X-Git-Url: https://git.creatis.insa-lyon.fr/pubgit/?a=blobdiff_plain;f=appli%2Fbash%2FcpPlugins_CreateInstances.cxx;h=a286d9311d1737034fe37feb8efe92fecbf926be;hb=a45c494fd214d02909f227909db3d9e04986b130;hp=e9a4590ca9f05d81fd56366cd511759cd9c42cbe;hpb=d300d9869563bae0ac020e7ed00a5a9905c897fb;p=cpPlugins.git

diff --git a/appli/bash/cpPlugins_CreateInstances.cxx b/appli/bash/cpPlugins_CreateInstances.cxx
index e9a4590..a286d93 100644
--- a/appli/bash/cpPlugins_CreateInstances.cxx
+++ b/appli/bash/cpPlugins_CreateInstances.cxx
@@ -1,9 +1,4 @@
-#include <fstream>
-#include <iostream>
-
-#include <algorithm>
-#include <cctype>
-#include <cstring>
+#include <cpPlugins_Config.h>
 #include <map>
 #include <vector>
 #include <sstream>
@@ -14,14 +9,11 @@ typedef std::map< char, TLines >        TParsedLines;
 typedef std::map< std::string, TLines > TVariables;
 
 // -------------------------------------------------------------------------
-TLines Tokenize( const std::string& str, const std::string& delims );
-std::string Replace(
-  const std::string& str, const std::string& sub, const std::string& nsub
-  );
 bool ReadFile( TParsedLines& lines, const std::string& fname );
 void ExpandGroups( TLines& res, const TLines& lines );
-void ExpandVariables( TLines& res, const TLines& lines, const TVariables& vars );
-void ParseIncludes( TLines& res, const TLines& lines, const std::string& ext );
+void ExpandDefinitions(
+  TLines& res, const TLines& lines, const TVariables& vars
+  );
 void PrintLines(
   const std::string& prefix, const std::string& suffix,
   const TLines& lines, std::ostream& out
@@ -39,224 +31,160 @@ int main( int argc, char* argv[] )
     return( 1 );
 
   } // fi
-  std::string lname = argv[ 2 ];
+  std::string input_definitions_fname = argv[ 1 ];
+  std::string library_name = argv[ 2 ];
+  std::string header_file_fname = argv[ 3 ];
+  std::string source_file_fname = argv[ 4 ];
 
   // Read file and simple parse it
   TParsedLines lines;
-  if( !ReadFile( lines, argv[ 1 ] ) )
+  if( !ReadFile( lines, input_definitions_fname ) )
   {
     std::cerr
       << "Error opening file: \""
-      << argv[ 1 ] << "\""
+      << input_definitions_fname << "\""
       << std::endl;
     return( 1 );
 
   } // fi
 
-  // Build definitions
+  // Expand definitions
   TVariables vars;
   for( auto dIt = lines[ 'd' ].begin( ); dIt != lines[ 'd' ].end( ); ++dIt )
   {
-    auto tokens = Tokenize( *dIt, "=;" );
+    TLines tokens;
+    cpPlugins::TokenizeString( tokens, *dIt, "=;" );
     auto tIt = tokens.begin( );
     auto vName = *tIt;
     tIt++;
     for( ; tIt != tokens.end( ); ++tIt )
       vars[ vName ].push_back( *tIt );
 
-  } // rof
-
-  // First include section
-  TLines first_includes;
-  ParseIncludes( first_includes, lines[ 'f' ], "" );
-
-  TLines normal_includes;
-  ParseIncludes( normal_includes, lines[ 'i' ], "" );
+    TLines res;
+    ExpandDefinitions( res, vars[ vName ], vars );
+    vars[ vName ] = res;
 
-  TLines template_includes;
-  ParseIncludes( template_includes, lines[ 't' ], "" );
-
-  TLines template_sources;
-  ParseIncludes( template_sources, lines[ 't' ], "xx" );
+  } // rof
 
   // Expand groups
