---

string.cc

/*
*  Name:      string.cc
*  Author:    Rafael Jesus Alcantara Perez
*  Summary:   String
*  Date:      $Date: 2003/04/14 00:18:35 $
*  Revision:  $Revision: 1.1 $
*
*  Copyright (C) 1994-2002  Rafael Jesus Alcantara Perez <rafa@dedalo-ing.com>
*
*  This program 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.
*/

#include <cstdarg>
#include <cstdio>
#include <mpcl/text/string.hh>

#ifdef HAVE_VSNPRINTF


//
//  E X P O R T E D   F U N C T I O N S
//

const char* mpcl::text::
BoolToString (bool gTRUTH, const char* pkcTRUE, const char* pkcFALSE)
{

  return ( gTRUTH ) ? pkcTRUE : pkcFALSE;

}  // BoolToString()


mpcl::text::TString mpcl::text::
Format (const char* pkcFORMAT...)
{

  using std::free;
  using std::malloc;
  using std::realloc;
  
  TString   yTarget;
  
  if ( pkcFORMAT )
  {
    va_list           tVa_list;
    register int      iChars              = -1;
    register size_t   zSize               = 1024;
    register char*    pcBuffer            = NULL;
    register char*    pcReallocatedBuffer = (char*) malloc (zSize);
    
    //
    //  Initializes the variable argument list.
    //  While the reserved buffer  doesn't  have the minimum size tries to hold
    //  the whole string, continues trying.
    //  
    //  Warning:  It  should  be  used  a boolean variable to  check  the  exit
    //            condition,  but for performance reasons it has  been removed.
    //
    while ( pcReallocatedBuffer )
    {
      va_start (tVa_list, pkcFORMAT);
      pcBuffer = pcReallocatedBuffer;
      iChars   = vsnprintf (pcBuffer, zSize, pkcFORMAT, tVa_list);
      va_end (tVa_list);

      //
      //  In GLIBC 2.0 it returns -1 if  there isn't space, but in GLIBC 2.1 it
      //  returns the characters that it would needed.
      //  Standard  function  'std::realloc()' doesn't free the  buffer  if  it
      //  can't reallocate the space, so it is needed to free that buffer, even
      //  if the last 'std::realloc()' has failed.
      //
      if ( iChars <= -1 )
      {
        //
        //  GLIBC 2.0.x version of function 'std::vsnprintf()'.
        //
        zSize               *= 2;
        pcReallocatedBuffer  = (char*) realloc (pcBuffer, zSize);
      }
      else if ( ((size_t) iChars) >= zSize )
      {
        //
        //  GLIBC 2.1.x (ISO C9X) version of function 'std::vsnprintf()'.
        //
        zSize               = iChars + 1;
        pcReallocatedBuffer = (char*) realloc (pcBuffer, zSize);
      }
      else
      {
        break;
      }
    }
    if ( pcBuffer )
    {
      if ( pcReallocatedBuffer )
      {
        yTarget = pcReallocatedBuffer;
      }
      free (pcBuffer);
    }
  }
  return yTarget;
  
}  // Format()


#else  // not HAVE_VSNPRINTF

#include <mpcl/automaton/deterministic_finite_automaton.hh>


namespace mpcl
{

  namespace text
  {

    enum ESpecialSymbol
    {
      any_char              = -1 ,
      digit                 = -2 ,
      other_convertors      = -3 ,
      other_convertors_real = -4
    };

    enum EState
    {
      initial_state              ,
      prepoint_number_state      ,
      point_number_state         ,
      postpoint_number_state     ,
      conversion_specifier_state ,
      final_percent_symbol_state ,
      final_string_state         ,
      final_state                ,
      l_state                    ,
      L_state
    };


    template <typename TState, typename TEvent>
    class TDirectiveDFA : public automaton::TDeterministicFiniteAutomaton<TState, TEvent>
    {

      public:

        //
        //  C O N S T R U C T O R S
        //

        TDirectiveDFA (void);


      public:

        //
        //  S E L E C T O R S
        //

        bool next ( TState  tSOURCE_STATE  ,
                    TEvent  tSOURCE_EVENT  ,
                    TState& rtTARGET_STATE ) const;

    };  // class TDirectiveDFA


    //
    //  L O C A L   F U N C T I O N S
    //

    static const char* _TranslateDirective ( const char*   pkcDIRECTIVE     ,
                                             std::va_list& rtSOURCE_VA_LIST ,
                                             TString&      ryTARGET_STRING  );

  }  // namespace text

}  // namespace mpcl


//
//  C O N S T R U C T O R S
//

template <typename TState, typename TEvent>
mpcl::text::TDirectiveDFA<TState, TEvent>::TDirectiveDFA (void) :
  mpcl::text::TDeterministicFiniteAutomaton<TState, TEvent> ()
{
  
# define ADD_TRANS(iSTATE, iEVENT, iNEXT_STATE) \
    tTransitionMap.bind (make_pair (iSTATE, iEVENT), iNEXT_STATE)

  tCurrentState = initial_state;
  tInitialState = initial_state;
  ADD_TRANS (initial_state, digit,    prepoint_number_state);
  ADD_TRANS (initial_state, '.',      point_number_state);
  ADD_TRANS (initial_state, '%',      final_percent_symbol_state);
  ADD_TRANS (initial_state, any_char, conversion_specifier_state);
  
  ADD_TRANS (conversion_specifier_state, 's',                   final_string_state);
  ADD_TRANS (conversion_specifier_state, 'c',                   final_state);
  ADD_TRANS (conversion_specifier_state, other_convertors,      final_state);
  ADD_TRANS (conversion_specifier_state, other_convertors_real, final_state);
  ADD_TRANS (conversion_specifier_state, 'l',                   l_state);
  ADD_TRANS (conversion_specifier_state, 'L',                   L_state);
  
  ADD_TRANS (prepoint_number_state, digit,    prepoint_number_state);
  ADD_TRANS (prepoint_number_state, '.',      point_number_state);
  ADD_TRANS (prepoint_number_state, any_char, conversion_specifier_state);
  
  ADD_TRANS (point_number_state, digit,    postpoint_number_state);
  ADD_TRANS (point_number_state, any_char, conversion_specifier_state);
  
  ADD_TRANS (postpoint_number_state, digit,    postpoint_number_state);
  ADD_TRANS (postpoint_number_state, any_char, conversion_specifier_state);
  
  ADD_TRANS (l_state, other_convertors,      final_state);
  ADD_TRANS (L_state, other_convertors_real, final_state);

# undef ADD_TRANS
  
}  // TDirectiveDFA()


