22318: [CEA] Problems with study dump in SMESH

Memory usage and performance optimization: do not make a script from
lines and than split it back into lines several times.

src/SMESH_I/SMESH_2smeshpy.cxx

@@ -183,7 +183,8 @@ namespace {
     if ( cmd->GetString().Location( TPythonDump::NotPublishedObjectName(), 1, cmd->Length() ))
     {
       bool isResultPublished = false;
-      for ( int i = 0; i < cmd->GetNbResultValues(); i++ )
+      const int nbRes = cmd->GetNbResultValues();
+      for ( int i = 0; i < nbRes; i++ )
       {
         _pyID objID = cmd->GetResultValue( i+1 );
         if ( cmd->IsStudyEntry( objID ))
@@ -198,7 +199,12 @@ namespace {
     }
     // check if an Object was created in the script
     _AString comment;
-    const _pyID&        obj = cmd->GetObject();
+
+    _pyID obj = cmd->GetObject();
+    if ( !obj.IsEmpty() && obj.Value( obj.Length() ) == ')' )
+      // remove an accessor method
+      obj = _pyCommand( obj ).GetObject();
+
     const bool isMethodCall = cmd->IsMethodCall();
     if ( !obj.IsEmpty() && isMethodCall && !presentObjects.count( obj ) )
     {
@@ -444,7 +450,7 @@ namespace {
 //================================================================================
 /*!
  * \brief Convert a python script using commands of smeshBuilder.py
- *  \param theScript - Input script
+ *  \param theScriptLines - Lines of the input script
  *  \param theEntry2AccessorMethod - returns method names to access to
  *         objects wrapped with python class
  *  \param theObjectNames - names of objects
@@ -456,30 +462,26 @@ namespace {
 //================================================================================
 
 void
-SMESH_2smeshpy::ConvertScript(TCollection_AsciiString&                  theScript,
+SMESH_2smeshpy::ConvertScript(std::list< TCollection_AsciiString >&     theScriptLines,
                               Resource_DataMapOfAsciiStringAsciiString& theEntry2AccessorMethod,
                               Resource_DataMapOfAsciiStringAsciiString& theObjectNames,
                               std::set< TCollection_AsciiString >&      theRemovedObjIDs,
                               SALOMEDS::Study_ptr&                      theStudy,
                               const bool                                theToKeepAllCommands)
 {
+  std::list< TCollection_AsciiString >::iterator lineIt;
   // process notebook variables
   {
     SMESH_NoteBook aNoteBook;
 
-    int from = 1, end = theScript.Length(), to;
+    for ( lineIt = theScriptLines.begin(); lineIt != theScriptLines.end(); ++lineIt )
-    while ( from < end && ( to = theScript.Location( "\n", from, end )))
+      aNoteBook.AddCommand( *lineIt );
-    {
+
-      if ( to != from )
+    theScriptLines.clear();
-        // cut out and store a command
-        aNoteBook.AddCommand( theScript.SubString( from, to - 1 ));
-      from = to + 1;
-    }
-    theScript.Clear();
 
     aNoteBook.ReplaceVariables();
 
-    theScript = aNoteBook.GetResultScript();
+    aNoteBook.GetResultLines( theScriptLines );
   }
 
   // convert to smeshBuilder.py API
@@ -490,16 +492,10 @@ SMESH_2smeshpy::ConvertScript(TCollection_AsciiString&                  theScrip
                        theStudy,
                        theToKeepAllCommands );
 
-  // split theScript into separate commands
+  for ( lineIt = theScriptLines.begin(); lineIt != theScriptLines.end(); ++lineIt )
-  int from = 1, end = theScript.Length(), to;
+    theGen->AddCommand( *lineIt );
-  while ( from < end && ( to = theScript.Location( "\n", from, end )))
+
-  {
+  theScriptLines.clear();
-    if ( to != from )
-      // cut out and store a command
-      theGen->AddCommand( theScript.SubString( from, to - 1 ));
-    from = to + 1;
-  }
-  theScript.Clear();
 
   // finish conversion
   theGen->Flush();
@@ -535,12 +531,10 @@ SMESH_2smeshpy::ConvertScript(TCollection_AsciiString&                  theScrip
       CheckObjectPresence( *cmd, createdObjects );
       if ( !(*cmd)->IsEmpty() ) {
         aPrevCmd = (*cmd)->GetString();
-        theScript += "\n";
+        theScriptLines.push_back( aPrevCmd );
-        theScript += aPrevCmd;
       }
     }
   }
-  theScript += "\n";
 
   theGen->Free();
   theGen.Nullify();
@@ -643,17 +637,23 @@ Handle(_pyCommand) _pyGen::AddCommand( const TCollection_AsciiString& theCommand
   // Method( SMESH.PointStruct(x,y,z)... -> Method( [x,y,z]...
   StructToList( aCommand );
 
+  const TCollection_AsciiString& method = aCommand->GetMethod();
+
   // not to erase _pySelfEraser's etc. used as args in some commands
   {
 #ifdef USE_STRING_FAMILY
-    _pyID objID;
+    std::list<_pyID>  objIDs;
-    if ( myKeepAgrCmdsIDs.IsIn( theCommand, objID ))
+    if ( myKeepAgrCmdsIDs.IsInArgs( aCommand, objIDs ))
     {
-      Handle(_pyObject) obj = FindObject( objID );
+      std::list<_pyID>::iterator objID = objIDs.begin();
-      if ( !obj.IsNull() )
+      for ( ; objID != objIDs.end(); ++objID )
       {
-        obj->AddArgCmd( aCommand );
+        Handle(_pyObject) obj = FindObject( *objID );
-        //cout << objID << " found in " << theCommand << endl;
+        if ( !obj.IsNull() )
+        {
+          obj->AddArgCmd( aCommand );
+          //cout << objID << " found in " << theCommand << endl;
+        }
       }
     }
 #else
@@ -695,8 +695,7 @@ Handle(_pyCommand) _pyGen::AddCommand( const TCollection_AsciiString& theCommand
     else if ( aCommand->GetMethod() == "GetSubMesh" ) { // SubMesh creation
       _pyID subMeshID = aCommand->GetResultValue();
       Handle(_pySubMesh) subMesh = new _pySubMesh( aCommand );
-      CheckObjectIsReCreated( subMesh );
+      AddObject( subMesh );
-      myObjects.insert( make_pair( subMeshID, subMesh ));
     }
 
     // Method( mesh.GetIDSource([id1,id2]) -> Method( [id1,id2]
@@ -718,8 +717,6 @@ Handle(_pyCommand) _pyGen::AddCommand( const TCollection_AsciiString& theCommand
 
     //addFilterUser( aCommand, theGen ); // protect filters from clearing
 
-    const TCollection_AsciiString& method = aCommand->GetMethod();
-
     // some commands of SMESH_MeshEditor create meshes and groups
     _pyID meshID, groups;
     if ( method.Search("MakeMesh") != -1 )
@@ -981,11 +978,11 @@ void _pyGen::Process( const Handle(_pyCommand)& theCommand )
       method == "CreateMeshesFromCGNS" ||
       method == "CreateMeshesFromGMF" ) // command result is ( [mesh1,mesh2], status )
   {
-    for ( int ind = 0; ind < theCommand->GetNbResultValues(); ind++ )
+    std::list< _pyID > meshIDs = theCommand->GetStudyEntries( theCommand->GetResultValue() );
+    std::list< _pyID >::iterator meshID = meshIDs.begin();
+    for ( ; meshID != meshIDs.end(); ++meshID )
     {
-      _pyID meshID = theCommand->GetResultValue(ind+1);
+      Handle(_pyMesh) mesh = new _pyMesh( theCommand, *meshID );
-      if ( !theCommand->IsStudyEntry( meshID ) ) continue;
-      Handle(_pyMesh) mesh = new _pyMesh( theCommand, theCommand->GetResultValue(ind+1));
       AddObject( mesh );
     }
     if ( method == "CreateMeshesFromGMF" )
@@ -1053,7 +1050,7 @@ void _pyGen::Process( const Handle(_pyCommand)& theCommand )
        method == "CreateMeasurements" )
   {
     Handle(_pyObject) obj = new _pySelfEraser( theCommand );
-    if ( !myObjects.insert( make_pair( obj->GetID(), obj )).second )
+    if ( !AddObject( obj ) )
       theCommand->Clear(); // already created
   }
   // Concatenate( [mesh1, ...], ... )
@@ -1149,10 +1146,15 @@ void _pyGen::Flush()
         id_hyp->second->GetCreationCmd()->SetObject( SMESH_2smeshpy::GenName() );
     }
 
-  // Flush other objects
+  // Flush other objects. 2 times, for objects depending on Flush() of later created objects
-  for ( id_obj = myObjects.begin(); id_obj != myObjects.end(); ++id_obj )
+  std::list< Handle(_pyObject) >::reverse_iterator robj = myOrderedObjects.rbegin();
-    if ( ! id_obj->second.IsNull() )
+  for ( ; robj != myOrderedObjects.rend(); ++robj )
-      id_obj->second->Flush();
+    if ( ! robj->IsNull() )
+      (*robj)->Flush();
+  std::list< Handle(_pyObject) >::iterator obj = myOrderedObjects.begin();
+  for ( ; obj != myOrderedObjects.end(); ++obj )
+    if ( ! obj->IsNull() )
+      (*obj)->Flush();
 
   myLastCommand->SetOrderNb( ++myNbCommands );
   myCommands.push_back( myLastCommand );
@@ -1167,23 +1169,23 @@ void _pyGen::Flush()
 
 void _pyGen::PlaceSubmeshAfterItsCreation( Handle(_pyCommand) theCmdUsingSubmesh ) const
 {
-  map< _pyID, Handle(_pyObject) >::const_iterator id_obj = myObjects.begin();
+  // map< _pyID, Handle(_pyObject) >::const_iterator id_obj = myObjects.begin();
-  for ( ; id_obj != myObjects.end(); ++id_obj )
+  // for ( ; id_obj != myObjects.end(); ++id_obj )
-  {
+  // {
-    if ( !id_obj->second->IsKind( STANDARD_TYPE( _pySubMesh ))) continue;
+  //   if ( !id_obj->second->IsKind( STANDARD_TYPE( _pySubMesh ))) continue;
-    for ( int iArg = theCmdUsingSubmesh->GetNbArgs(); iArg; --iArg )
+  //   for ( int iArg = theCmdUsingSubmesh->GetNbArgs(); iArg; --iArg )
-    {
+  //   {
-      const _pyID& arg = theCmdUsingSubmesh->GetArg( iArg );
+  //     const _pyID& arg = theCmdUsingSubmesh->GetArg( iArg );
-      if ( arg.IsEmpty() || arg.Value( 1 ) == '"' || arg.Value( 1 ) == '\'' )
+  //     if ( arg.IsEmpty() || arg.Value( 1 ) == '"' || arg.Value( 1 ) == '\'' )
-        continue;
+  //       continue;
-      list< _pyID > idList = theCmdUsingSubmesh->GetStudyEntries( arg );
+  //     list< _pyID > idList = theCmdUsingSubmesh->GetStudyEntries( arg );
-      list< _pyID >::iterator id = idList.begin();
+  //     list< _pyID >::iterator id = idList.begin();
-      for ( ; id != idList.end(); ++id )
+  //     for ( ; id != idList.end(); ++id )
-        if ( id_obj->first == *id )
+  //       if ( id_obj->first == *id )
-          // _pySubMesh::Process() does what we need
+  //         // _pySubMesh::Process() does what we need
-          Handle(_pySubMesh)::DownCast( id_obj->second )->Process( theCmdUsingSubmesh );
+  //         Handle(_pySubMesh)::DownCast( id_obj->second )->Process( theCmdUsingSubmesh );
-    }
+  //   }
-  }
+  // }
 }
 
 //================================================================================
@@ -1203,9 +1205,15 @@ void _pyGen::ClearCommands()
     if ( !id_hyp->second.IsNull() )
       id_hyp->second->ClearCommands();
 
-  map< _pyID, Handle(_pyObject) >::iterator id_obj = myObjects.begin();
+  // Other objects. 2 times, for objects depending on ClearCommands() of later created objects
-  for ( ; id_obj != myObjects.end(); ++id_obj )
+  std::list< Handle(_pyObject) >::reverse_iterator robj = myOrderedObjects.rbegin();
-    id_obj->second->ClearCommands();
+  for ( ; robj != myOrderedObjects.rend(); ++robj )
+    if ( ! robj->IsNull() )
+      (*robj)->ClearCommands();
+  std::list< Handle(_pyObject) >::iterator obj = myOrderedObjects.begin();
+  for ( ; obj != myOrderedObjects.end(); ++obj )
+    if ( ! obj->IsNull() )
+      (*obj)->ClearCommands();
 }
 
 //================================================================================
@@ -1500,20 +1508,27 @@ _pyID _pyGen::GenerateNewID( const _pyID& theID )
  */
 //================================================================================
 
-void _pyGen::AddObject( Handle(_pyObject)& theObj )
+bool _pyGen::AddObject( Handle(_pyObject)& theObj )
 {
-  if ( theObj.IsNull() ) return;
+  if ( theObj.IsNull() ) return false;
 
   CheckObjectIsReCreated( theObj );
 
-  if ( theObj->IsKind( STANDARD_TYPE( _pyMesh )))
+  bool add;
-    myMeshes.insert( make_pair( theObj->GetID(), Handle(_pyMesh)::DownCast( theObj )));
 
-  else if ( theObj->IsKind( STANDARD_TYPE( _pyMeshEditor )))
+  if ( theObj->IsKind( STANDARD_TYPE( _pyMesh ))) {
-    myMeshEditors.insert( make_pair( theObj->GetID(), Handle(_pyMeshEditor)::DownCast( theObj )));
+    add = myMeshes.insert( make_pair( theObj->GetID(),
-
+                                      Handle(_pyMesh)::DownCast( theObj ))).second;
-  else
+  }
-    myObjects.insert( make_pair( theObj->GetID(), theObj ));
+  else if ( theObj->IsKind( STANDARD_TYPE( _pyMeshEditor ))) {
+    add = myMeshEditors.insert( make_pair( theObj->GetID(),
+                                          Handle(_pyMeshEditor)::DownCast( theObj ))).second;
+  }
+  else {
+    add = myObjects.insert( make_pair( theObj->GetID(), theObj )).second;
+    if ( add ) myOrderedObjects.push_back( theObj );
+  }
+  return add;
 }
 
 //================================================================================
@@ -1984,7 +1999,7 @@ void _pyMesh::Process( const Handle(_pyCommand)& theCommand )
         {
           addCmd = *cmd;
           cmd    = addHypCmds.erase( cmd );
-          if ( !theGen->IsToKeepAllCommands() ) {
+          if ( !theGen->IsToKeepAllCommands() && CanClear() ) {
             addCmd->Clear();
             theCommand->Clear();
           }
@@ -3445,7 +3460,7 @@ bool _pyAlgorithm::Addition2Creation( const Handle(_pyCommand)& theCmd,
  */
 //================================================================================
 
-int _pyCommand::GetBegPos( int thePartIndex )
+int _pyCommand::GetBegPos( int thePartIndex ) const
 {
   if ( IsEmpty() )
     return EMPTY;
@@ -3485,7 +3500,7 @@ TCollection_AsciiString _pyCommand::GetIndentation()
     GetWord( myString, end, true );
   else
     end = GetBegPos( RESULT_IND );
-  return myString.SubString( 1, end - 1 );
+  return myString.SubString( 1, Max( end - 1, 1 ));
 }
 
 //================================================================================
@@ -3525,16 +3540,8 @@ const TCollection_AsciiString & _pyCommand::GetResultValue()
 
 int _pyCommand::GetNbResultValues()
 {
-  int nb     = 0;
+  GetResultValue(1);
-  int begPos = 1;
+  return myResults.Length();
-  int endPos = myString.Location( "=", 1, Length() );
-  while ( begPos < endPos )
-  {
-    _AString str = GetWord( myString, begPos, true );
-    begPos = begPos+ str.Length();
-    nb++;
-  }
-  return (nb-1);
 }
 
 
@@ -3545,32 +3552,38 @@ int _pyCommand::GetNbResultValues()
  * \retval const TCollection_AsciiString & - ResultValue with res index substring
  */
 //================================================================================
-TCollection_AsciiString _pyCommand::GetResultValue(int res)
+const _AString& _pyCommand::GetResultValue(int res)
 {
-  int begPos = 1;
+  if ( GetResultValue().IsEmpty() )
-  if ( SkipSpaces( myString, begPos ) && myString.Value( begPos ) == '[' )
+    return theEmptyString;
-    ++begPos; // skip [, else the whole list is returned
+
-  int endPos = myString.Location( "=", 1, Length() );
+  if ( myResults.IsEmpty() )
-  int Nb=0;
+  {
-  while ( begPos < endPos) {
+    int begPos = 1;
-    _AString result = GetWord( myString, begPos, true );
+    if ( SkipSpaces( myRes, begPos ) && myRes.Value( begPos ) == '[' )
-    begPos = begPos + result.Length();
+      ++begPos; // skip [, else the whole list is returned
-    Nb++;
+    while ( begPos < myRes.Length() ) {
-    if(res == Nb) {
+      _AString result = GetWord( myRes, begPos, true );
-      result.RemoveAll('[');
+      begPos += result.Length();
-      result.RemoveAll(']');
+      // if(res == Nb) {
-      return result;
+      //   result.RemoveAll('[');
+      //   result.RemoveAll(']');
+      //   return result;
+      // }
+      // if(Nb>res)
+      //   break;
+      myResults.Append( result );
     }
-    if(Nb>res)
-      break;
   }
+  if ( res > 0 && res <= myResults.Length() )
+    return myResults( res );
   return theEmptyString;
 }
 
 //================================================================================
 /*!
  * \brief Return substring of python command looking like ResVal = Object.Meth()
-  * \retval const TCollection_AsciiString & - Object substring
+ * \retval const TCollection_AsciiString & - Object substring
  */
 //================================================================================
 
@@ -3753,6 +3766,24 @@ const TCollection_AsciiString & _pyCommand::GetArg( int index )
   return myArgs( index );
 }
 
+//================================================================================
+/*!
+ * \brief Return position where arguments begin
+ */
+//================================================================================
+
+int _pyCommand::GetArgBeginning() const
+{
+  int pos = GetBegPos( ARG1_IND );
+  if ( pos == UNKNOWN )
+  {
+    pos = GetBegPos( METHOD_IND ) + myMeth.Length();
+    if ( pos < 1 )
+      pos = myString.Location( "(", 4, Length() ); // 4 = strlen("b.c(")
+  }
+  return pos;
+}
+
 //================================================================================
 /*!
  * \brief Check if char is a word part
@@ -3867,11 +3898,10 @@ bool _pyCommand::IsID( const TCollection_AsciiString& str )
 {
   if ( str.Length() < 1 ) return false;
 
-  if ( isdigit( str.Value( 1 )))
+  const char* s = str.ToCString();
-    return IsStudyEntry( str );
 
-  for ( int i = 1; i <= str.Length(); ++i )
+  for ( int i = 0; i < str.Length(); ++i )
-    if ( !isalnum( str.Value( i )) && !str.Value( i ) != '_' )
+    if ( !IsIDChar( s[i] ))
       return false;
 
   return true;
@@ -4038,9 +4068,9 @@ void _pyCommand::Comment()
     myString.Insert( i, "#" );
     for ( int iPart = 1; iPart <= myBegPos.Length(); ++iPart )
     {
-      int begPos = GetBegPos( iPart + 1 );
+      int begPos = GetBegPos( iPart );
-      if ( begPos != UNKNOWN )
+      if ( begPos != UNKNOWN && begPos != EMPTY )
-        SetBegPos( iPart + 1, begPos + 1 );
+        SetBegPos( iPart, begPos + 1 );
     }
   }
 }
@@ -4088,7 +4118,8 @@ bool _pyCommand::AddAccessorMethod( _pyID theObjectID, const char* theAcsMethod
     // check that theObjectID is not just a part of a longer ID
     int afterEnd = beg + theObjectID.Length();
     Standard_Character c = myString.Value( afterEnd );
-    if ( !isalnum( c ) && c != ':' ) {
+    if ( !IsIDChar( c ))
+    {
       // check if accessor method already present
       if ( c != '.' ||
            myString.Location( (char*) theAcsMethod, afterEnd, Length() ) != afterEnd+1) {
@@ -4105,7 +4136,7 @@ bool _pyCommand::AddAccessorMethod( _pyID theObjectID, const char* theAcsMethod
         added = true;
       }
     }
-    beg = afterEnd; // is a part - next search
+    beg = afterEnd; // is a part -> next search
   }
   return added;
 }
@@ -4180,7 +4211,8 @@ _pyID _pyObject::FatherID(const _pyID & childID)
 
 //================================================================================
 /*!
- * \brief SelfEraser erases creation command if no more it's commands invoked
+ * \brief SelfEraser erases creation command if none of it's commands invoked
+ *        (e.g. filterManager) or it's not used as a command argument (e.g. a filter)
  */
 //================================================================================
 
@@ -4193,11 +4225,12 @@ _pySelfEraser::_pySelfEraser(const Handle(_pyCommand)& theCreationCmd)
 
 //================================================================================
 /*!
- * \brief SelfEraser erases creation command if no more it's commands invoked
+ * \brief SelfEraser erases creation command if none of it's commands invoked
+ *        (e.g. filterManager) or it's not used as a command argument (e.g. a filter)
  */
 //================================================================================
 
-void _pySelfEraser::Flush()
+bool _pySelfEraser::CanClear()
 {
   bool toErase = false;
   if ( myIgnoreOwnCalls ) // check if this obj is used as argument
@@ -4205,23 +4238,55 @@ void _pySelfEraser::Flush()
     int nbArgUses = 0;
     list< Handle(_pyCommand) >::iterator cmd = myArgCmds.begin();
     for ( ; cmd != myArgCmds.end(); ++cmd )
-      nbArgUses += !(*cmd)->IsEmpty();
+      nbArgUses += IsAliveCmd( *cmd );
+
     toErase = ( nbArgUses < 1 );
   }
   else
   {
-    int nbCalls = GetNbCalls();
+    int nbCalls = 0;
-    if ( nbCalls > 0 )
+    std::list< Handle(_pyCommand) >& cmds = GetProcessedCmds();
-    {
+    std::list< Handle(_pyCommand) >::const_iterator cmd = cmds.begin();
-      // ignore cleared commands
+    for ( ; cmd != cmds.end(); ++cmd )
-      std::list< Handle(_pyCommand) >& cmds = GetProcessedCmds();
+      // check of cmd emptiness is not enough as object can change
-      std::list< Handle(_pyCommand) >::const_iterator cmd = cmds.begin();
+      nbCalls += ( ( *cmd )->GetString().Search( GetID() ) > 0 );
-      for ( ; cmd != cmds.end(); ++cmd )
+
-        nbCalls -= (*cmd)->IsEmpty();
-    }
     toErase = ( nbCalls < 1 );
   }
-  if ( toErase )
+  return toErase;
+}
+
+//================================================================================
+/*!
+ * \brief Check if a command is or can be cleared
+ */
+//================================================================================
+
+bool _pySelfEraser::IsAliveCmd( const Handle(_pyCommand)& theCmd )
+{
+  if ( theCmd->IsEmpty() )
+    return false;
+
+  if ( !theGen->IsToKeepAllCommands() )
+  {
+    const _pyID& objID = theCmd->GetObject();
+    Handle( _pyObject ) obj = theGen->FindObject( objID );
+    if ( !obj.IsNull() )
+      return !obj->CanClear();
+  }
+  return true;
+}
+
+//================================================================================
+/*!
+ * \brief SelfEraser erases creation command if none of it's commands invoked
+ *        (e.g. filterManager) or it's not used as a command argument (e.g. a filter)
+ */
+//================================================================================
+
+void _pySelfEraser::Flush()
+{
+  if ( CanClear() )
   {
     myIsPublished = false;
     _pyObject::ClearCommands();
@@ -4576,10 +4641,12 @@ void _pyFilter::Process( const Handle(_pyCommand)& theCommand)
     theCommand->SetMethod( "GetFilterFromCriteria" );
 
     // Swap "aFilterManager.CreateFilter()" and "smesh.GetFilterFromCriteria(criteria)"
+    // GetCreationCmd()->Clear();
+    // GetCreationCmd()->GetString() = theCommand->GetString();
+    // theCommand->Clear();
+    // theCommand->AddDependantCmd( GetCreationCmd() );
+    // why swap?
     GetCreationCmd()->Clear();
-    GetCreationCmd()->GetString() = theCommand->GetString();
-    theCommand->Clear();
-    theCommand->AddDependantCmd( GetCreationCmd() );
   }
   else if ( theCommand->GetMethod() == "SetMesh" )
   {
@@ -4909,31 +4976,42 @@ bool _pyStringFamily::Add( const char* str )
  */
 //================================================================================
 
-bool _pyStringFamily::IsIn( const _AString& longStr, _AString& subStr )
+bool _pyStringFamily::IsInArgs( Handle( _pyCommand)& cmd, std::list<_AString>& subStr )
 {
-  const char* s = longStr.ToCString();
+  const _AString& longStr = cmd->GetString();
+  const char*           s = longStr.ToCString();
 
   // look in _subFams
   std::list< _pyStringFamily >::iterator itSub = _subFams.begin();
-  int pos, len;
+  int nbFound = 0, pos, len, from, argBeg = cmd->GetArgBeginning();
+  if ( argBeg < 4 || argBeg > longStr.Length() )
+    return false;
   for ( ; itSub != _subFams.end(); ++itSub )
   {
-    if (( pos = longStr.Search( itSub->_prefix )-1) > 6-1 ) // 6 = strlen("a=b.c(")
+    from = argBeg;
-      if (( len = itSub->isIn( s + pos + itSub->_prefix.Length() )) >= 0 )
+    while (( pos = longStr.Location( itSub->_prefix, from, longStr.Length() )))
+      if (( len = itSub->isIn( s + pos-1 + itSub->_prefix.Length() )) >= 0 )
       {
-        subStr = _AString( s + pos, len + itSub->_prefix.Length() );
+        subStr.push_back( _AString( s + pos-1, len + itSub->_prefix.Length() ));
-        return true;
+        from = pos + len + itSub->_prefix.Length();
+        nbFound++;
+      }
+      else
+      {
+        from += itSub->_prefix.Length();
       }
   }
   // look among _strings
   std::list< _AString >::iterator itStr = _strings.begin();
   for ( ; itStr != _strings.end(); ++itStr )
-    if ( longStr.Search( *itStr ) > itStr->Length() )
+    if (( pos = longStr.Location( *itStr, argBeg, longStr.Length() )))
-    {
+      // check that object ID does not continue after len
-      subStr = *itStr;
+      if ( !cmd->IsIDChar( s[ pos + itStr->Length() - 1 ] ))
-      return true;
+      {
-    }
+        subStr.push_back( *itStr );
-  return false;
+        nbFound++;
+      }
+  return nbFound;
 }
 
 //================================================================================
@@ -4947,7 +5025,7 @@ bool _pyStringFamily::IsIn( const _AString& longStr, _AString& subStr )
 int _pyStringFamily::isIn( const char* str )
 {
   std::list< _pyStringFamily >::iterator itSub = _subFams.begin();
-  int len;
+  int len = -1;
   for ( ; itSub != _subFams.end(); ++itSub )
   {
     int cmp = strncmp( str, itSub->_prefix.ToCString(), itSub->_prefix.Length() );
@@ -4964,20 +5042,27 @@ int _pyStringFamily::isIn( const char* str )
     std::list< _AString >::iterator itStr = _strings.begin();
     bool firstEmpty = itStr->IsEmpty();
     if ( firstEmpty )
-      ++itStr;
+      ++itStr, len = 0;
     for ( ; itStr != _strings.end(); ++itStr )
     {
       int cmp = strncmp( str, itStr->ToCString(), itStr->Length() );
       if ( cmp == 0 )
-        return itStr->Length();
+      {
-      else if ( cmp < 0 )
+        len = itStr->Length();
         break;
+      }
+      else if ( cmp < 0 )
+      {
+        break;
+      }
     }
-    if ( firstEmpty )
+
-      return 0;
+    // check that object ID does not continue after len
+    if ( len >= 0 && _pyCommand::IsIDChar( str[len] ))
+      len = -1;
   }
 
-  return -1;
+  return len;
 }
 
 //================================================================================

src/SMESH_I/SMESH_2smeshpy.hxx

@@ -102,11 +102,12 @@ class _pyCommand: public Standard_Transient
   _AString                        myString;             //!< command text
   _AString                        myRes, myObj, myMeth; //!< found parts of command
   TColStd_SequenceOfAsciiString   myArgs;               //!< found arguments
+  TColStd_SequenceOfAsciiString   myResults;            //!< found results
   TColStd_SequenceOfInteger       myBegPos;             //!< where myRes, myObj, ... begin
   std::list< Handle(_pyCommand) > myDependentCmds; //!< commands that sould follow me in the script
 
   enum { UNKNOWN=-1, EMPTY=0, RESULT_IND, OBJECT_IND, METHOD_IND, ARG1_IND };
-  int  GetBegPos( int thePartIndex );
+  int  GetBegPos( int thePartIndex ) const;
   void SetBegPos( int thePartIndex, int thePosition );
   void SetPart( int thePartIndex, const _AString& theNewPart, _AString& theOldPart);
   void FindAllArgs() { GetArg(1); }
@@ -120,17 +121,18 @@ public:
   void SetOrderNb( int theNb ) { myOrderNb = theNb; }
   typedef void* TAddr;
   TAddr GetAddress() const { return (void*) this; }
-  int Length() { return myString.Length(); }
+  int Length() const { return myString.Length(); }
   void Clear() { myString.Clear(); myBegPos.Clear(); myArgs.Clear(); }
   bool IsEmpty() const { return myString.IsEmpty(); }
   _AString GetIndentation();
   const _AString & GetResultValue();
   int GetNbResultValues();
-  _AString GetResultValue(int res);
+  const _AString& GetResultValue(int res);
   const _AString & GetObject();
   const _AString & GetMethod();
   const _AString & GetArg( int index );
   int GetNbArgs() { FindAllArgs(); return myArgs.Length(); }
+  int GetArgBeginning() const;
   bool IsMethodCall();
   bool MethodStartsFrom(const _AString& beg)
   { GetMethod(); return ( myMeth.Location( beg, 1, myMeth.Length() ) == 1 ); }
@@ -148,6 +150,8 @@ public:
                            const bool theForward, const bool dotIsWord = false);
   static bool IsStudyEntry( const _AString& str );
   static bool IsID( const _AString& str );
+  static bool IsIDChar( char c )
+  { return ( isalnum( c ) || c == '_' || c == ':' ); }
   static std::list< _pyID > GetStudyEntries( const _AString& str );
   void AddDependantCmd( Handle(_pyCommand) cmd, bool prepend = false)
   { if (prepend) myDependentCmds.push_front( cmd ); else myDependentCmds.push_back( cmd ); }
@@ -234,7 +238,7 @@ class _pyStringFamily
   int isIn( const char* str );
 public:
   bool Add( const char* str );
-  bool IsIn( const _AString& str, _AString& subStr );
+  bool IsInArgs( Handle( _pyCommand)& cmd, std::list<_AString>& subStr );
   void Print( int level = 0 );
 };
 
@@ -261,7 +265,7 @@ public:
   void PlaceSubmeshAfterItsCreation( Handle(_pyCommand) theCmdUsingSubmesh ) const;
 
   _pyID GenerateNewID( const _pyID& theID );
-  void AddObject( Handle(_pyObject)& theObj );
+  bool AddObject( Handle(_pyObject)& theObj );
   void CheckObjectIsReCreated( Handle(_pyObject)& theObj );
   void SetProxyObject( const _pyID& theID, Handle(_pyObject)& theObj );
   Handle(_pyObject)     FindObject( const _pyID& theObjID ) const;
@@ -305,8 +309,9 @@ private:
 private:
   std::map< _pyID, Handle(_pyMesh) >        myMeshes;
   std::map< _pyID, Handle(_pyMeshEditor) >  myMeshEditors;
-  std::map< _pyID, Handle(_pyObject) >      myObjects;
   std::map< _pyID, Handle(_pyHypothesis) >  myHypos;
+  std::map< _pyID, Handle(_pyObject) >      myObjects;
+  std::list< Handle(_pyObject) >            myOrderedObjects; // to know order of myObjects creation
 #ifdef USE_STRING_FAMILY
   _pyStringFamily                           myKeepAgrCmdsIDs;
 #else
@@ -572,6 +577,8 @@ public:
   _pySelfEraser(const Handle(_pyCommand)& theCreationCmd);
   void IgnoreOwnCalls() { myIgnoreOwnCalls = true; }
   virtual void Flush();
+  virtual bool CanClear();
+  static bool IsAliveCmd( const Handle(_pyCommand)& theCmd );
 
   DEFINE_STANDARD_RTTI (_pySelfEraser)
 };

src/SMESH_I/SMESH_DumpPython.cxx

@@ -34,9 +34,10 @@
 
 #include <SALOMEDS_wrap.hxx>
 
+#include <LDOMParser.hxx>
+#include <Resource_DataMapIteratorOfDataMapOfAsciiStringAsciiString.hxx>
 #include <TColStd_HSequenceOfInteger.hxx>
 #include <TCollection_AsciiString.hxx>
-#include <LDOMParser.hxx>
 
 #ifdef _DEBUG_
 static int MYDEBUG = 0;
@@ -44,6 +45,8 @@ static int MYDEBUG = 0;
 static int MYDEBUG = 0;
 #endif
 
+#include "SMESH_TryCatch.hxx"
+
 namespace SMESH
 {
 
@@ -343,8 +346,12 @@ namespace SMESH
       SMESH::SMESH_Mesh_var            mesh = theArg->GetMesh();
       SMESH::long_array_var    anElementsId = theArg->GetIDs();
       SMESH::array_of_ElementType_var types = theArg->GetTypes();
-      SMESH::ElementType type = types->length() ? types[0] : SMESH::ALL;
+      SMESH::ElementType               type = types->length() ? types[0] : SMESH::ALL;
-      return *this << mesh << ".GetIDSource(" << anElementsId << ", " << type << ")";
+      SALOMEDS::SObject_wrap         meshSO = SMESH_Gen_i::ObjectToSObject(aStudy,mesh);
+      if ( meshSO->_is_nil() ) // don't waste memory for dumping not published objects
+        return *this << mesh << ".GetIDSource([], " << type << ")";
+      else
+        return *this << mesh << ".GetIDSource(" << anElementsId << ", " << type << ")";
     }
     return *this << theNotPublishedObjectName;
   }
@@ -613,6 +620,13 @@ namespace SMESH
 
     return true;
   }
+
+  void printException( const char* text )
+  {
+#ifdef _DEBUG_
+    cout << "Exception in SMESH_Gen_i::DumpPython(): " << text << endl;
+#endif
+  }
 }
 
 //=======================================================================
@@ -655,7 +669,6 @@ Engines::TMPFile* SMESH_Gen_i::DumpPython (CORBA::Object_ptr theStudy,
   // Map study entries to object names
   Resource_DataMapOfAsciiStringAsciiString aMap;
   Resource_DataMapOfAsciiStringAsciiString aMapNames;
-  //TCollection_AsciiString s ("qwertyuioplkjhgfdsazxcvbnmQWERTYUIOPLKJHGFDSAZXCVBNM0987654321_");
 
   SALOMEDS::ChildIterator_wrap Itr = aStudy->NewChildIterator(aSO);
   for (Itr->InitEx(true); Itr->More(); Itr->Next()) {
@@ -663,10 +676,10 @@ Engines::TMPFile* SMESH_Gen_i::DumpPython (CORBA::Object_ptr theStudy,
     CORBA::String_var anID = aValue->GetID();
     CORBA::String_var aName = aValue->GetName();
     TCollection_AsciiString aGUIName ( (char*) aName.in() );
-    TCollection_AsciiString anEnrty ( (char*) anID.in() );
+    TCollection_AsciiString anEntry ( (char*) anID.in() );
     if (aGUIName.Length() > 0) {
-      aMapNames.Bind( anEnrty, aGUIName );
+      aMapNames.Bind( anEntry, aGUIName );
-      aMap.Bind( anEnrty, aGUIName );
+      aMap.Bind( anEntry, aGUIName );
     }
   }
 
@@ -816,23 +829,32 @@ namespace {
    */
   //================================================================================
 
-  bool fixPythonName(TCollection_AsciiString & aName )
+  bool fixPythonName(TCollection_AsciiString & aName)
   {
-    const TCollection_AsciiString allowedChars =
-      "qwertyuioplkjhgfdsazxcvbnmQWERTYUIOPLKJHGFDSAZXCVBNM0987654321_";
     bool isValidName = true;
     int nbUnderscore = 0;
-    int p=1; // replace not allowed chars by underscore
+    int p;
-    while (p <= aName.Length() &&
+    // replace not allowed chars by underscore
-           (p = aName.FirstLocationNotInSet(allowedChars, p, aName.Length())))
+    const char* name = aName.ToCString();
-    {
+    for ( p = 0; name[p]; ++p ) {
-      if ( p == 1 || p == aName.Length() || aName.Value(p-1) == '_')
+      if ( !isalnum( name[p] ) && name[p] != '_' )
-        aName.Remove( p, 1 ); // remove double _ from the start and the end
+      {
-      else
+        if ( p == 0 || p+1 == aName.Length() || name[p-1] == '_')
-        aName.SetValue(p, '_'), nbUnderscore++;
+        {
-      isValidName = false;
+          aName.Remove( p+1, 1 ); // remove __ and _ from the start and the end
+          --p;
+          name = aName.ToCString();
+        }
+        else
+        {
+          aName.SetValue( p+1, '_');
+          nbUnderscore++;
+        }
+        isValidName = false;
+      }
     }
-    if ( aName.IsIntegerValue() ) { // aName must not start with a digit
+    // aName must not start with a digit
+    if ( aName.IsIntegerValue() ) {
       aName.Insert( 1, 'a' );
       isValidName = false;
     }
@@ -888,11 +910,22 @@ namespace {
   }
 }
 
-//=============================================================================
+//================================================================================
 /*!
- *  DumpPython
+ * \brief Createa a Dump Python script
+ *  \param [in] theStudy - the study to dump
+ *  \param [in,out] theObjectNames - map of an entry to a study and python name
+ *  \param [in] theNames -  - map of an entry to a study name
+ *  \param [in] isPublished - \c true if dump of object publication in study is needed
+ *  \param [in] isMultiFile - \c true if dump of each module goes to a separate file
+ *  \param [in] isHistoricalDump - \c true if removed object should be dumped
+ *  \param [out] aValidScript - returns \c true if the returned script seems valid
+ *  \param [in,out] theSavedTrace - the dump stored in the study. It's cleared to
+ *         decrease memory usage.
+ *  \return TCollection_AsciiString - the result dump script.
  */
-//=============================================================================
+//================================================================================
+
 TCollection_AsciiString SMESH_Gen_i::DumpPython_impl
                         (SALOMEDS::Study_ptr                       theStudy,
                          Resource_DataMapOfAsciiStringAsciiString& theObjectNames,
@@ -901,81 +934,75 @@ TCollection_AsciiString SMESH_Gen_i::DumpPython_impl
                          bool                                      isMultiFile,
                          bool                                      isHistoricalDump,
                          bool&                                     aValidScript,
-                         const TCollection_AsciiString&            theSavedTrace)
+                         TCollection_AsciiString&                  theSavedTrace)
 {
-  int aStudyID = theStudy->StudyId();
+  SMESH_TRY;
+  const int aStudyID = theStudy->StudyId();
 
-  TCollection_AsciiString helper; // to comfortably concatenate C strings
+  const TCollection_AsciiString aSmeshpy ( SMESH_2smeshpy::SmeshpyName() );
-  TCollection_AsciiString aSmeshpy( SMESH_2smeshpy::SmeshpyName() );
+  const TCollection_AsciiString aSMESHGen( SMESH_2smeshpy::GenName() );
-  TCollection_AsciiString aSMESHGen( SMESH_2smeshpy::GenName() );
+  const TCollection_AsciiString anOldGen ( SMESH::TPythonDump::SMESHGenName() );
-  TCollection_AsciiString anOldGen( SMESH::TPythonDump::SMESHGenName() );
+  const TCollection_AsciiString helper; // to comfortably append C strings to TCollection_AsciiString
+  const TCollection_AsciiString tab( isMultiFile ? "\t" : "" ), nt = helper + "\n" + tab;
 
-  TCollection_AsciiString aScript;
+  std::list< TCollection_AsciiString > lines; // lines of a script
-  if( isMultiFile )
+  std::list< TCollection_AsciiString >::iterator linesIt;
-    aScript += "def RebuildData(theStudy):";
+  
-
-  aScript += "\n\t";
   if ( isPublished )
-    aScript += aSMESHGen + " = smeshBuilder.New(theStudy)\n\t";
+    lines.push_back(  tab + aSMESHGen + " = smeshBuilder.New(theStudy)" );
-  else
+   else
-    aScript += aSMESHGen + " = smeshBuilder.New(None)\n\t";
+    lines.push_back(  tab + aSMESHGen + " = smeshBuilder.New(None)" );
-  aScript += helper + "aFilterManager = " + aSMESHGen + ".CreateFilterManager()\n\t";
+  lines.push_back(  tab + "aFilterManager = " + aSMESHGen + ".CreateFilterManager()" );
-  aScript += helper + "aMeasurements = " + aSMESHGen + ".CreateMeasurements()\n\t";
+  lines.push_back(  tab + "aMeasurements = "  + aSMESHGen + ".CreateMeasurements()" );
 
-  // Dump trace of restored study
+  // Treat dump trace of restored study
-  if (theSavedTrace.Length() > 0) {
+  if (theSavedTrace.Length() > 0)
+  {
+    linesIt = --lines.end();
+    // Split theSavedTrace into lines
+    int from = 1, end = theSavedTrace.Length(), to;
+    while ( from < end && ( to = theSavedTrace.Location( "\n", from, end )))
+    {
+      if ( theSavedTrace.ToCString()[from-1] == '\t' )
+        ++from;
+      if ( to != from )
+        lines.push_back( theSavedTrace.SubString( from, to - 1 ));
+      from = to + 1;
+    }
     // For the convertion of IDL API calls -> smeshBuilder.py API, "smesh" standing for SMESH_Gen
     // was replaces with "smeshgen" (==TPythonDump::SMESHGenName()).
     // Change "smesh" -> "smeshgen" in the trace saved before passage to smeshBuilder.py API
     bool isNewVersion =
       theSavedTrace.Location( anOldGen + ".", 1, theSavedTrace.Length() );
-    if ( !isNewVersion ) {
+    theSavedTrace.Clear();
-      TCollection_AsciiString aSavedTrace( theSavedTrace );
+    if ( !isNewVersion )
-      TCollection_AsciiString aSmeshCall ( "smesh." ), gen( "gen" );
-      int beg, end = aSavedTrace.Length(), from = 1;
-      while ( from < end && ( beg = aSavedTrace.Location( aSmeshCall, from, end ))) {
-        char charBefore = ( beg == 1 ) ? ' ' : aSavedTrace.Value( beg - 1 );
-        if ( isspace( charBefore ) || charBefore == '=' ) { // "smesh." is not a part of a long word
-          aSavedTrace.Insert( beg + aSmeshCall.Length() - 1, gen );// "smesh" -> "smeshgen"
-          end += gen.Length();
-        }
-        from = beg + aSmeshCall.Length();
-      }
-      aScript += helper + "\n" + aSavedTrace;
-    }
-    else
-      // append a saved trace to the script
-      aScript += helper + "\n" + theSavedTrace;
-  }
-
-  // Dump trace of API methods calls
-  TCollection_AsciiString aNewLines = GetNewPythonLines(aStudyID);
-  if (aNewLines.Length() > 0) {
-    aScript += helper + "\n" + aNewLines;
-  }
-
-  // import python files corresponding to plugins if they are used in aScript
-  {
-    TCollection_AsciiString importStr;
-    std::vector<std::string> pluginNames = getPluginNames();
-    for ( size_t i = 0; i < pluginNames.size(); ++i )
     {
-      // Convert access to plugin members:
+      const TCollection_AsciiString aSmeshCall ( "smesh." ), gen( "gen" );
-      // e.g. StdMeshers.QUAD_REDUCED -> StdMeshersBuilder.QUAD_REDUCED
+      int beg, end, from;
-      TCollection_AsciiString pluginAccess = (pluginNames[i] + ".").c_str() ;
+      for ( ++linesIt; linesIt != lines.end(); ++linesIt )
-      int iFrom = 1, iPos;
-      while (( iPos = aScript.Location( pluginAccess, iFrom, aScript.Length() )))
       {
-        aScript.Insert( iPos + pluginNames[i].size(), "Builder" );
+        TCollection_AsciiString& aSavedLine = *linesIt;
-        iFrom = iPos + pluginNames[i].size() + 8;
+        end = aSavedLine.Length(), from = 1;
+        while ( from < end && ( beg = aSavedLine.Location( aSmeshCall, from, end )))
+        {
+          char charBefore = ( beg == 1 ) ? ' ' : aSavedLine.Value( beg - 1 );
+          if ( isspace( charBefore ) || charBefore == '=' ) { // "smesh." is not a part of a long word
+            aSavedLine.Insert( beg + aSmeshCall.Length() - 1, gen );// "smesh" -> "smeshgen"
+            end += gen.Length();
+          }
+          from = beg + aSmeshCall.Length();
+        }
       }
-      // if any plugin member is used, import the plugin
-      if ( iFrom > 1 )
-        importStr += ( helper + "\n\t" + "from salome." + (char*) pluginNames[i].c_str() +
-                       " import " + (char*) pluginNames[i].c_str() +"Builder" );
     }
-    if ( !importStr.IsEmpty() )
+  }
-      aScript.Insert( 1, importStr + "\n\t" );
+
+  // Add new dump trace of API methods calls to script lines
+  if (myPythonScripts.find( aStudyID ) != myPythonScripts.end())
+  {
+    Handle(TColStd_HSequenceOfAsciiString) aPythonScript = myPythonScripts[ aStudyID ];
+    Standard_Integer istr, aLen = aPythonScript->Length();
+    for (istr = 1; istr <= aLen; istr++)
+      lines.push_back( aPythonScript->Value( istr ));
   }
 
   // Convert IDL API calls into smeshBuilder.py API.
@@ -984,89 +1011,111 @@ TCollection_AsciiString SMESH_Gen_i::DumpPython_impl
   Resource_DataMapOfAsciiStringAsciiString anEntry2AccessorMethod;
   std::set< TCollection_AsciiString >      aRemovedObjIDs;
   if ( !getenv("NO_2smeshpy_conversion"))
-    SMESH_2smeshpy::ConvertScript( aScript, anEntry2AccessorMethod,
+    SMESH_2smeshpy::ConvertScript( lines, anEntry2AccessorMethod,
                                    theObjectNames, aRemovedObjIDs,
                                    theStudy, isHistoricalDump );
 
-  // Replace characters used instead of quote marks to quote notebook variables
-  {
-    int pos = 1;
-    while (( pos = aScript.Location( 1, SMESH::TVar::Quote(), pos, aScript.Length() )))
-      aScript.SetValue( pos, '"' );
-  }
-
-  // Find entries to be replaced by names
-  Handle(TColStd_HSequenceOfInteger) aSeq = FindEntries(aScript);
-  Standard_Integer aLen = aSeq->Length();
-
-  if (aLen == 0 && isMultiFile)
-    return aScript;
-
-  // Replace entries by the names
-  GEOM::GEOM_Gen_ptr geom = GetGeomEngine();
-  TColStd_SequenceOfAsciiString seqRemoved;
-  Resource_DataMapOfAsciiStringAsciiString mapRemoved;
-  Standard_Integer objectCounter = 0, aStart = 1, aScriptLength = aScript.Length();
-  TCollection_AsciiString anUpdatedScript, anEntry, aName, aBaseName("smeshObj_");
-
-  // Collect names of GEOM objects to exclude same names of SMESH objects
-  GEOM::string_array_var aGeomNames = geom->GetAllDumpNames();
-  int ign = 0, nbgn = aGeomNames->length();
-  for (; ign < nbgn; ign++) {
-    aName = aGeomNames[ign];
-    theObjectNames.Bind(aName, "1");
-  }
-
   bool importGeom = false;
-  for (Standard_Integer i = 1; i <= aLen; i += 2) {
+  GEOM::GEOM_Gen_ptr geom = GetGeomEngine();
-    anUpdatedScript += aScript.SubString(aStart, aSeq->Value(i) - 1);
+  {
-    anEntry = aScript.SubString(aSeq->Value(i), aSeq->Value(i + 1));
+    // Add names of GEOM objects to theObjectNames to exclude same names of SMESH objects
-    // is a GEOM object?
+    GEOM::string_array_var aGeomNames = geom->GetAllDumpNames();
-    aName = geom->GetDumpName( anEntry.ToCString() );
+    int ign = 0, nbgn = aGeomNames->length();
-    if (aName.IsEmpty()) {
+    for (; ign < nbgn; ign++) {
-      // is a SMESH object
+      TCollection_AsciiString aName = aGeomNames[ign].in();
-      if (theObjectNames.IsBound(anEntry)) {
+      theObjectNames.Bind(aName, "1");
-        // The Object is in Study
-        aName = theObjectNames.Find(anEntry);
-        // check validity of aName
-        bool isValidName = fixPythonName( aName );
-        if (theObjectNames.IsBound(aName) && anEntry != theObjectNames(aName)) {
-          // diff objects have same name - make a new name by appending a digit
-          TCollection_AsciiString aName2;
-          Standard_Integer i = 0;
-          do {
-            aName2 = aName + "_" + ++i;
-          } while (theObjectNames.IsBound(aName2) && anEntry != theObjectNames(aName2));
-          aName = aName2;
-          isValidName = false;
-        }
-        if ( !isValidName )
-          theObjectNames(anEntry) = aName;
-
-      } else {
-        // Removed Object
-        do {
-          aName = aBaseName + (++objectCounter);
-        } while (theObjectNames.IsBound(aName));
-        if ( !aRemovedObjIDs.count( anEntry ))
-          seqRemoved.Append(aName);
-        mapRemoved.Bind(anEntry, "1");
-        theObjectNames.Bind(anEntry, aName);
-      }
-      theObjectNames.Bind(aName, anEntry); // to detect same name of diff objects
     }
-    else
-    {
-      importGeom = true;
-    }
-    anUpdatedScript += aName;
-    aStart = aSeq->Value(i + 1) + 1;
   }
 
-  // set initial part of aSript
+  TCollection_AsciiString anUpdatedScript;
+
+  Resource_DataMapOfAsciiStringAsciiString mapRemoved;
+  Resource_DataMapOfAsciiStringAsciiString mapEntries; // names and entries present in anUpdatedScript
+  Standard_Integer objectCounter = 0;
+  TCollection_AsciiString anEntry, aName, aGUIName, aBaseName("smeshObj_");
+
+  // Treat every script line and add it to anUpdatedScript
+  for ( linesIt = lines.begin(); linesIt != lines.end(); ++linesIt )
+  {
+    TCollection_AsciiString& aLine = *linesIt;
+    anUpdatedScript += tab;
+    {
+      //Replace characters used instead of quote marks to quote notebook variables
+      int pos = 1;
+      while (( pos = aLine.Location( 1, SMESH::TVar::Quote(), pos, aLine.Length() )))
+        aLine.SetValue( pos, '"' );
+    }
+    // Find entries to be replaced by names
+    Handle(TColStd_HSequenceOfInteger) aSeq = FindEntries(aLine);
+    const Standard_Integer aSeqLen = aSeq->Length();
+    Standard_Integer aStart = 1;
+    for (Standard_Integer i = 1; i <= aSeqLen; i += 2)
+    {
+      if ( aStart < aSeq->Value(i) )
+        anUpdatedScript += aLine.SubString( aStart, aSeq->Value(i) - 1 ); // line part before i-th entry
+      anEntry = aLine.SubString( aSeq->Value(i), aSeq->Value(i + 1) );
+      // is a GEOM object?
+      CORBA::String_var geomName = geom->GetDumpName( anEntry.ToCString() );
+      if ( !geomName.in() || !geomName[0] ) {
+        // is a SMESH object
+        if ( theObjectNames.IsBound( anEntry )) {
+          // The Object is in Study
+          aName = theObjectNames.Find( anEntry );
+          // check validity of aName
+          bool isValidName = fixPythonName( aName );
+          if (theObjectNames.IsBound(aName) && anEntry != theObjectNames(aName)) {
+            // diff objects have same name - make a new name by appending a digit
+            TCollection_AsciiString aName2;
+            Standard_Integer i = 0;
+            do {
+              aName2 = aName + "_" + ++i;
+            } while (theObjectNames.IsBound(aName2) && anEntry != theObjectNames(aName2));
+            aName = aName2;
+            isValidName = false;
+          }
+          if ( !isValidName )
+            theObjectNames(anEntry) = aName;
+
+          if ( aLine.Value(1) != '#' )
+            mapEntries.Bind(anEntry, aName);
+        }
+        else
+        {
+          // Removed Object
+          do {
+            aName = aBaseName + (++objectCounter);
+          } while (theObjectNames.IsBound(aName));
+
+          if ( !aRemovedObjIDs.count( anEntry ) && aLine.Value(1) != '#')
+            mapRemoved.Bind(anEntry, aName);
+
+          theObjectNames.Bind(anEntry, aName);
+        }
+        theObjectNames.Bind(aName, anEntry); // to detect same name of diff objects
+      }
+      else
+      {
+        aName = geomName.in();
+        importGeom = true;
+      }
+      anUpdatedScript += aName;
+      aStart = aSeq->Value(i + 1) + 1;
+
+    } // loop on entries within aLine
+
+    if ( aSeqLen == 0 )
+      anUpdatedScript += aLine;
+    else if ( aSeq->Value( aSeqLen ) < aLine.Length() )
+      anUpdatedScript += aLine.SubString( aSeq->Value(aSeqLen) + 1, aLine.Length() );
+
+    anUpdatedScript += '\n';
+  }
+
+  // Make an initial part of aSript
+
   TCollection_AsciiString initPart = "import ";
   if ( isMultiFile )
-    initPart += helper + "salome, ";
+    initPart += "salome, ";
   initPart += " SMESH, SALOMEDS\n";
   initPart += "from salome.smesh import smeshBuilder\n";
   if ( importGeom && isMultiFile )
@@ -1076,78 +1125,100 @@ TCollection_AsciiString SMESH_Gen_i::DumpPython_impl
                  "sys.path.insert( 0, os.path.dirname(__file__) )\n"
                  "exec(\"from \"+re.sub(\"SMESH$\",\"GEOM\",__name__)+\" import *\")\n");
   }
-  anUpdatedScript.Insert ( 1, initPart );
+  // import python files corresponding to plugins if they are used in anUpdatedScript
-
+  {
-  // add final part of aScript
+    TCollection_AsciiString importStr;
-  if (aLen && aSeq->Value(aLen) < aScriptLength)
+    std::vector<std::string> pluginNames = getPluginNames();
-    anUpdatedScript += aScript.SubString(aSeq->Value(aLen) + 1, aScriptLength);
+    for ( size_t i = 0; i < pluginNames.size(); ++i )
-
+    {
-  // Remove removed objects
+      // Convert access to plugin members:
-  if ( seqRemoved.Length() > 0 ) {
+      // e.g. StdMeshers.QUAD_REDUCED -> StdMeshersBuilder.QUAD_REDUCED
-    anUpdatedScript += "\n\t## some objects were removed";
+      TCollection_AsciiString pluginAccess = (pluginNames[i] + ".").c_str() ;
-    anUpdatedScript += "\n\taStudyBuilder = theStudy.NewBuilder()";
+      int iFrom = 1, iPos;
+      while (( iPos = anUpdatedScript.Location( pluginAccess, iFrom, anUpdatedScript.Length() )))
+      {
+        anUpdatedScript.Insert( iPos + pluginNames[i].size(), "Builder" );
+        iFrom = iPos + pluginNames[i].size() + 8;
+      }
+      // if any plugin member is used, import the plugin
+      if ( iFrom > 1 )
+        importStr += ( helper + "\n" "from salome." + pluginNames[i].c_str() +
+                       " import " + pluginNames[i].c_str() +"Builder" );
+    }
+    if ( !importStr.IsEmpty() )
+      initPart += importStr + "\n";
   }
-  for (int ir = 1; ir <= seqRemoved.Length(); ir++) {
+
-    anUpdatedScript += "\n\tSO = theStudy.FindObjectIOR(theStudy.ConvertObjectToIOR(";
+  if( isMultiFile )
-    anUpdatedScript += seqRemoved.Value(ir);
+    initPart += "def RebuildData(theStudy):";
-    // for object wrapped by class of smeshBuilder.py
+  initPart += "\n";
-    anEntry = theObjectNames( seqRemoved.Value(ir) );
+
-    if ( anEntry2AccessorMethod.IsBound( anEntry ) )
+  anUpdatedScript.Prepend( initPart );
-      anUpdatedScript += helper + "." + anEntry2AccessorMethod( anEntry );
+
-    anUpdatedScript += "))\n\tif SO is not None: aStudyBuilder.RemoveObjectWithChildren(SO)";
+  // Make a final part of aScript
+
+  // Dump object removal
+  TCollection_AsciiString removeObjPart;
+  if ( !mapRemoved.IsEmpty() ) {
+    removeObjPart += nt + "## some objects were removed";
+    removeObjPart += nt + "aStudyBuilder = theStudy.NewBuilder()";
+    Resource_DataMapIteratorOfDataMapOfAsciiStringAsciiString mapRemovedIt;
+    for ( mapRemovedIt.Initialize( mapRemoved ); mapRemovedIt.More(); mapRemovedIt.Next() ) {
+      aName   = mapRemovedIt.Value(); // python name
+      anEntry = mapRemovedIt.Key();
+      removeObjPart += nt + "SO = theStudy.FindObjectIOR(theStudy.ConvertObjectToIOR(";
+      removeObjPart += aName;
+      // for object wrapped by class of smeshBuilder.py
+      if ( anEntry2AccessorMethod.IsBound( anEntry ) )
+        removeObjPart += helper + "." + anEntry2AccessorMethod( anEntry );
+      removeObjPart += helper + "))" + nt + "if SO: aStudyBuilder.RemoveObjectWithChildren(SO)";
+    }
   }
 
   // Set object names
-
+  TCollection_AsciiString setNamePart;
-  TCollection_AsciiString aGUIName, aSetNameScriptPart;
+  Resource_DataMapIteratorOfDataMapOfAsciiStringAsciiString mapEntriesIt;
-  Resource_DataMapOfAsciiStringAsciiString mapEntries;
+  for ( mapEntriesIt.Initialize( mapEntries ); mapEntriesIt.More(); mapEntriesIt.Next() )
-  for (Standard_Integer i = 1; i <= aLen; i += 2)
   {
-    anEntry = aScript.SubString(aSeq->Value(i), aSeq->Value(i + 1));
+    anEntry = mapEntriesIt.Key();
-    aName   = geom->GetDumpName( anEntry.ToCString() );
+    aName   = mapEntriesIt.Value(); // python name
-    if (aName.IsEmpty() && // Not a GEOM object
+    if ( theNames.IsBound( anEntry ))
-        theNames.IsBound(anEntry) &&
-        !aRemovedObjIDs.count(anEntry) && // A command creating anEntry was erased
-        !mapEntries.IsBound(anEntry) && // Not yet processed
-        !mapRemoved.IsBound(anEntry)) // Was not removed
     {
-      aName    = theObjectNames.Find(anEntry);
       aGUIName = theNames.Find(anEntry);
-      mapEntries.Bind(anEntry, aName);
+      setNamePart += nt + aSMESHGen + ".SetName(" + aName;
-      aSetNameScriptPart += helper + "\n\t" + aSMESHGen + ".SetName(" + aName;
       if ( anEntry2AccessorMethod.IsBound( anEntry ) )
-        aSetNameScriptPart += helper + "." + anEntry2AccessorMethod( anEntry );
+        setNamePart += helper + "." + anEntry2AccessorMethod( anEntry );
-      aSetNameScriptPart += helper + ", '" + aGUIName + "')";
+      setNamePart += helper + ", '" + aGUIName + "')";
     }
   }
-  if ( !aSetNameScriptPart.IsEmpty() )
+  if ( !setNamePart.IsEmpty() )
   {
-    anUpdatedScript += "\n\t## set object names";
+    setNamePart.Insert( 1, nt + "## Set names of Mesh objects" );
-    anUpdatedScript += aSetNameScriptPart;
   }
 
-  // -----------------------------------------------------------------
+  // Store visual properties of displayed objects
-  // store visual properties of displayed objects
-  // -----------------------------------------------------------------
 
+  TCollection_AsciiString visualPropertiesPart;
   if (isPublished)
   {
     //Output the script that sets up the visual parameters.
     CORBA::String_var compDataType = ComponentDataType();
-    char* script = theStudy->GetDefaultScript( compDataType.in(), "\t");
+    CORBA::String_var script = theStudy->GetDefaultScript( compDataType.in(), tab.ToCString() );
-    if (script && strlen(script) > 0) {
+    if ( script.in() && script[0] ) {
-      anUpdatedScript += "\n\n\t### Store presentation parameters of displayed objects\n";
+      visualPropertiesPart += nt + "### Store presentation parameters of displayed objects\n";
-      anUpdatedScript += script;
+      visualPropertiesPart += script.in();
-      CORBA::string_free(script);
     }
   }
 
+  anUpdatedScript += removeObjPart + '\n' + setNamePart + '\n' + visualPropertiesPart;
+
   if( isMultiFile )
     anUpdatedScript += "\n\tpass";
   anUpdatedScript += "\n";
 
-  if( !isMultiFile ) // remove unnecessary tabulation
+  // no need now as we use 'tab' and 'nt' variables depending on isMultiFile
-    RemoveTabulation( anUpdatedScript );
+  // if( !isMultiFile ) // remove unnecessary tabulation
+  //   RemoveTabulation( anUpdatedScript );
 
   // -----------------------------------------------------------------
   // put string literals describing patterns into separate functions
@@ -1206,6 +1277,11 @@ TCollection_AsciiString SMESH_Gen_i::DumpPython_impl
   aValidScript = true;
 
   return anUpdatedScript;
+
+  SMESH_CATCH( SMESH::printException );
+
+  aValidScript = false;
+  return "";
 }
 
 //=============================================================================
@@ -1222,7 +1298,7 @@ TCollection_AsciiString SMESH_Gen_i::GetNewPythonLines (int theStudyID)
     Handle(TColStd_HSequenceOfAsciiString) aPythonScript = myPythonScripts[theStudyID];
     Standard_Integer istr, aLen = aPythonScript->Length();
     for (istr = 1; istr <= aLen; istr++) {
-      aScript += "\n\t";
+      aScript += "\n";
       aScript += aPythonScript->Value(istr);
     }
     aScript += "\n";

src/SMESH_I/SMESH_Gen_i.hxx

@@ -478,7 +478,7 @@ public:
                                            bool isMultiFile,
                                            bool isHistoricalDump,
                                            bool& aValidScript,
-                                           const TCollection_AsciiString& theSavedTrace);
+                                           TCollection_AsciiString& theSavedTrace);
 
   TCollection_AsciiString GetNewPythonLines (int theStudyID);
 

src/SMESH_I/SMESH_NoteBook.cxx

@@ -934,6 +934,17 @@ TCollection_AsciiString SMESH_NoteBook::GetResultScript() const
   return aResult;
 }
 
+//================================================================================
+/*!
+ *  \brief Return lines of the result script
+ */
+//================================================================================
+void SMESH_NoteBook::GetResultLines(std::list< TCollection_AsciiString >& lines) const
+{
+  for(int i=0;i<_commands.size();i++)
+    lines.push_back( _commands[i]->GetString() );
+}
+
 //================================================================================
 /*!
  *  \brief Return value of the variable
@@ -965,4 +976,3 @@ bool SMESH_NoteBook::GetReal(const TCollection_AsciiString& theVarName, double&
 
   return ok;
 }
-

src/SMESH_I/SMESH_NoteBook.hxx

@@ -91,6 +91,7 @@ public:
   
   void AddCommand(const TCollection_AsciiString& theString);
   TCollection_AsciiString GetResultScript() const;
+  void GetResultLines(std::list< TCollection_AsciiString >& lines) const;
 
 private:
 

src/SMESH_I/SMESH_PythonDump.hxx

@@ -29,13 +29,15 @@
 #include CORBA_SERVER_HEADER(SMESH_Mesh)
 #include CORBA_SERVER_HEADER(SALOMEDS)
 
+#include <TCollection_AsciiString.hxx>
+
 #include <sstream>
 #include <vector>
 #include <set>
+#include <list>
 
 class SMESH_Gen_i;
 class SMESH_MeshEditor_i;
-class TCollection_AsciiString;
 class Resource_DataMapOfAsciiStringAsciiString;
 
 // ===========================================================================================
@@ -46,8 +48,9 @@ class Resource_DataMapOfAsciiStringAsciiString;
  */
 // ===========================================================================================
 
-namespace SMESH_2smeshpy
+class SMESH_2smeshpy
 {
+public:
   /*!
    * \brief Convert a python script using commands of smeshBuilder.py
    * \param theScript - the Input script to convert
@@ -59,8 +62,8 @@ namespace SMESH_2smeshpy
    *        to exclude commands relating to objects removed from study
    * \retval TCollection_AsciiString - Convertion result
    */
-  void
+  static void
-  ConvertScript(TCollection_AsciiString&                  theScript,
+  ConvertScript(std::list< TCollection_AsciiString >&     theScriptLines,
                 Resource_DataMapOfAsciiStringAsciiString& theEntry2AccessorMethod,
                 Resource_DataMapOfAsciiStringAsciiString& theObjectNames,
                 std::set< TCollection_AsciiString >&      theRemovedObjIDs,