---

clause_body_string.cc

/*
*  Name:      clause_body_string.cc
*  Author:    Rafael Jesus Alcantara Perez
*  Summary:   Clause-body 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 <mpcl/text/codegen/clause_body_string.hh>
#include <mpcl/text/regex/matcher.hh>


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

mpcl::text::codegen::TClauseBodyString& mpcl::text::codegen::TClauseBodyString::
operator = (const TClauseBodyString& rkySOURCE_CLAUSE_BODY)
{

  TString::operator = (rkySOURCE_CLAUSE_BODY);
  return *this;
  
}  // operator =()


void mpcl::text::codegen::TClauseBodyString::
read (std::basic_istream<char_type, traits_type>& rtSOURCE_ISTREAM)
{

  using text::regex::TMatcher;
  using std::basic_string;

  TMatcher   tMatcher (rtSOURCE_ISTREAM);
  
  tMatcher.setCaseSensitiveness (false);
  tMatcher.scan (pkcCLAUSE_BodyPattern, (basic_string<char>*) this, NULL);

}  // read()


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

mpcl::text::TString mpcl::text::codegen::TClauseBodyString::
instantiate ( const char* pkcFIRST_PARAMETER_NAME     ,
              const char* pkcFIRST_PARAMETER_VALUE... ) const
{
  
  //
  //  yParameterTag ::= <%><parameter><%>
  //
  
  const char*   pkcTag;
  const char*   pkcValue;
  va_list       tVa_list;
  TString       yParameterTag;
  TString       yInstance (preprocess());

  //
  //  Then, replace parameters.
  //
  yParameterTag = Format ("%%%s%%", pkcFIRST_PARAMETER_NAME);
  if ( !gParameterExistenceSensitiveness )
  {
    yInstance.replaceAll (yParameterTag, pkcFIRST_PARAMETER_VALUE);
    va_start (tVa_list, pkcFIRST_PARAMETER_VALUE);
    while ( NULL != (pkcTag = va_arg (tVa_list, char*)) )
    { 
      if ( NULL == (pkcValue = va_arg (tVa_list, char*)) )
      {
        throw TBadInstantiateSyntaxException ("you must give tag-value pairs", __FILE__, __LINE__);
      }
      else
      {
        yParameterTag = Format ("%%%s%%", pkcTag);
        yInstance.replaceAll (yParameterTag, pkcValue);
      }
    }
  }
  else
  {
    if ( !yInstance.replaceAll (yParameterTag, pkcFIRST_PARAMETER_VALUE) )
    {
      TString   yMessage = Format ( "there is no tag called '%s' in this clause code" ,
                                    pkcFIRST_PARAMETER_NAME                           );
      
      throw TBadInstantiateSyntaxException (yMessage, __FILE__, __LINE__);
    }
    else
    {
      va_start (tVa_list, pkcFIRST_PARAMETER_VALUE);
      while ( NULL != (pkcTag = va_arg (tVa_list, char*)) )
      { 
        if ( NULL == (pkcValue = va_arg (tVa_list, char*)) )
        {
          throw TBadInstantiateSyntaxException ("you must give tag-value pairs", __FILE__, __LINE__);
        }
        else
        {
          yParameterTag = Format ("%%%s%%", pkcTag);
          if ( !yInstance.replaceAll (yParameterTag, pkcValue) )
          {
            TString   yMessage = Format ("there is no tag called '%s' in this clause code", pkcTag);
              
            throw TBadInstantiateSyntaxException (yMessage, __FILE__, __LINE__);
          }
        }
      }
    }
  }
  return yInstance;
  
}  // instantiate()


mpcl::text::TString mpcl::text::codegen::TClauseBodyString::
instantiate ( const TStringToVariableMap& rktSOURCE_VARIABLE_MAP             ,
              bool                        gPARAMETER_EXISTENCE_SENSITIVENESS ) const
{
  
  //
  //  yParameterTag ::=  <%><parameter><%>
  //
  
  TString                                yParameterTag;
  TString                                yInstance = preprocess();
  TStringToVariableMap::const_iterator   I         = rktSOURCE_VARIABLE_MAP.begin();
  TStringToVariableMap::const_iterator   ktEnd     = rktSOURCE_VARIABLE_MAP.end();
  
  //
  //  Replace parameters.
  //
  if ( !gPARAMETER_EXISTENCE_SENSITIVENESS )
  {
    for (; ( I != ktEnd ) ;++I)
    {
      yParameterTag = Format ("%%%s%%", I->first.c_str());
      yInstance.replaceAll (yParameterTag, I->second);
    }
  }
  else
  {
    for (; ( I != ktEnd ) ;++I)
    {
      yParameterTag = Format ("%%%s%%", I->first.c_str());
      if ( !yInstance.replaceAll (yParameterTag, I->second) )
      {
        if ( I->second.type() == TVariableString::eNormal )
        {
          //
          //  If parameter name isn't optional then
          //  there is an error.
          //
          TString   yMessage = Format ( "there is no tag called '%s' in this clause code" ,
                                        I->first.c_str()                                  );
          
          throw TBadInstantiateSyntaxException (yMessage, __FILE__, __LINE__);
        }
      }
    }
  }
  return yInstance;
  
}  // instantiate()


mpcl::text::TString mpcl::text::codegen::TClauseBodyString::
instantiate ( const TStringToStringMap& rktSOURCE_STRING_MAP               ,
              bool                      gPARAMETER_EXISTENCE_SENSITIVENESS ) const
{
  
  //
  //  yParameterTag ::= <%><parameter><%>
  //
  
  TString                              yParameterTag;
  TString                              yInstance = preprocess();
  TStringToStringMap::const_iterator   I         = rktSOURCE_STRING_MAP.begin();
  TStringToStringMap::const_iterator   ktEnd     = rktSOURCE_STRING_MAP.end();
  
  //
  //  Replace parameters.
  //
  if ( !gPARAMETER_EXISTENCE_SENSITIVENESS )
  {
    for (; ( I != ktEnd ) ;++I)
    {
      yParameterTag = Format ("%%%s%%", I->first.c_str());
      yInstance.replaceAll (yParameterTag, I->second);
    }
  }
  else
  {
    for (; ( I != ktEnd ) ;++I)
    {
      yParameterTag = Format ("%%%s%%", I->first.c_str());
      if ( !yInstance.replaceAll (yParameterTag, I->second) )
      {
        //
        //  If parameter name isn't optional then
        //  there is an error.
        //
        TString   yMessage = Format ( "there is no tag called '%s' in this clause code" ,
                                      I->first.c_str()                                  );
          
        throw TBadInstantiateSyntaxException (yMessage, __FILE__, __LINE__);
      }
    }
  }
  return yInstance;
  
}  // instantiate()


void mpcl::text::codegen::TClauseBodyString::
write (std::basic_ostream<char_type, traits_type>& rtTARGET_OSTREAM) const
{
  
  operator << (rtTARGET_OSTREAM, (std::string) *this);
  rtTARGET_OSTREAM << "</clause>\n";
  
}  // write()


mpcl::text::TString mpcl::text::codegen::TClauseBodyString::
preprocess (void) const
{
  
  TString   yInstance (*this);
  
  //
  //  Replace first, all entities.
  //
  InstantiateEntities (yInstance);
  return yInstance;
  
}  // preprocess()

---