---

utils.cpp

Go to the documentation of this file.

//============================================================================= 
//
// XDFLengine library
//
//----------------------------------------------------------------------------- 
//  UTILS.CPP
//----------------------------------------------------------------------------- 
//_____________________________________________________________________________
//
//  Copyright (C) 2003 Guillaume Baurand. All Rights Reserved.
//
//  This file is part of the XDFLengine project.
//
//  The XDFLengine is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2 of the License, or
//  (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,
//  USA.
//
//  For more information, 
//      contact  : guillaume@baurand.net 
//      or visit : http://xdflengine.sourceforge.net
//
//============================================================================= 

#   include <ctype.h>
// Xerces
#   include "xercesc/sax2/XMLReaderFactory.hpp"
#   include "xercesc/sax2/SAX2XMLReader.hpp"



#   include "utils.hpp"
#   include <time.h>
 
BEGIN_XDFLENGINE_NS

// XML STRING

    //_____________________________________________________________________
    //  XSTR
    //---------------------------------------------------------------------
    char* XSTR(const XMLCh* totrans,char* p_pszBuffer)
    {
        //DEBUG_FUNC(XSTR)
        unsigned int    l_uiLen;
        
        l_uiLen = XMLString::stringLen( totrans);
        if(!p_pszBuffer) p_pszBuffer = allocCharBuffer( l_uiLen);
        XMLString::transcode( totrans, p_pszBuffer, l_uiLen);

        return p_pszBuffer;
    }


    //_____________________________________________________________________
    //  XSTR
    //---------------------------------------------------------------------
    char* XSTR(XMLTranscoder* fXCoder, const XMLCh* const toFormat, const unsigned int count, char* p_pszBuffer)
    {

        unsigned int    charsEaten;

        if(!p_pszBuffer) p_pszBuffer = allocCharBuffer( count*2+2);
        const unsigned int outBytes = fXCoder->transcodeTo
        (
            toFormat
            , count
            , (unsigned char*)p_pszBuffer
            , count*2
            , charsEaten
            , XMLTranscoder::UnRep_RepChar
        );
        p_pszBuffer[ outBytes]='\0'; 
        return p_pszBuffer;

    }

    //_____________________________________________________________________
    //  XSTR
    //---------------------------------------------------------------------
    char* XSTR(XMLTranscoder* fXCoder, const XMLCh* const toFormat, char* p_pszBuffer)
    {

        return XSTR(fXCoder, toFormat,XMLString::stringLen(toFormat), p_pszBuffer);
    }

    //_____________________________________________________________________
    //  STRX
    //---------------------------------------------------------------------
    XMLCh* STRX(const char* totrans)
    {
        //DEBUG_FUNC(XSTR)
        return XMLString::transcode(totrans);
    }

    //_____________________________________________________________________
    //  CORRECTATTRVALUE
    //---------------------------------------------------------------------
    char* correctAttrValue(const char* src)
    {
        char* l_pszTmp;
        char* l_pszTmp2;

        l_pszTmp = replaceInCharBuffer( src,"<","&lt;");
        l_pszTmp2 = replaceInCharBuffer( l_pszTmp,">","&gt;");
        l_pszTmp = releaseCharBuffer( l_pszTmp);
        return l_pszTmp2;
    }