template <typename TState, typename TEvent>
bool mpcl::text::TDirectiveDFA<TState, TEvent>::
next ( TState  tSOURCE_STATE  ,
       TEvent  tSOURCE_EVENT  ,
       TState& rtTARGET_STATE ) const
{

  typename TTransitionMap::const_iterator   I;
  bool                                      gSuccess;
  
  I        = tTransitionMap.find (make_pair (tSOURCE_STATE, tSOURCE_EVENT));
  gSuccess = ( I != tTransitionMap.end() );
  if ( gSuccess )
  {
    rtTARGET_STATE = I->second;
  }
  return gSuccess;

}  // next()


//
//  L O C A L   V A R I A B L E S
//

static const mpcl::text::TDirectiveDFA<int, int>   _ktDirectiveDFA;


//
//  L O C A L   F U N C T I O N S
//

static const char* mpcl::text::text::
_TranslateDirective ( const char*   pkcDIRECTIVE     ,
                      std::va_list& rtSOURCE_VA_LIST ,
                      TString&      ryTARGET_STRING  )
{

  char            acBuffer [1024];
  register bool   gFound;
  register bool   gEatChar;
  register int    iNextState;
  register int    iEvent;
  register bool   gFinalState   = false;
  register int    iCurrentState = initial_state;
  TString         yDirective    = "%";

  //
  //  Steps over introducer character ('%') and initializes map.
  //
  while ( !gFinalState )
  {
    //
    //  Groups input chars on special symbols (if any).
    //
    switch (*pkcDIRECTIVE)
    {
      case '0':
      case '1':
      case '2':
      case '3':
      case '4':
      case '5':
      case '6':
      case '7':
      case '8':
      case '9':
      {
        iEvent = (int) digit;
        break;
      }
      case 'd':
      case 'i':
      case 'u':
      case 'x':
      {
        iEvent = (int) other_convertors;
        break;
      }
      case 'f':
      case 'e':
      {
        iEvent = (int) other_convertors_real;
        break;
      }
      default:
      {
        iEvent = *pkcDIRECTIVE;
      }
    }
    
    //
    //  Find next state (if any).
    //
    gFound = _ktDirectiveDFA.next (iCurrentState, iEvent, iNextState);
    if ( gFound )
    {
      gEatChar = true;
    }
    else
    {
      gFound   = _ktDirectiveDFA.next (iCurrentState, any_char, iNextState);
      gEatChar = !gFound;
    }
    switch (iCurrentState)
    {
      case conversion_specifier_state:
      case initial_state:
      case point_number_state:
      case prepoint_number_state:
      case postpoint_number_state:
      case l_state:
      case L_state:
      {
        if ( gEatChar )
        {
          yDirective.append (1, *pkcDIRECTIVE);
          ++pkcDIRECTIVE;
        }
        break;
      }
      case final_string_state:
      {
        ryTARGET_STRING.append (va_arg (rtSOURCE_VA_LIST, const char*));
        gFinalState = true;
        break;
      }
      case final_state:
      {
        vsprintf (acBuffer, yDirective.c_str(), rtSOURCE_VA_LIST);
        ryTARGET_STRING.append (acBuffer);
        gFinalState = true;
        break;
      }
      case final_percent_symbol_state:
      {
        ryTARGET_STRING.append (1, '%');
        gFinalState = true;
        break;
      }
    }
    if ( gFound )
    {
      iCurrentState = iNextState;
    }
    else if ( gFinalState )
    {
      break;
    }
    else
    {
      throw TConstraintException ("unrecognized directive", __FILE__, __LINE__);
    }
  }
  return pkcDIRECTIVE;
  
}  // _TranslateDirective()


//
//  E X P O R T E D   F U N C T I O N S
//

mpcl::text::TString mpcl::text::
Format (const char* pkcFORMAT...)
{
  
  TString   yTarget;
  
  if ( pkcFORMAT )
  {
    register const char*   pkcIter;
    va_list                tVa_list;
    register const char*   pkcChunkBegin = pkcFORMAT;

    va_start (tVa_list, pkcFORMAT);

    //
    //  While it founds directive intruducer, append plain chunks
    //  and translates directives.
    //
    while ( NULL != (pkcIter = strchr (pkcChunkBegin, '%')) )
    {
      yTarget.append (pkcChunkBegin, pkcIter - pkcChunkBegin);
      pkcChunkBegin = _TranslateDirective (pkcIter + 1, tVa_list, yTarget);
    }
    yTarget.append (pkcChunkBegin);
    va_end (tVa_list);
  }
  return yTarget;
  
}  // Format()


#endif  // not HAVE_VSNPRINTF

---