---

dia2dfaml.cc

/*
*  Name:      dia2dfaml.cc
*  Author:    Rafael Jesus Alcantara Perez
*  Summary:   Translator for DIA XML format to DFAML
*  Date:      $Date: 2003/10/06 12:45:11 $
*  Revision:  $Revision: 1.2 $
*
*  Copyright (C) 1999-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 <algorithm>
#include <clocale>
#include <ctime>
#include <fstream>
#include <iostream>
#include <list>
#include <mpcl/automaton/defs.hh>
#include <mpcl/system/defs.hh>
#include <mpcl/text/regex/matcher.hh>
#include <mpcl/text/string.hh>
#include <mpcl/util/prefs/config_processor.hh>
#include <set>


//
//  L O C A L   T Y P E S
//

using mpcl::automaton::TIntegrityException;
using mpcl::text::regex::TMatcher;
using mpcl::text::Format;
using mpcl::text::TString;
using mpcl::util::collection::TMap;
using mpcl::util::prefs::TConfigProcessor;
using mpcl::system::GetErrorMessage;
using std::pair;
using std::set;

typedef 
  pair<TString, TString>
  TConnectionPair;

typedef
  pair<TString, TString>
  TIdStatePair;

typedef
  TMap<TString, TConnectionPair>
  TMessageToConnectionMap;

typedef
  set<TString>
  TStateSet;

typedef
  TMap<TIdStatePair, TString>
  TStateToActionNameMap;


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

static const char*   _pkcVersion = "0.0.0";

static TStateSet   _tFinalStateSet;

static TStateSet   _tInitialStateSet;

static TMessageToConnectionMap   _tMessageToConnectionMap;

static TStateToActionNameMap   _tStateToActionNameMap;


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

static void _CheckIntegrity (void);

static bool _ParseDiaString (TMatcher& rtSOURCE_MATCHER, TString& ryTARGET);

static void 
_ParseDiaClassAttribute ( TMatcher&      rtSOURCE_MATCHER         ,
                          TString&       ryTARGET_ATTRIBUTE_NAME  ,
                          TString&       ryTARGET_ATTRIBUTE_VALUE ,
                          const TString& rkySOURCE_OBJECT_ID      );

static void
_ParseDiaClassOperation ( TMatcher&      rtSOURCE_MATCHER        ,
                          TString&       ryTARGET_OPERATION_NAME ,
                          const TString& rkySOURCE_OBJECT_ID     );

static bool _ParseEndDiaAttribute (TMatcher& rtSOURCE_MATCHER);

static bool
_ParseDiaAttribute ( TMatcher&      rtSOURCE_MATCHER    ,
                     TString&       ryTARGET_NAME       ,
                     TString&       ryTARGET_TYPE       ,
                     const TString& rkySOURCE_OBJECT_ID );

static bool
_ParseDiaConnections ( TMatcher& rtSOURCE_MATCHER ,
                       TString&  ryTARGET_FROM_ID ,
                       TString&  ryTARGET_TO_ID   );

static void
_ParseUmlMessage (TMatcher& rtSOURCE_MATCHER, const TString& rkySOURCE_OBJECT_ID);

static void
_ParseUmlClass (TMatcher& rtSOURCE_MATCHER, const TString& rkySOURCE_OBJECT_ID);

static void _PrintUsage (void);

static void _ResolveStates (void);

static void _WriteActions (void);

static void _WriteDfaml (const TString& rkySOURCE_DFAML_NAME);

static void _WriteTransitions (const TString& rkySOURCE_STATE);


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

static void _CheckIntegrity (void)
{

  std::list<TString>::const_iterator   I;
  TMessageToConnectionMap::iterator    J;
  std::list<TString>                   tReachableStateList;

  //
  //  Checks that only exists one and only one initial state.
  //
  switch (_tInitialStateSet.size())
  {
    case 0:
    {
      throw TIntegrityException ("no initial states", __FILE__, __LINE__);
    }
    case 1:
    {
      break;
    }
    default:
    {
      throw TIntegrityException ("too many initial states", __FILE__, __LINE__);
    }
  }

  //
  //  Checks that all states are reachable from initial state.
  //  Connections must be resolved before that.
  //
  tReachableStateList.push_back (*_tInitialStateSet.begin());
  for (I = tReachableStateList.begin(); ( I != tReachableStateList.end() ) ;++I)
  {
    for (J = _tMessageToConnectionMap.begin(); ( J != _tMessageToConnectionMap.end() ) ;++J)
    {
      //
      //  If the from-state is equal to the original state from reachable set.
      //
      if ( *I == J->second.first )
      {
        //
        //  If the to-state isn't included in the reachable state vector,
        //  then it inserts into it.
        //
        if ( find ( tReachableStateList.begin() ,
                    tReachableStateList.end()   ,
                    J->second.second            ) == tReachableStateList.end() )
        {
          tReachableStateList.push_back (J->second.second);
        }
      }
    }
  }

  //
  //  Checks that the cardinal of reachable states from original state,
  //  is the same that the cardinal of all states.
  //
  if ( tReachableStateList.size() != _tStateToActionNameMap.size() )
  {
    throw TIntegrityException ("there are states not reachable", __FILE__, __LINE__);
  }

}  // _CheckIntegrity()


static bool _ParseDiaString (TMatcher& rtSOURCE_MATCHER, TString& ryTARGET)
{

  return rtSOURCE_MATCHER.scan ("<dia:string>{sep}*#%s#{sep}*</dia:string>{sep}*", &ryTARGET, NULL);

}  // _ParseDiaString()


static void _ParseDiaClassOperation ( TMatcher&      rtSOURCE_MATCHER        ,
                                      TString&       ryTARGET_OPERATION_NAME ,
                                      const TString& rkySOURCE_OBJECT_ID     )
{

  TString   yNull;
  
  while ( _ParseDiaAttribute ( rtSOURCE_MATCHER        ,
                               ryTARGET_OPERATION_NAME ,
                               yNull                   ,
                               rkySOURCE_OBJECT_ID     ) );

}  // _ParseDiaClassOperation()


static void _ParseDiaClassAttribute ( TMatcher&      rtSOURCE_MATCHER         ,
                                      TString&       ryTARGET_ATTRIBUTE_NAME  ,
                                      TString&       ryTARGET_ATTRIBUTE_VALUE ,
                                      const TString& rkySOURCE_OBJECT_ID      )
{

  while ( _ParseDiaAttribute ( rtSOURCE_MATCHER             ,
                               ryTARGET_ATTRIBUTE_NAME  ,
                               ryTARGET_ATTRIBUTE_VALUE , 
                               rkySOURCE_OBJECT_ID      ) );

}  // _ParseDiaClassAttribute()


static bool _ParseEndDiaAttribute (TMatcher& rtSOURCE_MATCHER)
{

  return rtSOURCE_MATCHER.scan ("</dia:attribute>{sep}*", NULL);
  
}  // _ParseEndDiaAttribute()


static bool _ParseDiaAttribute ( TMatcher&      rtSOURCE_MATCHER    ,
                                 TString&       ryTARGET_NAME       ,
                                 TString&       ryTARGET_TYPE       ,
                                 const TString& rkySOURCE_OBJECT_ID )
{

  int       iRet;
  TString   yActions;
  TString   yDiaAttributeName;
  TString   yDiaString;
  TString   yDiaOperation;
  TString   yNull;

  iRet = rtSOURCE_MATCHER.scan ("<dia:attribute name=%q>{sep}*", &yDiaAttributeName, NULL);
  if ( !iRet )
  {
    //
    //  Scans for an empty attribute.
    //
    iRet = rtSOURCE_MATCHER.scan ("<dia:attribute name=%q/>{sep}*", &yNull, NULL);
  }
  else 
  {
    if ( ( yDiaAttributeName == "name" ) ||
         ( yDiaAttributeName == "text" )  )
    {
      _ParseDiaString (rtSOURCE_MATCHER, yDiaString);
      ryTARGET_NAME = yDiaString;
      _ParseEndDiaAttribute (rtSOURCE_MATCHER);
    }
    else if ( yDiaAttributeName == "value" )
    {
      _ParseDiaString (rtSOURCE_MATCHER, yDiaString);
      ryTARGET_TYPE = yDiaString;
      _ParseEndDiaAttribute (rtSOURCE_MATCHER);
    }
    else if ( yDiaAttributeName == "operations" )
    {
      //
      //  Gets all actions for the current state.
      //
      yActions.erase();
      while ( rtSOURCE_MATCHER.scan ("<dia:composite type=\"umloperation\">{sep}*", NULL) )
      {
        _ParseDiaClassOperation (rtSOURCE_MATCHER, yDiaOperation, rkySOURCE_OBJECT_ID);
        rtSOURCE_MATCHER.scan ("</dia:composite>{sep}*", NULL);
        if ( !yActions.empty() )
        {
          yActions += ", ";
        }
        yActions += yDiaOperation;
      }
      _tStateToActionNameMap.bind (make_pair (rkySOURCE_OBJECT_ID, ryTARGET_NAME), yActions);
      _ParseEndDiaAttribute (rtSOURCE_MATCHER);
    }
    else if ( yDiaAttributeName == "attributes" )
    {
      TString   yAttributeName;
      TString   yAttributeValue;
      
      //
      //  Gets state type (initial or final) for the current state.
      //
      while ( rtSOURCE_MATCHER.scan ("<dia:composite type=\"umlattribute\">{sep}*", NULL) )
      {
        _ParseDiaClassAttribute (rtSOURCE_MATCHER, yAttributeName, yAttributeValue, rkySOURCE_OBJECT_ID);
        rtSOURCE_MATCHER.scan ("</dia:composite>{sep}*", NULL);
      }
      if ( yAttributeName == "type" )
      {
        if ( yAttributeValue == "final" )
        {
          _tFinalStateSet.insert (ryTARGET_NAME);
        }
        else if ( yAttributeValue == "initial" )
        {
          _tInitialStateSet.insert (ryTARGET_NAME);
        }
      }
      _ParseEndDiaAttribute (rtSOURCE_MATCHER);
    }
    else
    {
      //
      //  Remove un-useful DIA attributes.
      //
      while ( true )
      {
        if ( !rtSOURCE_MATCHER.scan ("<dia:%s val=%q/>{sep}*", NULL) )
        {
          if ( !rtSOURCE_MATCHER.scan ("<dia:string>%t</dia:string>{sep}*", NULL) )
          {
            if ( !rtSOURCE_MATCHER.scan ("<dia:string/>{sep}*", NULL) )
            {
              break;
            }
          }
        }
      }
    }
    _ParseEndDiaAttribute (rtSOURCE_MATCHER);
  }
  return iRet;

}  // _ParseDiaAttribute()


static bool _ParseDiaConnections ( TMatcher& rtSOURCE_MATCHER ,
                                   TString&  ryTARGET_FROM_ID ,
                                   TString&  ryTARGET_TO_ID   )
{

  TString   yNull;

  return rtSOURCE_MATCHER.scan ( "<dia:connections>{sep}*"
                                 "<dia:connection handle=%q to=%q connection=%q/>{sep}*"
                                 "<dia:connection handle=%q to=%q connection=%q/>{sep}*"
                                 "</dia:connections>{sep}*"                              ,
                                 &yNull                                                  ,
                                 &ryTARGET_FROM_ID                                       ,
                                 &yNull                                                  ,
                                 &yNull                                                  ,
                                 &ryTARGET_TO_ID                                         ,
                                 &yNull                                                  ,
                                 NULL                                                    );

}  // _ParseDiaConnections()


static void _ParseUmlClass ( TMatcher&      rtSOURCE_MATCHER    ,
                             const TString& rkySOURCE_OBJECT_ID )
{

  TStateToActionNameMap::const_iterator   I;
  TString                                 yDiaClassName;
  TString                                 yDiaClassType;

  while ( _ParseDiaAttribute (rtSOURCE_MATCHER, yDiaClassName, yDiaClassType, rkySOURCE_OBJECT_ID) );
  I = _tStateToActionNameMap.find (make_pair (rkySOURCE_OBJECT_ID, yDiaClassName));
  if ( I == _tStateToActionNameMap.end() )
  {
    _tStateToActionNameMap.bind (make_pair (rkySOURCE_OBJECT_ID, yDiaClassName), "");
  }
  rtSOURCE_MATCHER.scan ("</dia:object>{sep}*", NULL);
  
}  // _ParseUmlClass()


static void
_ParseUmlMessage (TMatcher& rtSOURCE_MATCHER, const TString& rkySOURCE_OBJECT_ID)
{

  TString   yDiaMessageName;
  TString   yFromId;
  TString   yNull;
  TString   yToId;

  for (;;)
  {
    if ( !_ParseDiaAttribute (rtSOURCE_MATCHER, yDiaMessageName, yNull, rkySOURCE_OBJECT_ID) )
    {
      if ( !_ParseDiaConnections (rtSOURCE_MATCHER, yFromId, yToId) )
      {
        break;
      }
      else
      {
        _tMessageToConnectionMap.bind (yDiaMessageName, make_pair (yFromId, yToId));
      }
    }
  }
  rtSOURCE_MATCHER.scan ("</dia:object>{sep}*", NULL);

}  // _ParseUmlMessage()


static void _ResolveStates (void)
{

  TMessageToConnectionMap::iterator       I;
  TStateToActionNameMap::const_iterator   J;
  register short int                      K;

  for (I = _tMessageToConnectionMap.begin(); ( I != _tMessageToConnectionMap.end() ) ;++I)
  {
    J = _tStateToActionNameMap.begin();
    K = 0;
    for (; ( ( K < 2 ) && ( J != _tStateToActionNameMap.end() ) ) ;++J)
    {
      //
      //  Resolve FROM object identifier to a state name.
      //
      if ( I->second.first == J->first.first )
      {
        I->second.first = J->first.second;
        ++K;
      }
      //
      //  Resolve TO object identifier to a state name.
      //
      if ( I->second.second == J->first.first )
      {
        I->second.second = J->first.second;
        ++K;
      }
    }
  }

}  // ResolveStates()


static void _WriteActions (void)
{
  
  TStateToActionNameMap::iterator   I;

  for (I = _tStateToActionNameMap.begin(); ( I != _tStateToActionNameMap.end() ) ;++I)
  {
    if ( !I->second.empty() )
    {
      std::cout << "    <action state=\"" << I->first.second
                << "\" actions=\""        << I->second
                << "\">\n";
    }
  }

}  // _WriteTransitions()


static void _WriteDfaml (const TString& rkySOURCE_DFAML_NAME)
{

  using std::cout;
  using std::time_t;

  TStateToActionNameMap::const_iterator   I;
  char*                                   pcCurrentTime;
  time_t                                  tCurrentTime;
  TString                                 yDtdVersion;
  TString                                 yInitialState = *_tInitialStateSet.begin();
  
  //
  //  If there are no actions, then DTD version is 1.0, else is 2.0.
  //
  yDtdVersion = ( _tStateToActionNameMap.empty() ) ? "1.0" : "2.0";

  //
  //  Gets current date, and removes the last character '\n'
  //  from the string returned from std::ctime().
  //
  std::time (&tCurrentTime);
  pcCurrentTime                                      = std::ctime (&tCurrentTime);
  *(pcCurrentTime + std::strlen (pcCurrentTime) - 1) = '\0';

  //
  //  Writes header.
  //
  cout << Format ( "<!doctype dfaml public \"-//MPCL//DTD DFAML %s//EN\">\n"
                   "<dfaml name=\"%s\">\n"
                   "  <desc>Created with DIA2DFAML (DFAML %s) on %s.</desc>\n"
                   "  <transtbl initial=\"%s\">\n"                             ,
                   yDtdVersion.c_str()                                         ,
                   rkySOURCE_DFAML_NAME.c_str()                                ,
                   yDtdVersion.c_str()                                         ,
                   pcCurrentTime                                               ,
                   yInitialState.c_str()                                       );

  //
  //  Writes STATEs.
  //
  for (I = _tStateToActionNameMap.begin(); ( I != _tStateToActionNameMap.end() ) ;++I)
  {
    cout << "    <state name=\"" << I->first.second;
    
    //
    //  If this is a final state, then writes the corresponding attribute.
    //
    if ( _tFinalStateSet.find (I->first.second) == _tFinalStateSet.end() )
    {
      cout << "\">\n";
    }
    else
    {
      cout << "\" type=\"final\">\n";
    }
    _WriteTransitions (I->first.second);
    cout << "    </state>\n";
  }
  cout << "  </transtbl>\n";

  //
  //  Writes ACTLIST if any state has actions.
  //
  if ( !_tStateToActionNameMap.empty() )
  {
    cout << "  <actlist>\n";
    _WriteActions();
    cout << "  </actlist>\n";
  }
  cout << "</dfaml>\n";

}  // _WriteDfaml()


static void _WriteTransitions (const TString& rkySOURCE_STATE)
{
  
  TMessageToConnectionMap::iterator   I;
  
  for (I = _tMessageToConnectionMap.begin(); ( I != _tMessageToConnectionMap.end() ) ;++I)
  {
    if ( I->second.first == rkySOURCE_STATE )
    {
      std::cout << "      <transit event=\"" << I->first 
                << "\" next=\""              << I->second.second
                << "\">\n";
    }
  }
  
}  // _WriteTransitions()


static void _PrintUsage (void)
{

  std::cout << "Usage:  diadfaml [OPTION]... [{FILE, -}]\n\n"
            << "Overall Options:\n"
            << "  -n, --name=DFAML_NAME\n\n"
            << "Informative output:\n"
            << "  -h, --help\n"
            << "  -V, --version\n\n";

}  // _PrintUsage()


int main (int argc, const char* argv[])
{

  using std::cerr;
  using std::cin;
  using std::cout;
  using std::endl;
  
  TMatcher                    tMatcher;
  TString                     yNull;
  TString                     yObjectId;
  TString                     yObjectType;
  TConfigProcessor            tConfig (argc, argv);
  int                         iExitCode      = 0;
  std::basic_istream<char>*   ptInputIstream = NULL;
  
  std::setlocale (LC_ALL, "");
  try
  {
    tConfig.addOption ("name",    "n", "generic_dfa");
    tConfig.addOption ("help",    "h");
    tConfig.addOption ("version", "V");
    tConfig.processOptions();
    if ( tConfig ["help"].isAtCmdLine() )
    {
      _PrintUsage();
    }
    else if ( tConfig ["version"].isAtCmdLine() )
    {
      cout << _pkcVersion << endl;
    }
    else
    {
      switch (tConfig.numberOfArguments())
      {
        case 0:
        {
          //
          //  Input is from standard input stream.
          //
          ptInputIstream = &cin;
          break;
        }
        case 1:
        {
          if ( tConfig.argumentValue (0) == "-" )
          {
            //
            //  Input is from standard input stream.
            //
            ptInputIstream = &cin;
          }
          else
          {
            //
            //  Input is from a file.
            //
            ptInputIstream = new std::basic_ifstream<char> (tConfig.argumentValue (0).c_str());
            if ( !ptInputIstream->good() )
            {
              throw mpcl::TNotFoundException (GetErrorMessage(), __FILE__, __LINE__);
            }
          }
          break;
        }
        default:
        {
          //
          //  Too many arguments.
          //
          throw TIntegrityException ("too many files", __FILE__, __LINE__);
        }
      }
      tMatcher.setInput (*ptInputIstream);
      tMatcher.define ("{sep}", "[[:space:]]");
      tMatcher.scan ( "%t<dia:layer name=\"Background\" visible=\"true\">{sep}*", NULL);
      while ( tMatcher.scan ( "<dia:object type=%q version=%q id=%q>{sep}*" ,
                              &yObjectType                                  ,
                              &yNull                                        ,
                              &yObjectId                                    ,
                              NULL                                          ) )
      {
        if ( yObjectType == "UML - Class" )
        {
          _ParseUmlClass (tMatcher, yObjectId);
        }
        else if ( yObjectType == "UML - Message" )
        {
          _ParseUmlMessage (tMatcher, yObjectId);
        }
        else
        {
          tMatcher.scan("%t</dia:object>{sep}*", NULL);
        }
      }
      //
      //  Resolves state identifiers to names.
      //
      _ResolveStates();
      _CheckIntegrity();
      _WriteDfaml (tConfig ["name"].getValue());
    }
  }
  catch (const mpcl::TException& rktEXCEPTION)
  {
    iExitCode = 3;
    cerr << rktEXCEPTION.what() << endl;
  }
  catch (const std::exception& rktEXCEPTION)
  {
    iExitCode = 2;
    cerr << rktEXCEPTION.what() << endl;
  }
  catch (...)
  {
    iExitCode = 1;
    cerr << mpcl::TException ("unhandled exception", NULL, __FILE__, __LINE__).what() << endl;
  }

  //
  //  Destroys dynamicly created objects.
  //
  if ( ptInputIstream && ( ptInputIstream != &cin ) )
  {
    delete ptInputIstream;
  }
  return iExitCode;

}  // main()

---