-  TLines classes;
-  ExpandGroups( classes, lines[ 'c' ] );
-
-  // Expand variables
-  TLines real_classes;
-  ExpandVariables( real_classes, classes, vars );
-
-  // Prepare precompiler options
-  TLines global_header;
-  std::stringstream global_header_stream;
-  global_header_stream
-    << "#ifndef __" << lname << "__H__" << std::endl
-    << "#define __" << lname << "__H__" << std::endl<< std::endl
-    << "#include <cpPlugins_Config.h>" << std::endl << std::endl;
-  global_header.push_back( global_header_stream.str( ) );
-
-  TLines macro_header;
-  std::stringstream macro_header_stream;
-  macro_header_stream
-    << "#ifdef " << lname << "_EXPORTS" << std::endl
-    << "#  define " << lname << "_PREFIX template class "
-    << lname << "_EXPORT" << std::endl
-    << "#else // " << lname << "_EXPORTS" << std::endl
-    << "#  define " << lname << "_PREFIX extern template class" << std::endl
-    << "#endif // " << lname << "_EXPORTS" << std::endl;
-  macro_header.push_back( macro_header_stream.str( ) );
-
-  TLines end_global_header;
-  std::stringstream end_global_header_stream;
-  end_global_header_stream
-    << "#endif // __" << lname << "__H__" << std::endl;
-  end_global_header.push_back( end_global_header_stream.str( ) );
+  TLines f_includes_groups, includes_groups, templates_groups, classes_groups;
+  ExpandGroups( f_includes_groups, lines[ 'f' ] );
+  ExpandGroups( includes_groups, lines[ 'i' ] );
+  ExpandGroups( templates_groups, lines[ 't' ] );
+  ExpandGroups( classes_groups, lines[ 'c' ] );
+
+  // Expand definitions
+  TLines f_includes_list, includes_list, templates_list, classes_list;
+  ExpandDefinitions( f_includes_list, f_includes_groups, vars );
+  ExpandDefinitions( includes_list, includes_groups, vars );
+  ExpandDefinitions( templates_list, templates_groups, vars );
+  ExpandDefinitions( classes_list, classes_groups, vars );
 
   // Write header file
-  std::ofstream header_file( argv[ 3 ] );
+  std::ofstream header_file( header_file_fname.c_str( ) );
   if( !header_file )
   {
     std::cerr
-      << "Error opening \"" << argv[ 3 ] << "\" for writing." << std::endl;
+      << "Error opening \"" << header_file_fname
+      << "\" for writing." << std::endl;
     return( 1 );
 
   } // fi
-  PrintLines( "", "", global_header, header_file );
+
+  // Print header
   header_file
-    << "#include <" << lname << "_Export.h>" << std::endl << std::endl;
+    << "#ifndef __" << library_name << "__H__" << std::endl
+    << "#define __" << library_name << "__H__" << std::endl<< std::endl
+    << "#include <cpPlugins_Config.h>" << std::endl
+    << "#include <" << library_name << "_Export.h>" << std::endl << std::endl;
   PrintLines( "", "", lines[ 'b' ], header_file );
   header_file << std::endl;
-  PrintLines( "", "", first_includes, header_file );
-  PrintLines( "", "", macro_header, header_file );
-  PrintLines( "", "", normal_includes, header_file );
-  PrintLines( "", "", template_includes, header_file );
-  header_file << std::endl << "#ifdef " << lname << "_EXPORTS" << std::endl;
-  PrintLines( "", "", template_sources, header_file );
-  header_file << "#endif // " << lname << "_EXPORTS" << std::endl;
-  header_file << std::endl;
-  PrintLines( lname + std::string( "_PREFIX " ), ";", real_classes, header_file );
-  header_file << std::endl;
-  PrintLines( "", "", end_global_header, header_file );
+  PrintLines( "#include <", ">", f_includes_list, header_file );
+  header_file
+    << "#ifdef " << library_name << "_EXPORTS" << std::endl
+    << "#  define " << library_name << "_PREFIX template class "
+    << library_name << "_EXPORT" << std::endl
+    << "#else // " << library_name << "_EXPORTS" << std::endl
+    << "#  define " << library_name
+    << "_PREFIX extern template class" << std::endl
+    << "#endif // "
+    << library_name << "_EXPORTS" << std::endl << std::endl;
+  PrintLines( "#include <", ">", includes_list, header_file );
+  PrintLines( "#include <", ">", templates_list, header_file );
+  header_file
+    << std::endl << "#ifdef " << library_name << "_EXPORTS" << std::endl;
+  PrintLines( "#include <", "xx>", templates_list, header_file );
+  header_file
+    << "#endif // " << library_name << "_EXPORTS" << std::endl << std::endl;
+  PrintLines(
+    library_name + std::string( "_PREFIX " ), ";", classes_list, header_file
+    );
+  header_file
+    << std::endl << "#endif // __" << library_name << "__H__" << std::endl;
   header_file.close( );
 
   // Write source file
-  std::ofstream source_file( argv[ 4 ] );
+  std::ofstream source_file( source_file_fname );
   if( !source_file )
   {
     std::cerr
-      << "Error opening \"" << argv[ 3 ] << "\" for writing." << std::endl;
+      << "Error opening \"" << header_file_fname << "\" for writing." << std::endl;
     return( 1 );
 
   } // fi
   source_file
