---

matcher.cc

/*
*  Name:      matcher.cc
*  Author:    Rafael Jesus Alcantara Perez
*  Summary:   Regular expression matcher         
*  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 <cctype>
#include <cstdarg>
#include <cstdlib>
#include <cstring>
#include <mpcl/text/string.hh>
#include <mpcl/text/regex/matcher.hh>


//
//  L O C A L   M A C R O S
//

#define REM_SEPARATOR           "[[:space:]]"
#define REM_SEPARATOR_PLUS      REM_SEPARATOR "+"
#define REM_SEPARATOR_ASTERISK  REM_SEPARATOR "*"
#define REM_BLANK               "[[:blank:]]"
#define REM_BLANK_PLUS          REM_BLANK "+"
#define REM_BLANK_ASTERISK      REM_BLANK "*"
#define REM_ANY_ASTERISK        "[.]*"
#define REM_STRING              "%s"
#define REM_INTEGER             "%d"
#define REM_QUOTABLE_STRING     "%q"
#define REM_TEXT                "%t"
#define REM_EOF                 "<<EOF>>"


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

namespace mpcl
{

  namespace text
  {

    namespace regex
    {

      static const char*   _pkcAnyAsteriskPattern       = REM_ANY_ASTERISK;
      static const char*   _pkcBlankAsteriskPattern     = REM_BLANK_ASTERISK;
      static const char*   _pkcBlankPattern             = REM_BLANK;
      static const char*   _pkcBlankPlusPattern         = REM_BLANK_PLUS;
      static const char*   _pkcEofPattern               = REM_EOF;
      static const char*   _pkcIntegerPattern           = REM_INTEGER;
      static const char*   _pkcQuotableStringPattern    = REM_QUOTABLE_STRING;
      static const char*   _pkcSeparatorAsteriskPattern = REM_SEPARATOR_ASTERISK;
      static const char*   _pkcSeparatorPattern         = REM_SEPARATOR;
      static const char*   _pkcSeparatorPlusPattern     = REM_SEPARATOR_PLUS;
      static const char*   _pkcStringPattern            = REM_STRING;
      static const char*   _pkcTextPattern              = REM_TEXT;

      static std::size_t   _zAnyAsteriskPatternLength       = std::strlen (_pkcAnyAsteriskPattern);
      static std::size_t   _zBlankAsteriskPatternLength     = std::strlen (_pkcBlankAsteriskPattern);
      static std::size_t   _zBlankPatternLength             = std::strlen (_pkcBlankPattern);
      static std::size_t   _zBlankPlusPatternLength         = std::strlen (_pkcBlankPlusPattern);
      static std::size_t   _zEofPatternLength               = std::strlen (_pkcEofPattern);
      static std::size_t   _zIntegerPatternLength           = std::strlen (_pkcIntegerPattern);
      static std::size_t   _zQuotableStringPatternLength    = std::strlen (_pkcQuotableStringPattern);
      static std::size_t   _zSeparatorAsteriskPatternLength = std::strlen (_pkcSeparatorAsteriskPattern);
      static std::size_t   _zSeparatorPatternLength         = std::strlen (_pkcSeparatorPattern);
      static std::size_t   _zSeparatorPlusPatternLength     = std::strlen (_pkcSeparatorPlusPattern);
      static std::size_t   _zStringPatternLength            = std::strlen (_pkcStringPattern);
      static std::size_t   _zTextPatternLength              = std::strlen (_pkcTextPattern);

    }  // namespace regex

  }  // namespace text

}  // namespace mpcl

#undef REM_SEPARATOR
#undef REM_SEPARATOR_PLUS
#undef REM_SEPARATOR_ASTERISK
#undef REM_BLANK
#undef REM_BLANK_PLUS
#undef REM_BLANK_ASTERISK
#undef REM_ANY_ASTERISK
#undef REM_STRING
#undef REM_INTEGER
#undef REM_QUOTABLE_STRING
#undef REM_TEXT
#undef REM_EOF


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

void mpcl::text::regex::TMatcher::
clearDefinitions (void)
{
  
  tTerminalMap.clear();
  
}  // clearDefinitions()


void mpcl::text::regex::TMatcher::
clearStream (void)
{

  if ( gLocalStream )
  {
    if ( !ptSourceIstream )
    {
      throw TNoStreamException ("bad stream", __FILE__, __LINE__);
    }
    else
    {
      delete ptSourceIstream;
    }
    ptSourceIstream = NULL;
    
    gLocalStream = false;
  }

}  // clearStream()


void mpcl::text::regex::TMatcher::
define ( const char* pkcTERMINAL   ,
         const char* pkcDEFINITION )
{
  
  tTerminalMap.bind (pkcTERMINAL, pkcDEFINITION);
  
}  // define()


bool mpcl::text::regex::TMatcher::
match (const char* pkcPATTERN_STRING) const
{
  
  bool   gSuccess = false;
  
  if ( !ptSourceIstream )
  {
    throw TNoStreamException ("bad stream", __FILE__, __LINE__);
  }
  else
  {
    std::ios::iostate   tInitialIostate   = ptSourceIstream->rdstate();
    std::streampos      tInitialStreampos = ptSourceIstream->tellg();
    
    gSuccess = ( scan (pkcPATTERN_STRING, NULL) > 0 );
    if ( gSuccess )
    {
      //
      //  Only if there are matched chars (the pointer has moved),
      //  then it recovers the old stream state.
      //
      ptSourceIstream->seekg (tInitialStreampos);
      ptSourceIstream->clear (tInitialIostate);
    }
  }
  return gSuccess;
  
}  // match()


void mpcl::text::regex::TMatcher::
redefine ( const char* pkcTERMINAL   , 
           const char* pkcDEFINITION )
{
  
  tTerminalMap [pkcTERMINAL] = pkcDEFINITION;
  
}  // redefine()


std::size_t mpcl::text::regex::TMatcher::
scan (const char* pkcPATTERN_STRING...) const
{

  using std::size_t;
  using std::streampos;
  using std::string;
  
  size_t   zTotalMatchedChars = 0;
  
  if ( !ptSourceIstream )
  {
    throw TNoStreamException ("bad stream", __FILE__, __LINE__);
  }
  else
  {
    //
    //  pyArgument:      Pointer to a string (std::string) argument.
    //  piArgument:      Pointer to a integer (int) argument.
    //  gMoreArguments:  Boolean with the successfulness of the last
    //                   call to va_arg().
    //
    
    va_list             tVa_list;
    int                 iNextCharacter;
    bool                gMoreArguments    = true;
    TString             yPatternInstance  = instantiate (pkcPATTERN_STRING);
    char*               pcPatternIterator = (char*) yPatternInstance.c_str();
    std::ios::iostate   tInitialIostate   = ptSourceIstream->rdstate();
    std::streampos      tInitialStreampos = ptSourceIstream->tellg();
    string*             pyArgument        = NULL;
    int*                piArgument        = NULL;
    
    va_start (tVa_list, pkcPATTERN_STRING);
    while ( *pcPatternIterator && ptSourceIstream->good() )
    {
      iNextCharacter = ptSourceIstream->peek();
      if ( iNextCharacter == EOF )
      {
        break;
      }
      
      //
      //  _pkcSeparatorPlusPattern
      //
      if ( !strncmp ( _pkcSeparatorPlusPattern     ,
                      pcPatternIterator            ,
                      _zSeparatorPlusPatternLength ) )
      {
        if ( !isspace (iNextCharacter) )
        {
          break;
        }
        else
        {
          ptSourceIstream->get();
          ++zTotalMatchedChars;
          while ( isspace (ptSourceIstream->peek()) )
          {
            ptSourceIstream->get();
            ++zTotalMatchedChars;
          }      
          pcPatternIterator += _zSeparatorPlusPatternLength;
          continue;
        }
      }
      //
      //  _pkcSeparatorAsteriskPattern
      //
      if ( !strncmp ( _pkcSeparatorAsteriskPattern     ,
                      pcPatternIterator                ,
                      _zSeparatorAsteriskPatternLength ) )
      {
        while ( isspace (ptSourceIstream->peek()) )
        { 
          ptSourceIstream->get();
          ++zTotalMatchedChars;
        }
        pcPatternIterator += _zSeparatorAsteriskPatternLength;
        continue;      
      }
      //
      //  _pkcSeparatorPattern
      //
      if ( !strncmp ( _pkcSeparatorPattern     ,
                      pcPatternIterator        ,
                      _zSeparatorPatternLength ) )
      {
        if ( !isspace (ptSourceIstream->peek()) )
        {
          break;
        }
        else
        {
          ptSourceIstream->get();
          ++zTotalMatchedChars;
          pcPatternIterator += _zSeparatorPatternLength;
          continue;
        }
      }
      //
      //  _pkcBlankPlusPattern
      //
      if ( !strncmp (_pkcBlankPlusPattern, pcPatternIterator, _zBlankPlusPatternLength) )
      {
        if ( ( iNextCharacter != ' ' ) && ( iNextCharacter != '\t' ) )
        {
          break;
        }
        else
        {
          ptSourceIstream->get();
          ++zTotalMatchedChars;
          iNextCharacter = ptSourceIstream->peek();
          while ( ( iNextCharacter == ' ' ) || ( iNextCharacter == '\t') )
          {
            ptSourceIstream->get();
            iNextCharacter = ptSourceIstream->peek();
            ++zTotalMatchedChars;
          }
          pcPatternIterator += _zBlankPlusPatternLength;
          continue;
        }
      }
      //
      //  _pkcBlankAsteriskPattern
      //
      if ( !strncmp ( _pkcBlankAsteriskPattern     ,
                      pcPatternIterator            ,
                      _zBlankAsteriskPatternLength ) )
      {
        while ( ( iNextCharacter == ' ' ) || ( iNextCharacter == '\t') )
        {
          ptSourceIstream->get();
          iNextCharacter = ptSourceIstream->peek();
          ++zTotalMatchedChars;
        }
        pcPatternIterator += _zBlankAsteriskPatternLength;
        continue;      
      }
      //
      //  _pkcAnyAsteriskPattern
      //
      if ( !strncmp (_pkcAnyAsteriskPattern, pcPatternIterator, _zAnyAsteriskPatternLength) )
      {
        const char*   pkcNextPattern = pcPatternIterator + _zAnyAsteriskPatternLength;
        
        if ( *pkcNextPattern )
        {
          while ( ( iNextCharacter != EOF ) && !match (pkcNextPattern) )
          { 
            ptSourceIstream->get();
            iNextCharacter = ptSourceIstream->peek();
            ++zTotalMatchedChars;
          }
        }
        else
        {
          //
          //  If this is the last pattern, then it matches all
          //  characters till the end of stream.
          //
          while ( iNextCharacter != EOF )
          { 
            ptSourceIstream->get();
            iNextCharacter = ptSourceIstream->peek();
            ++zTotalMatchedChars;
          }
        }
        pcPatternIterator = (char*) pkcNextPattern;
        continue;      
      }
      //
      //  _pkcBlankPattern
      //
      if ( !strncmp (_pkcBlankPattern, pcPatternIterator, _zBlankPatternLength) )
      {
        if ( ( iNextCharacter != ' ' ) && ( iNextCharacter != '\t' ) )
        {
          break;
        }
        else
        {
          ptSourceIstream->get();
          ++zTotalMatchedChars;
          pcPatternIterator += _zBlankPatternLength;
          continue;
        }
      }
      //
      //  _pkcEofPattern
      //
      if ( !strncmp (_pkcEofPattern, pcPatternIterator, _zEofPatternLength) )
      {
        //
        //  If matcher reaches this point then input is not matching.
        //
        break;
      }
      //
      //  _pkcStringPattern
      //
      if ( !strncmp (_pkcStringPattern, pcPatternIterator, _zStringPatternLength) )
      {
        string   yMatched;
        
        while ( ( isalnum (iNextCharacter) ) ||
                ( iNextCharacter == '_' )    ||
                ( iNextCharacter == '-' )    ||
                ( iNextCharacter == '.' )     )
        {
          yMatched       += ptSourceIstream->get();
          iNextCharacter  = ptSourceIstream->peek();
          ++zTotalMatchedChars;
        }
        pcPatternIterator += _zStringPatternLength;
        if ( gMoreArguments )
        {
          pyArgument     = va_arg (tVa_list, string*);
          gMoreArguments = ( pyArgument != NULL );
          if ( gMoreArguments )
          { 
            *pyArgument = yMatched;
          }
        }
        continue;
      }
      //
      //  _pkcIntegerPattern
      //
      if ( !strncmp (_pkcIntegerPattern, pcPatternIterator, _zIntegerPatternLength) )
      {
        TString   yMatched;
        
        while ( isdigit (iNextCharacter) )
        {
          yMatched       += ptSourceIstream->get();
          iNextCharacter  = ptSourceIstream->peek();
          ++zTotalMatchedChars;
        }
        pcPatternIterator += _zStringPatternLength;
        if ( gMoreArguments )
        {
          piArgument     = va_arg (tVa_list, int*);
          gMoreArguments = ( piArgument != NULL );
          if ( gMoreArguments )
          { 
            *piArgument = atoi (yMatched.c_str());
          }
        }
        continue;
      }
      //
      //  _pkcQuotableStringPattern
      //
      if ( !strncmp ( _pkcQuotableStringPattern     , 
                      pcPatternIterator             , 
                      _zQuotableStringPatternLength ) )
      {
        TString   yMatched;
        
        iNextCharacter = ptSourceIstream->peek();
        if ( iNextCharacter == EOF )
        {
          continue;
        }
        else
        {
          if ( iNextCharacter != '"' )
          {
            //
            //  Not-quoted string case.
            //
            while ( ( isalnum (iNextCharacter) ) ||
                    ( iNextCharacter == '_' )    ||
                    ( iNextCharacter == '-' )    ||
                    ( iNextCharacter == '.' )     )
            { 
              yMatched       += ptSourceIstream->get();
              iNextCharacter  = ptSourceIstream->peek();
              ++zTotalMatchedChars;
            }
          }
          else
          {
            //
            //  Quoted string case.
            //
            ptSourceIstream->get();
            ++zTotalMatchedChars;
            iNextCharacter = ptSourceIstream->peek();
            while ( ( iNextCharacter != '"' ) && ( iNextCharacter != EOF ) )
            { 
              yMatched       += ptSourceIstream->get();
              iNextCharacter  = ptSourceIstream->peek();
              ++zTotalMatchedChars;
            }
            if ( iNextCharacter != '"' )
            {
              break;
            }
            else
            {
              ptSourceIstream->get();
              ++zTotalMatchedChars;
            }
          }
          pcPatternIterator += _zQuotableStringPatternLength;
          if ( gMoreArguments )
          {
            pyArgument     = va_arg (tVa_list, string*);
            gMoreArguments = ( pyArgument != NULL );
            if ( gMoreArguments )
            { 
              *pyArgument = yMatched;
            }
          }
          continue;
        }
      }
      //
      //  _pkcTextPattern
      //
      if ( !strncmp (_pkcTextPattern, pcPatternIterator, _zTextPatternLength) )
      {
        TString       yMatched;
        const char*   pkcNextPattern = pcPatternIterator + _zTextPatternLength;
        
        if ( *pkcNextPattern )
        {
          while ( ( iNextCharacter != EOF ) && !match (pkcNextPattern) )
          { 
            yMatched       += ptSourceIstream->get();
            iNextCharacter  = ptSourceIstream->peek();
            ++zTotalMatchedChars;
          }
        }
        else
        {
          //
          //  If this is the last pattern, then it matches all
          //  characters till the end of stream.
          //
          while ( iNextCharacter != EOF )
          { 
            yMatched       += ptSourceIstream->get();
            iNextCharacter  = ptSourceIstream->peek();
            ++zTotalMatchedChars;
          }
        }
        pcPatternIterator = (char*) pkcNextPattern;
        if ( gMoreArguments )
        {
          pyArgument     = va_arg (tVa_list, string*);
          gMoreArguments = ( pyArgument != NULL );
          if ( gMoreArguments )
          { 
            *pyArgument = yMatched;
          }
        }
        continue;      
      }
      
      //
      //  Simple character matching.
      //
      if ( iNextCharacter != EOF )
      {
        if ( matchChars (iNextCharacter, pcPatternIterator) )
        {
          ++zTotalMatchedChars;
          ptSourceIstream->get();
        }
        else
        {
          if ( *(pcPatternIterator + 1) != '?' )
          {
            break;
          }
        }
        if ( *(pcPatternIterator + 1) == '?' )
        {
          ++pcPatternIterator;
        }
        ++pcPatternIterator;
      }
    }
    if ( *pcPatternIterator )
    {
      //
      //  _pkcEofPattern:  Must be the last pattern.
      //
      if ( !strcmp (_pkcEofPattern, pcPatternIterator) )
      {
        if ( iNextCharacter != EOF )
        { 
          zTotalMatchedChars = 0;
          ptSourceIstream->seekg (tInitialStreampos);
          ptSourceIstream->clear (tInitialIostate);
        }
      }
      else
      {
        zTotalMatchedChars = 0;
        ptSourceIstream->seekg (tInitialStreampos);
        ptSourceIstream->clear (tInitialIostate);
      }
    }
    va_end (tVa_list);
  }
  return zTotalMatchedChars;
  
}  // scan()


void mpcl::text::regex::TMatcher::
setCaseSensitiveness (bool gTRUTH)
{
  
  gCaseSensitive = gTRUTH;
  
}  // setCaseSensitiveness()


void mpcl::text::regex::TMatcher::
setInput (const char* pkcSTRING)
{

  clearStream();
  ptSourceIstream = new std::basic_istringstream<char> (pkcSTRING);
  gLocalStream    = true;
  if ( pkcSTRING && std::strlen (pkcSTRING) )
  {
    checkStream();
  }

}  // setInput()


void mpcl::text::regex::TMatcher::
setInput (std::basic_istream<char>& rtSOURCE_ISTREAM)
{
  
  clearStream();
  ptSourceIstream = &rtSOURCE_ISTREAM;
  checkStream();
  
}  // setInput()


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

void mpcl::text::regex::TMatcher::
checkStream (void) const
{

  if ( ptSourceIstream )
  {
    if ( !ptSourceIstream->eof() )
    {
      //
      //  Checks that the stream is  repositionable (and it is not yet at the end
      //  of the stream).
      //
      if ( EOF == ptSourceIstream->rdbuf()->pubseekoff (0, std::ios_base::cur, std::ios_base::in) )
      {
        throw TNotRePositionableStreamException ("bad stream", __FILE__, __LINE__);
      }
    }
  }

}  // checkStream()


mpcl::text::TString mpcl::text::regex::TMatcher::
instantiate (const char* pkcPATTERN_STRING) const
{

  TStringToStringMap::const_iterator   ktIter = tTerminalMap.begin();
  TStringToStringMap::const_iterator   ktEnd  = tTerminalMap.end();
  TString                              yInstance (pkcPATTERN_STRING);
  
  for (; ( ktIter != ktEnd ) ;++ktIter)
  {
    yInstance.replaceAll (ktIter->first, ktIter->second);
  }
  return yInstance;
  
}  // instantiate()


bool mpcl::text::regex::TMatcher::
matchChars (char cSOURCE, const char* pkcPATTERN_STRING) const
{
  
  bool   gSuccess;
  
  if ( gCaseSensitive )
  {
    gSuccess = ( *pkcPATTERN_STRING == cSOURCE );
  }
  else
  {
    gSuccess = ( tolower (*pkcPATTERN_STRING) == tolower (cSOURCE) );
  }
  return gSuccess;
  
}  // matchChars()

---