// SAX 

    //_____________________________________________________________________
    //  SAX_PARSEXML
    //---------------------------------------------------------------------
    void SAX_parseXML(InputSource* p_pXMLDOM_inputSrc ,ContentHandler* p_pXMLSAX_handlers, ErrorHandler* p_pErrHandler )
    {
        //---------------------------------------------------------------------
        SAX2XMLReader*          l_pXMLSAX_parser=0;
        //---------------------------------------------------------------------

        DEBUG_IN(SAX_parseXML)
        
        //  Create a SAX parser object. 
        l_pXMLSAX_parser = XMLReaderFactory::createXMLReader();  

        l_pXMLSAX_parser->setFeature( XMLUni::fgXercesContinueAfterFatalError, false);
        l_pXMLSAX_parser->setFeature( XMLUni::fgXercesDynamic, true);
        l_pXMLSAX_parser->setFeature( XMLUni::fgXercesSchema, false);
        l_pXMLSAX_parser->setFeature( XMLUni::fgXercesSchemaFullChecking, false);
         
        l_pXMLSAX_parser->setFeature( XMLUni::fgSAX2CoreValidation, true);
        l_pXMLSAX_parser->setFeature( XMLUni::fgSAX2CoreNameSpaces, true);
        l_pXMLSAX_parser->setFeature( XMLUni::fgSAX2CoreNameSpacePrefixes, true);
         

        // Give handler to the parser
        l_pXMLSAX_parser->setContentHandler( p_pXMLSAX_handlers);
        l_pXMLSAX_parser->setErrorHandler  ( p_pErrHandler);

        // Parse !
        l_pXMLSAX_parser->parse( *p_pXMLDOM_inputSrc);

        // Release objects
        delete l_pXMLSAX_parser;
              
        DEBUG_OUT(SAX_parseXML)
    };


    //_____________________________________________________________________
    //  SAX_GETATTRVALUE
    //---------------------------------------------------------------------
    char* SAX_getAttrValue(const Attributes& p_attrs,const char * p_pzName, const char* p_pszDefValue,char* p_pzBuffer)
    {
        int l_iIndex;
        XMLCh*  l_pxmlchTmp;

        l_pxmlchTmp = STRX( p_pzName);
        l_iIndex = p_attrs.getIndex( l_pxmlchTmp);
        XMLString::release( &l_pxmlchTmp);

        if( l_iIndex>-1 )
        {
            return XSTR(p_attrs.getValue( l_iIndex), p_pzBuffer);
        }
        else
        {
            if(! p_pzBuffer) return copyCharBuffer( p_pszDefValue);
            else
            {
                strcpy( p_pzBuffer, p_pszDefValue);
                return p_pzBuffer;
            }
        }
    }