-    << "#include \"" << argv[ 3 ] << "\"" << std::endl;
-  /* TODO
-     PrintLines( "", "", first_includes, source_file );
-     PrintLines( "", "", template_includes, source_file );
-     source_file << std::endl;
-     PrintLines(
-     std::string( "template class " ) + lname + std::string( "_EXPORT " ),
-     ";", real_classes, source_file
-     );
-  */
+    << "#include \"" << header_file_fname << "\"" << std::endl;
   source_file.close( );
-  return( 0 );
-}
-
-// -------------------------------------------------------------------------
-TLines Tokenize( const std::string& str, const std::string& delims )
-{
-  TLines tokens;
-  if( str.size( ) > 0 )
-  {
-    char* buffer = new char[ str.size( ) + 1 ];
-    std::strcpy( buffer, str.c_str( ) );
-    buffer[ str.size( ) ] = '\0';
-    char* it = std::strtok( buffer, delims.c_str( ) );
-    while( it != NULL )
-    {
-      tokens.push_back( std::string( it ) );
-      it = std::strtok( NULL, delims.c_str( ) );
-
-    } // elihw
-    delete buffer;
-
-  } // fi
-  return( tokens );
-}
-
-// -------------------------------------------------------------------------
-std::string Replace(
-  const std::string& str, const std::string& sub, const std::string& nsub
-  )
-{
-  std::string res = str;
-  size_t index = 0;
-  while( true )
-  {
-    index = res.find( sub,  index );
-    if( index == std::string::npos ) break;
-    res.replace( index, sub.size( ), nsub );
-    index += sub.size( );
 
-  } // elihw
-  return( res );
+  return( 0 );
 }
 
 // -------------------------------------------------------------------------
 bool ReadFile( TParsedLines& lines, const std::string& fname )
 {
-  // Load file into a string stream
-  std::ifstream file_stream( fname.c_str( ) );
-  if( !file_stream )
-    return( false );
   std::string buffer;
-  file_stream.seekg( 0, std::ios::end );
-  buffer.reserve( file_stream.tellg( ) );
-  file_stream.seekg( 0, std::ios::beg );
-  buffer.assign(
-    ( std::istreambuf_iterator< char >( file_stream ) ),
-    std::istreambuf_iterator< char >( )
-    );
-  file_stream.close( );
-  std::istringstream input_stream( buffer );
-
-  // Read line by line
-  std::string line;
-  while( std::getline( input_stream, line ) )
+  if( cpPlugins::ReadFileIntoString( buffer, fname ) )
   {
-    auto cmd_pos = line.end( );
-    auto arg_pos = line.end( );
-    auto lIt = line.begin( );
-    while( lIt != line.end( ) )
+    std::istringstream input_stream( buffer );
+
+    // Read line by line
+    std::string line;
+    while( std::getline( input_stream, line ) )
     {
-      if( !std::isblank( *lIt ) )
+      auto cmd_pos = line.end( );
+      auto arg_pos = line.end( );
+      auto lIt = line.begin( );
+      while( lIt != line.end( ) )
       {
-        if( cmd_pos == line.end( ) )
+        if( !cpPlugins::IsBlank( *lIt ) )
         {
-          cmd_pos = lIt;
-          ++lIt;
+          if( cmd_pos == line.end( ) )
+          {
+            cmd_pos = lIt;
+            ++lIt;
+          }
+          else if( arg_pos == line.end( ) )
+          {
+            arg_pos = lIt;
+            lIt = line.end( );
+
+          } // fi
         }
-        else if( arg_pos == line.end( ) )
-        {
-          arg_pos = lIt;
-          lIt = line.end( );
+        else
+          ++lIt;
+
+      } // elihw
+      char cmd = *cmd_pos;
+      std::string arg;
+      arg.resize( line.end( ) - arg_pos );
+      std::copy( arg_pos, line.end( ), arg.begin( ) );
+      lines[ cmd ].push_back( arg );
 
-        } // fi
-      }
-      else
-        ++lIt;
-      
     } // elihw
-    char cmd = *cmd_pos;
-    std::string arg;
-    arg.resize( line.end( ) - arg_pos );
-    std::copy( arg_pos, line.end( ), arg.begin( ) );
-    lines[ cmd ].push_back( arg );
-
-  } // elihw
-  return( true );
+    return( true );
+  }
+  else
+    return( false );
 }
 
 // -------------------------------------------------------------------------
