---

pattern_based_code_generator.cc

/*
*  Name:      pattern_based_code_generator.cc
*  Author:    Rafael Jesus Alcantara Perez
*  Summary:   Pattern based code generator       
*  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 <fstream>
#include <mpcl/system/all.hh>
#include <mpcl/text/codegen/pattern_based_code_generator.hh>
#include <mpcl/text/regex/matcher.hh>


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

mpcl::text::codegen::TPatternBasedCodeGenerator::
TPatternBasedCodeGenerator ( const TString& rkySOURCE_CDML_FILE ,
                             const TString& rkyCDML_PATH        ) :
  IStreamable<>      ()                                           ,
  tInstructionMap    ()                                           ,
  tVariableMap       ()                                           ,
  yCdmlPath          (rkyCDML_PATH)                               ,
  yDescription       ()                                           ,
  yInherit           ()                                           ,
  yPublic            ()                                           ,
  ySystem            ()                                           ,
  yTarget            ()
{

  initConstants();
  loadFrom (rkySOURCE_CDML_FILE);

}  // TPatternBasedCodeGenerator()


void mpcl::text::codegen::TPatternBasedCodeGenerator::
clear (void)
{
  
  tInstructionMap.clear();
  yTarget.erase();
  yInherit.erase();
  yDescription.erase();
  yCdmlPath.erase();

}  // clear()


void mpcl::text::codegen::TPatternBasedCodeGenerator::
clearCode (void)
{

  TInstructionMap::iterator                      tInstructionIter;
  TInstructionBody::TClauseMap::iterator         tClauseIter;
  TInstructionBody::TClauseMap::const_iterator   ktClauseEnd;
  
  tInstructionIter = tInstructionMap.begin();
  for (; ( tInstructionIter != tInstructionMap.end() ) ;++tInstructionIter)
  {
    tClauseIter = tInstructionIter->second.tClauseMap.begin();
    ktClauseEnd = tInstructionIter->second.tClauseMap.end();
    for (; ( tClauseIter != ktClauseEnd ) ;++tClauseIter)
    {
      tClauseIter->second.erase();
    }
  }

}  // clearCode()


void mpcl::text::codegen::TPatternBasedCodeGenerator::
loadFrom (const TString& rkySOURCE_CDML_FILE)
{

  using mpcl::system::tSystem;
  using std::basic_ifstream;
  using std::vector;
  
  basic_ifstream<char>   tCdmlIfstream;
  TString                yCdmlFileName;
  bool                   gSuccess = false;

  //
  //  If there is CDML path and it  can't open the file,  then it tries to load
  //  the file from the directories in the CDML path.
  //
  tCdmlIfstream.open (rkySOURCE_CDML_FILE.c_str());
  if ( !tCdmlIfstream.is_open() && !yCdmlPath.empty() )
  {
    //
    //  There are some path items to test.
    //
    vector<TString>                   tPathVector = tSystem.getPathItems (yCdmlPath);
    vector<TString>::const_iterator   I           = tPathVector.begin();

    yCdmlFileName  = tSystem.getDirectorySeparator();
    yCdmlFileName += rkySOURCE_CDML_FILE;
    for (; ( I != tPathVector.end() ) ;++I)
    {
      tCdmlIfstream.clear();
      tCdmlIfstream.open ((*I + yCdmlFileName).c_str());
      if ( tCdmlIfstream.is_open() )
      {
        break;
      }
    }
  }
  if ( tCdmlIfstream.is_open() )
  {
    //
    //  Loads CDML file into code-generator.
    //
    gSuccess = true;
    read (tCdmlIfstream);
    tCdmlIfstream.close();
  }
  if ( !gSuccess )
  {
    TString   yMessage = Format ("couldn't open file '%s'", rkySOURCE_CDML_FILE.c_str());

    throw TFileNotFoundException (yMessage, __FILE__, __LINE__);
  }

}  // loadFrom()


void mpcl::text::codegen::TPatternBasedCodeGenerator::
compile (void)
{

  size_t   zOffset;

  //
  //  There is no inheritance from here towards.
  //
  yInherit.erase();

  //
  //  Preprocess source variables (normal and file types).
  //
  {
    TStringToVariableMap::iterator         I             = tVariableMap.begin();
    TStringToVariableMap::const_iterator   ktVariableEnd = tVariableMap.end();
    
    for (; ( I != ktVariableEnd ) ;++I)
    {
      zOffset = I->second.find (pkcEOC_EntityPattern);
      if ( TString::npos != zOffset )
      {
        I->second.erase (zOffset);
      }
    }
  }
  
  //
  //  Preprocess clause-body-strings.
  //
  {
    TInstructionMap::iterator                      I;
    TInstructionMap::const_iterator                ktInstructionEnd;
    TInstructionBody::TClauseMap::iterator         J;
    TInstructionBody::TClauseMap::const_iterator   ktClauseEnd;
    
    I                = tInstructionMap.begin();
    ktInstructionEnd = tInstructionMap.end();
    for (; ( I != ktInstructionEnd ) ;++I)
    {
      J           = I->second.tClauseMap.begin();
      ktClauseEnd = I->second.tClauseMap.end();
      for (; ( J != ktClauseEnd ) ;++J)
      {
        zOffset = J->second.find (pkcEOC_EntityPattern);
        if ( TString::npos != zOffset )
        {
          J->second.erase (zOffset);
        }
      }
    }
  }

}  // compile()


void mpcl::text::codegen::TPatternBasedCodeGenerator::
preprocessVariables (void)
{

  TStringToVariableMap::iterator         I             = tVariableMap.begin();
  TStringToVariableMap::const_iterator   ktVariableEnd = tVariableMap.end();
  
  for (; ( I != ktVariableEnd ) ;++I)
  {
    InstantiateEntities (I->second);
  }
  
}  // preprocessVariables()


void mpcl::text::codegen::TPatternBasedCodeGenerator::
setDescription (const char* pkcSOURCE_DESCRIPTION)
{

  yDescription = pkcSOURCE_DESCRIPTION;

}  // setDescription()


void mpcl::text::codegen::TPatternBasedCodeGenerator::
setCdmlPath (const TString& rkyCDML_PATH)
{

  yCdmlPath = rkyCDML_PATH;

}  // setCdmlPath()


void mpcl::text::codegen::TPatternBasedCodeGenerator::
initConstants (void) const
{

  using std::strlen;

  //
  //  Due to a bug in GNU-C version <= 2.7.2.3.
  //
  if ( !zEntityPrefixLength )
  {
    zEntityPrefixLength      = strlen (pkcEntityPrefix);
    zGT_EntityPatternLength  = strlen (pkcGT_EntityPattern);
    zGT_EntityValueLength    = strlen (pkcGT_EntityValue);
    zLT_EntityPatternLength  = strlen (pkcLT_EntityPattern);
    zLT_EntityValueLength    = strlen (pkcLT_EntityValue);
    zNL_EntityPatternLength  = strlen (pkcNL_EntityPattern);
    zNL_EntityValueLength    = strlen (pkcNL_EntityValue);
    zEOC_EntityPatternLength = strlen (pkcEOC_EntityPattern);
    zAMP_EntityPatternLength = strlen (pkcAMP_EntityPattern);
    zAMP_EntityValueLength   = strlen (pkcAMP_EntityValue);
  }

}  // initConstants()


void mpcl::text::codegen::TPatternBasedCodeGenerator::
inheritFrom (const TString& rkySOURCE_CDML_FILE)
{

  //
  //  The only attribute that must persists is
  //  string yTarget.
  //

  TString   yOldTarget  = yTarget;
  TString   yOldInherit = yInherit;
  
  loadFrom (rkySOURCE_CDML_FILE);
  yTarget  = yOldTarget;
  yInherit = yOldInherit;

}  // inheritFrom()


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

# define PBCG_REMOVE_COMMENTS                                    \
         {                                                       \
           while ( tMatcher.scan (pkcCommentTagPattern, NULL) ); \
         }

  using text::regex::TMatcher;

  //
  //  CDML document must be validated, so parsing
  //  doesn't have to worry about syntax errors.
  //  First it musts find CDML tag, and then skip
  //  it.
  //

  //
  //  If gUpdateOnly is false, then it's loading a root CDML file (maybe,
  //  it is an only-one-node tree). Else, it is updating the inner nodes.
  //
  bool       gUpdateOnly = false;
  TMatcher   tMatcher (rtSOURCE_ISTREAM);

  yPublic.erase();
  ySystem.erase();
  yTarget.erase();
  yInherit.erase();
  tInstructionMap.clear();  
  tMatcher.setCaseSensitiveness (false);
  PBCG_REMOVE_COMMENTS;

  //
  //  !DOCTYPE tag.
  //
  if ( !tMatcher.scan (pkcDOCTYPE_TagPattern_1, NULL) )
  {
    if ( !tMatcher.scan (pkcDOCTYPE_TagPattern_2, NULL) )
    {
      if ( !tMatcher.scan (pkcDOCTYPE_TagPattern_3, &ySystem, NULL) )
      {
        tMatcher.scan (pkcDOCTYPE_TagPattern_4, &yPublic, NULL);
      }
    }
  }
  PBCG_REMOVE_COMMENTS;
  
  //
  //  CDML tag.
  //
  if ( !tMatcher.scan (pkcCDML_TagPattern_1, &yTarget, NULL) )
  {
    if ( !tMatcher.scan (pkcCDML_TagPattern_2, &yTarget, &yInherit, NULL) )
    {
      if ( !tMatcher.scan (pkcCDML_TagPattern_3, &yInherit, &yTarget, NULL) )
      {
        throw TNotCdmlFileException ("file doesn't conform CDML", __FILE__, __LINE__);
      }
    }

    //
    //  First, it loads base CDMLs, and then loads this instance, overloading base
    //  instruction/clause pairs.
    //
    inheritFrom (yInherit + ".cdml");
    gUpdateOnly = true;
  }
  PBCG_REMOVE_COMMENTS;
  
  //
  //  Reads DESC tag/DESC body/DESC end-tag.
  //
  tMatcher.scan (pkcDESC_ElementPattern, &yDescription, NULL);
  PBCG_REMOVE_COMMENTS;
  
  //
  //  Reads DECLARE tag/DECLARE end-tag.
  //
  if ( tMatcher.scan (pkcDECLARE_TagPattern, NULL) > 0 )
  {
    TString   yName;
    TString   yValue;
    TString   yType;
    bool      gFound;

    if ( !gUpdateOnly )
    {
      do
      {
        //
        //  It removes  comments  and then,  scans  for  only one of the  three
        //  possible patterns.
        //
        PBCG_REMOVE_COMMENTS;
        gFound = ( tMatcher.scan (pkcVARIABLE_ElementPattern_1, &yName, &yValue, NULL) > 0 );
        if ( !gFound )
        {
          gFound = ( tMatcher.scan (pkcVARIABLE_ElementPattern_2, &yName, &yType, &yValue, NULL) > 0 );
        }
        if ( !gFound )
        {
          gFound = ( tMatcher.scan (pkcVARIABLE_ElementPattern_3, &yType, &yName, &yValue, NULL) > 0 );
        }
        if ( gFound )
        {
          yType.uppercase();
          if ( yType == "FILE" )
          {
            tVariableMap.bind (yName, TVariableString (yValue, TVariableString::eFile));
          }
          else if ( yType == "OPTIONAL" )
          {
            tVariableMap.bind (yName, TVariableString (yValue, TVariableString::eOptional));
          }
          else
          {
            tVariableMap.bind (yName, TVariableString (yValue));
          }
          yName.erase();
          yValue.erase();
          yType.erase();
          PBCG_REMOVE_COMMENTS;
        }
      } while ( gFound );
    }
    else
    {
      do
      {
        //
        //  It removes  comments  and then,  scans  for  only one of the  three
        //  possible patterns.
        //
        PBCG_REMOVE_COMMENTS;
        gFound = ( tMatcher.scan (pkcVARIABLE_ElementPattern_1, &yName, &yValue, NULL) > 0 );
        if ( !gFound )
        {
          gFound = ( tMatcher.scan (pkcVARIABLE_ElementPattern_2, &yName, &yType, &yValue, NULL) > 0 );
        }
        if ( !gFound )
        {
          gFound = ( tMatcher.scan (pkcVARIABLE_ElementPattern_3, &yType, &yName, &yValue, NULL) > 0 );
        }
        if ( gFound )
        {
          yType.uppercase();
          if ( yType == "FILE" )
          {
            //
            //  Insert or update new value.
            //
            if ( tVariableMap.end() == tVariableMap.find (yName) )
            {
              //
              //  If variable type was not eFile, then now it musts throw
              //  an exception here.
              //
              tVariableMap.bind (yName, TVariableString (yValue, TVariableString::eFile));
            }
            else
            {
              if ( tVariableMap [yName].type() == TVariableString::eFile )
              {
                tVariableMap [yName] = yValue;
              }
              else
              {
                TString   yMessage = Format ( "variable '%s' already has another type" ,
                                              yName.c_str()                            );

                throw TBadInstantiateSyntaxException (yMessage, __FILE__, __LINE__);
              }
            }
          }
          else if ( yType == "OPTIONAL" )
          {
            //
            //  Insert or update new value.
            //
            if ( tVariableMap.end() == tVariableMap.find (yName) )   
            {
              //
              //  If variable type was not eFile, then now it musts throw
              //  an exception here.
              //
              tVariableMap.bind (yName, TVariableString (yValue, TVariableString::eOptional));
            }
            else
            {
              if ( tVariableMap [yName].type() == TVariableString::eOptional )
              {
                tVariableMap [yName] = yValue;
              }
              else
              {
                TString   yMessage = Format ( "variable '%s' already has another type" ,
                                              yName.c_str()                            );

                throw TBadInstantiateSyntaxException (yMessage, __FILE__, __LINE__);
              }
            }
          }
          else
          {
            //
            //  Insert or update new value.
            //
            if ( tVariableMap.end() == tVariableMap.find (yName) )
            {
              tVariableMap.bind (yName, TVariableString (yValue));
            }
            else
            {                               
              if ( tVariableMap [yName].type() == TVariableString::eNormal )
              {
                tVariableMap [yName] = yValue;
              }
              else
              {
                TString   yMessage = Format ( "variable '%s' already has another type" ,
                                              yName.c_str()                            );

                throw TBadInstantiateSyntaxException (yMessage, __FILE__, __LINE__);
              }
            }
          }
          yName.erase();
          yValue.erase();
          yType.erase();
          PBCG_REMOVE_COMMENTS;
        }
      } while ( gFound );
    }
    tMatcher.scan (pkcDECLARE_EndTagPattern, NULL);
    PBCG_REMOVE_COMMENTS;
  }
  
  //
  //  Read CDML instructions.
  //
  if ( !gUpdateOnly )
  {
    //
    //  This is a leaf node of the inheritance tree.
    //
    rtSOURCE_ISTREAM >> tInstructionMap;
  }
  else
  {
    //
    //  This is an internal or root node of the inheritance tree.
    //

    TInstructionMap::const_iterator   I;
    TInstructionMap::const_iterator   ktSourceInstructionEnd;
    TInstructionMap                   tSourceInstructionMap;

    //
    //  Loads the parent CDML instructions into a local instruction map.
    //
    rtSOURCE_ISTREAM >> tSourceInstructionMap;

    //
    //  Iterates over all instructions and their clauses.
    //
    I                      = tSourceInstructionMap.begin();
    ktSourceInstructionEnd = tSourceInstructionMap.end();
    for (; ( I != ktSourceInstructionEnd ) ;++I)
    {
      TInstructionBody::TClauseMap::const_iterator   J;

      TInstructionBody::TClauseMap::iterator   K;

      TInstructionBody::TClauseMap::const_iterator   ktSourceClauseEnd;
      
      TInstructionBody::TClauseMap&
        rtTargetClauseMap = tInstructionMap [I->first].tClauseMap;

      //
      //  Initializes iterators.
      //
      J                 = I->second.tClauseMap.begin();
      ktSourceClauseEnd = I->second.tClauseMap.end();
      for (; ( J != ktSourceClauseEnd ) ;++J)
      {
        const TClauseTagString&   rktSourceClauseTag = J->first;

        if ( !rktSourceClauseTag.hasTarget() )
        {
          //
          //  Warning: Key must be bound.
          //
          //  It musts substitute the key in target map, so it musts
          //  remove first the value and insert the modified value again.
          //

          TClauseTagString    yTargetClauseTag;
          TClauseBodyString   yTargetClauseBody;
          
          K = rtTargetClauseMap.find (rktSourceClauseTag);
          if ( K == rtTargetClauseMap.end() )
          {
            TString   yMessage =
                        Format ( "clause '%s' in instruction '%s' is not defined in parent CDMLs" ,
                                 rktSourceClauseTag.c_str()                                       ,
                                 I->first.c_str()                                                 );
            
            throw TBadInstantiateSyntaxException (yMessage, __FILE__, __LINE__);
          }
          
          //
          //  There is a previous target clause defined with that tag.
          //
          yTargetClauseTag  = K->first;
          yTargetClauseBody = K->second;
          rtTargetClauseMap.erase (K);
          yTargetClauseTag.overloadFrom (rktSourceClauseTag);
          yTargetClauseBody = J->second;
          rtTargetClauseMap.bind (yTargetClauseTag, yTargetClauseBody);
        }
        else
        {
          K = rtTargetClauseMap.find (rktSourceClauseTag);
          if ( K == rtTargetClauseMap.end() )
          {
            //
            //  Insert clause-tag string value.
            //
            rtTargetClauseMap.bind (rktSourceClauseTag, J->second);
          }
          else
          {
            //
            //  Copy clause-tag string value.
            //
            //  It musts substitute the key in target map, so it musts
            //  remove first the value and insert the modified value again.
            //

            TClauseTagString    yTargetClauseTag  = K->first;
            TClauseBodyString   yTargetClauseBody = K->second;
          
            rtTargetClauseMap.erase (K);
            yTargetClauseTag.overloadFrom (rktSourceClauseTag);
            rtTargetClauseMap.bind (yTargetClauseTag, yTargetClauseBody);
          }
        }
      }
    }
  }
  PBCG_REMOVE_COMMENTS;

  //
  //  CDML end-tag.
  //
  tMatcher.scan (pkcCDML_EndTagPattern, NULL);
  PBCG_REMOVE_COMMENTS;

# undef PBCG_REMOVE_COMMENTS

}  // read()


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

const mpcl::text::codegen::TStringToVariableMap& mpcl::text::codegen::TPatternBasedCodeGenerator::
variables (void) const
{

  return tVariableMap;

}  // variables()


const mpcl::text::codegen::TClauseBodyString& mpcl::text::codegen::TPatternBasedCodeGenerator::
codePatternFor ( const char* pkcINSTRUCTION_NAME ,
                 const char* pkcCLAUSE_NAME      ) const
{

  TInstructionMap::const_iterator   ktIter = tInstructionMap.find (pkcINSTRUCTION_NAME);

  if ( ktIter == tInstructionMap.end() )
  {
    TString   yMessage;
    
    yMessage = Format ("instruction '%s' not found", pkcINSTRUCTION_NAME);
    throw TNotFoundException (yMessage, __FILE__, __LINE__);
  }
  return ktIter->second.clauseBody (pkcCLAUSE_NAME);

}  // codePatternFor()


mpcl::text::codegen::TInstructionBody& mpcl::text::codegen::TPatternBasedCodeGenerator::
instruction (const char* pkcINSTRUCTION_NAME)
{

  TInstructionMap::iterator   tIter = tInstructionMap.find (pkcINSTRUCTION_NAME);

  if ( tIter == tInstructionMap.end() )
  {
    TString   yMessage;
    
    yMessage = Format ("instruction '%s' not found", pkcINSTRUCTION_NAME);
    throw TNotFoundException (yMessage, __FILE__, __LINE__);
  }
  return tIter->second;

}  // instruction()


const mpcl::text::codegen::TInstructionBody& mpcl::text::codegen::TPatternBasedCodeGenerator::
instruction (const char* pkcINSTRUCTION_NAME) const
{

  TInstructionMap::const_iterator   ktIter = tInstructionMap.find (pkcINSTRUCTION_NAME);

  if ( ktIter == tInstructionMap.end() )
  {
    TString   yMessage;
    
    yMessage = Format ("instruction '%s' not found", pkcINSTRUCTION_NAME);
    throw TNotFoundException (yMessage, __FILE__, __LINE__);
  }
  return ktIter->second;

}  // instruction()


bool mpcl::text::codegen::TPatternBasedCodeGenerator::
existsClause (const char* pkcINSTRUCTION_NAME, const char* pkcCLAUSE_NAME) const
{

  bool                              gSuccess = false;
  TInstructionMap::const_iterator   tIter    = tInstructionMap.find (pkcINSTRUCTION_NAME);

  if ( tInstructionMap.end() != tIter )
  {
    gSuccess = tIter->second.existsClause (pkcCLAUSE_NAME);
  }
  return gSuccess;

}  // existsClause()


void mpcl::text::codegen::TPatternBasedCodeGenerator::
write (std::basic_ostream<char_type, traits_type>& rtTARGET_OSTREAM) const
{

  rtTARGET_OSTREAM << "<!doctype cdml";
  if ( !yPublic.empty() )
  {
    rtTARGET_OSTREAM << " public \"" << yPublic << "\"";
  }
  else if ( !ySystem.empty() )
  {
    rtTARGET_OSTREAM << " system \"" << ySystem << "\"";
  }
  rtTARGET_OSTREAM << ">\n<cdml target=\"" << yTarget << "\"";
  if ( !yInherit.empty() )
  {
    rtTARGET_OSTREAM << " inherit=\"" << yInherit << '"';
  }
  rtTARGET_OSTREAM << ">\n";
  if ( !yDescription.empty() )
  {
    rtTARGET_OSTREAM << "<desc>\n" << yDescription << "\n</desc>\n";
  }
  if ( !tVariableMap.empty() )
  {
    TStringToVariableMap::const_iterator   ktIter = tVariableMap.begin();
    TStringToVariableMap::const_iterator   ktEnd  = tVariableMap.end();
    
    rtTARGET_OSTREAM << "<declare>\n";
    for (; ( ktIter != ktEnd ) ;++ktIter)
    {
      rtTARGET_OSTREAM << "<variable name=\"" << ktIter->first << "\"";
      switch (ktIter->second.type())
      {
        case TVariableString::eNormal:
        {
          rtTARGET_OSTREAM << " type=normal";
          break;
        }
        case TVariableString::eFile:
        {
          rtTARGET_OSTREAM << " type=file";
          break;
        }
        case TVariableString::eOptional:
        {
          rtTARGET_OSTREAM << " type=optional";
          break;
        }
      }
      rtTARGET_OSTREAM << ">" << ktIter->second << "</variable>\n";
    }
    rtTARGET_OSTREAM << "</declare>\n";
  }
  rtTARGET_OSTREAM << tInstructionMap;
  rtTARGET_OSTREAM << "</cdml>\n";

}  // write()

---