// STRING PROCESSING

    //_____________________________________________________________________
    //  UPPERIZE
    //---------------------------------------------------------------------
    void upperize(char* cTxt)
    {
        for(unsigned int i=0; i<strlen(cTxt); i++) cTxt[i]=toupper(cTxt[i]);
    }
    void lowerize(char* cTxt)
    {
        for(unsigned int i=0; i<strlen(cTxt); i++) cTxt[i]=tolower(cTxt[i]);
    }

    
    //_____________________________________________________________________
    //  GETTIMESTRING
    //--------------------------------------------------------------------- 
    char* getTimeString(const char* p_cExpression)
    {

        time_t          start_time;
        struct tm       tm_start;
        char *          psDate;
        int             l_iSec;
        int             l_iMin;
        int             l_iHour;
        int             l_iDay;
        int             l_iMonth;
        int             l_iYear;        

        start_time = time(0);
        tm_start   = *localtime(&start_time);

        l_iYear =   1900+tm_start.tm_year ;
        l_iMonth =  tm_start.tm_mon+1 ;
        l_iDay =    tm_start.tm_mday ;
        l_iHour =   tm_start.tm_hour ;
        l_iMin =    tm_start.tm_min ;
        l_iSec =    tm_start.tm_sec ;


        psDate=(char*)  allocCharBuffer(40);

        if( ! strcmp(p_cExpression, DATEFORMAT_USER))
        {   // jj/mm/aaaa hh:mm:ss
            sprintf(psDate,     "%02d/%02d/%04d",       l_iDay, l_iMonth, l_iYear);
            sprintf(psDate+10,  " %02d:%02d:%02d",      l_iHour, l_iMin, l_iSec);
        }

        if( ! strcmp(p_cExpression, DATEFORMAT_FILE))
        {   // aaaammjj_hhmmss
            sprintf( psDate,    "%04d%02d%02d",         l_iYear, l_iMonth, l_iDay);
            sprintf( psDate+8,  "_%02d%02d%02d",        l_iHour, l_iMin, l_iSec);
        }

        if( ! strcmp(p_cExpression, DATEFORMAT_SQL))
        {   // aaaa-mm-ss hh:mm:ss
            sprintf( psDate,    "%04d-%02d-%02d",       l_iYear, l_iMonth, l_iDay);
            sprintf( psDate+10, " %02d:%02d:%02d",      l_iHour, l_iMin, l_iSec);
        }

        return psDate;
    }   



    //_____________________________________________________________________
    //  ALLOCCHARBUFFER
    //--------------------------------------------------------------------- 
    char* allocCharBuffer(unsigned int p_uiSize)
    {
        //if(p_uiSize<50) p_uiSize=50;
        //DEBUG_CREATE(charBuffer)
        return (char*) malloc( p_uiSize+1);
    }

    //_____________________________________________________________________
    //  RELEASECHARBUFFER
    //--------------------------------------------------------------------- 
    char* releaseCharBuffer(char* p_pszBuffer)
    {
        free( p_pszBuffer);
        //DEBUG_DEL(charBuffer)
        return (char*) 0;
    }

    //_____________________________________________________________________
    //  COPYCHARBUFFER
    //--------------------------------------------------------------------- 
    char* copyCharBuffer(const char* p_pszBuffer)
    {
        //------------------------------------------------------------------
        char*   l_pszNewBuffer = 0;
        //------------------------------------------------------------------

        if( p_pszBuffer)
        {
            l_pszNewBuffer = allocCharBuffer( strlen( p_pszBuffer));
            strcpy( l_pszNewBuffer, p_pszBuffer);
        }
        return l_pszNewBuffer;
    }

    //---------------------------------------------------------------------
    //  TRIMCHARBUFFER
    //---------------------------------------------------------------------
    char* trimCharBuffer( const char* p_pszToTrim)
    {
        //-----------------------------------------------------------------
        char*           p_pszTrimmed;
        char            l_chChar;
        bool            l_fOK;
        unsigned int    i;
        unsigned int    l_uiOutIndex;
        unsigned int    l_uiToTrimLen;
        //-----------------------------------------------------------------
        
        l_uiToTrimLen = strlen( p_pszToTrim);
        p_pszTrimmed = allocCharBuffer( l_uiToTrimLen);
        l_fOK = false;
        l_uiOutIndex = 0;
        
        // Trim begin
        for (i=0 ; i < l_uiToTrimLen; i++)
        {
            l_chChar = p_pszToTrim[i];
            if ( ((unsigned char)l_chChar > 32) || (l_fOK) )
            {
                p_pszTrimmed[ l_uiOutIndex] = l_chChar;
                l_uiOutIndex++;
                l_fOK=true;
            }       
        }
        
        // Trim end         
        for (i=l_uiOutIndex ; i>0 ; i--)
        {
            l_chChar = p_pszTrimmed[i-1];
            if ( ((unsigned char)l_chChar) > 32) break;
        }
        p_pszTrimmed[i]='\0';
        
        return p_pszTrimmed;        
    }


    //_____________________________________________________________________
    //  IMPORTCHARBUFFER
    //--------------------------------------------------------------------- 
    char* importCharBuffer( char* p_pszOldBuffer,const char* p_pszNewBuffer)
    {
        char* l_pszBuffer;

        if( p_pszOldBuffer) 
        {
            if( strlen( p_pszOldBuffer) >= strlen( p_pszNewBuffer) )
            {
                strcpy( p_pszOldBuffer, p_pszNewBuffer);
                l_pszBuffer = p_pszOldBuffer;
            }
            else
            {
                l_pszBuffer = (char*) realloc( p_pszOldBuffer, strlen(p_pszNewBuffer)+1);
                strcpy( l_pszBuffer, p_pszNewBuffer);
            }
        }
        else
        {
            l_pszBuffer = copyCharBuffer( p_pszNewBuffer);  
        }

        return l_pszBuffer;
    }

    //_____________________________________________________________________
    //  EXPORTCHARBUFFER
    //--------------------------------------------------------------------- 
    const char* exportCharBuffer(char* l_pszBuffer)
    {
        return l_pszBuffer;
    }

    //_____________________________________________________________________
    //  CONCATCHARBUFFER
    //--------------------------------------------------------------------- 
    char* concatCharBuffer( char* p_pszBaseBuffer, const char* p_pszToAdd, unsigned int p_uiGrowSize)
    {
        unsigned int    l_uiBufSize;
        unsigned int    l_uiStrLen;
        unsigned int    l_uiAddLen;
        unsigned int    l_uiTotalLen;
        unsigned int    l_uiConcatSize;
        //unsigned int  l_uiNumGrows;
        char*           l_pszConcatBuf;

        if(p_pszToAdd)
        {
            l_uiAddLen = strlen( p_pszToAdd);

            if( p_pszBaseBuffer)
            {
                l_uiStrLen = strlen( p_pszBaseBuffer);
                //p_pszBaseBuffer[l_uiStrLen]=' ';
                l_uiBufSize = strlen(p_pszBaseBuffer);
            }
            else
            {
                l_uiBufSize = 0;
                l_uiStrLen = 0;
            }

            l_uiTotalLen = l_uiStrLen + l_uiAddLen;

            if( l_uiBufSize < l_uiTotalLen)
            {
                //l_uiNumGrows = (l_uiTotalLen - l_uiBufSize) / p_uiGrowSize + 1;
                //l_uiConcatSize = l_uiBufSize + p_uiGrowSize * l_uiNumGrows;
                l_uiConcatSize = l_uiTotalLen;
                l_pszConcatBuf = (char*) realloc( p_pszBaseBuffer, l_uiConcatSize+1);
                //memset( l_pszConcatBuf + l_uiStrLen,' ',l_uiTotalLen-l_uiStrLen);
                //l_pszConcatBuf[l_uiConcatSize]='\0';
            }
            else
            {
                if(p_pszBaseBuffer) l_pszConcatBuf = p_pszBaseBuffer;
                else l_pszConcatBuf = allocCharBuffer(1);
            }

            memcpy( l_pszConcatBuf + l_uiStrLen, p_pszToAdd, l_uiAddLen);   
            l_pszConcatBuf[l_uiStrLen+l_uiAddLen]='\0';
            return l_pszConcatBuf;
        }
        else return p_pszBaseBuffer;
    }


    //_____________________________________________________________________
    //  REPLACEINCHARBUFFER
    //---------------------------------------------------------------------
    char* replaceInCharBuffer(const char* src, const char *srch, const char *rpl)
    {
        const char *    p = NULL;
        char            c[2];
        size_t          srclen = 0;
        size_t          srchlen = 0;
        size_t          rpllen = 0;
        size_t          x = 0;
        char*           ret = 0;
        unsigned int    i=0;
            
        /* Initialize */

        ret=copyCharBuffer("");
        srclen= strlen( src);
        srchlen = strlen(srch);
        rpllen = strlen(rpl);
        c[1]='\0';

        for (i=0; i < srclen ; i++) 
        {
        
            p= (const char*) &(src[i]);
            if ( strncmp(p, srch, srchlen) == 0)
            {
                /* Match found, add replacement in */
                ret = concatCharBuffer( ret, rpl);          
                i += (srchlen - 1);
            } 
            else
            {
                /* No match, add single character back in */
                c[0]=(char)p[0];
                ret = concatCharBuffer( ret, &c[0]);
            }
        }

        return ret;
    }

END_XDFLENGINE_NS

---