@@ -264,15 +192,30 @@ void ExpandGroups( TLines& res, const TLines& lines )
 {
   for( auto lIt = lines.begin( ); lIt != lines.end( ); ++lIt )
   {
-    auto b_pos = lIt->find( "#{" );
+    auto b_pos = lIt->find( "@{" );
     if( b_pos != std::string::npos )
     {
-      auto e_pos = lIt->find( "}" );
-      auto expansion = lIt->substr( b_pos + 2, e_pos - b_pos - 2 );
-      auto tokens = Tokenize( expansion, ";" );
-      for( auto tIt = tokens.begin( ); tIt != tokens.end( ); ++tIt )
-        *tIt = lIt->substr( 0, b_pos ) + *tIt + lIt->substr( e_pos + 1 );
-      ExpandGroups( res, tokens );
+      unsigned int braces_count = 1;
+      auto e_pos = b_pos;
+      e_pos += 2;
+      while( braces_count != 0 && e_pos < lIt->size( ) )
+      {
+        auto v = ( *lIt )[ e_pos ];
+        braces_count += ( v == '{' )? 1: ( ( v == '}' )? -1: 0 );
+        e_pos++;
+
+      } // elihw
+      if( braces_count == 0 )
+      {
+        auto replace = lIt->substr( b_pos, e_pos - b_pos );
+        auto expansion = replace.substr( 2, replace.size( ) - 3 );
+        TLines tokens;
+        cpPlugins::TokenizeString( tokens, expansion, ";" );
+        for( auto tIt = tokens.begin( ); tIt != tokens.end( ); ++tIt )
+          *tIt = cpPlugins::ReplaceString( *lIt, replace, *tIt );
+        ExpandGroups( res, tokens );
+
+      } // fi
     }
     else
       res.push_back( *lIt );
@@ -281,61 +224,46 @@ void ExpandGroups( TLines& res, const TLines& lines )
 }
 
 // -------------------------------------------------------------------------
-void ExpandVariables( TLines& res, const TLines& lines, const TVariables& vars )
+void ExpandDefinitions(
+  TLines& res, const TLines& lines, const TVariables& vars
+  )
 {
-  const char* int_types[] = { "char", "short", "int", "long" };
-  const char* float_types[] = { "float", "double" };
-  unsigned int n_int_types = 4, n_float_types = 2;
+  std::string seps = " ,;:{}[]()\"$&<>*.";
+
   for( auto lIt = lines.begin( ); lIt != lines.end( ); ++lIt )
   {
     auto b_pos = lIt->find( "#" );
     if( b_pos != std::string::npos )
     {
-      auto tokens = Tokenize( lIt->substr( b_pos ), " ,;:{}[]()\"$&<>" );
+      TLines tokens;
+      cpPlugins::TokenizeString( tokens, lIt->substr( b_pos ), seps );
       std::string cmd = tokens[ 0 ];
-      if(
-        cmd == "#int_types" || cmd == "#uint_types" || cmd == "#float_types"
-        )
+      auto vIt = vars.find( cmd );
+      if( vIt != vars.end( ) )
       {
-        const char** types = ( cmd == "#float_types" )? float_types: int_types;
-        unsigned int size = ( cmd == "#float_types" )? n_float_types: n_int_types;
-        std::string ustr = ( ( cmd == "#uint_types" )? "unsigned ": "" );
-        TLines new_res;
-        for( unsigned int i = 0; i < size; ++i )
-          new_res.push_back( Replace( *lIt, cmd, ustr + types[ i ] ) );
-        ExpandVariables( res, new_res, vars );
-      }
-      else
-      {
-        auto vIt = vars.find( cmd );
-        if( vIt != vars.end( ) )
+        if( vIt->second.size( ) > 0 )
         {
           TLines new_res;
           for(
             auto wIt = vIt->second.begin( ); wIt != vIt->second.end( ); ++wIt
             )
-            new_res.push_back( Replace( *lIt, cmd, *wIt ) );
-          ExpandVariables( res, new_res, vars );
+            new_res.push_back( cpPlugins::ReplaceString( *lIt, cmd, *wIt ) );
+          ExpandDefinitions( res, new_res, vars );
 
         } // fi
 
       } // fi
     }
     else
-      res.push_back( *lIt );
+      res.push_back(
+        cpPlugins::ReplaceString(
+          cpPlugins::ReplaceString( *lIt, "{", "" ), "}", ""
+          )
+        );
 
   } // rof
 }
 
-// -------------------------------------------------------------------------
-void ParseIncludes( TLines& res, const TLines& lines, const std::string& ext )
-{
-  for( auto lIt = lines.begin( ); lIt != lines.end( ); ++lIt )
-    res.push_back(
-      std::string( "#include <" ) + *lIt + ext + std::string( ">" )
-      );
-}
-
 // -------------------------------------------------------------------------
 void PrintLines(
   const std::string& prefix, const std::string& suffix,