]> Creatis software - bbtk.git/blob - kernel/src/bbtkInterpreter.cxx
#3203 BBTK Feature New Normal vtk7itk4wx3-mingw64
[bbtk.git] / kernel / src / bbtkInterpreter.cxx
1 /*
2  # ---------------------------------------------------------------------
3  #
4  # Copyright (c) CREATIS (Centre de Recherche en Acquisition et Traitement de l'Image
5  #                        pour la SantÈ)
6  # Authors : Eduardo Davila, Frederic Cervenansky, Claire Mouton
7  # Previous Authors : Laurent Guigues, Jean-Pierre Roux
8  # CreaTools website : www.creatis.insa-lyon.fr/site/fr/creatools_accueil
9  #
10  #  This software is governed by the CeCILL-B license under French law and
11  #  abiding by the rules of distribution of free software. You can  use,
12  #  modify and/ or redistribute the software under the terms of the CeCILL-B
13  #  license as circulated by CEA, CNRS and INRIA at the following URL
14  #  http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
15  #  or in the file LICENSE.txt.
16  #
17  #  As a counterpart to the access to the source code and  rights to copy,
18  #  modify and redistribute granted by the license, users are provided only
19  #  with a limited warranty  and the software's author,  the holder of the
20  #  economic rights,  and the successive licensors  have only  limited
21  #  liability.
22  #
23  #  The fact that you are presently reading this means that you have had
24  #  knowledge of the CeCILL-B license and that you accept its terms.
25  # ------------------------------------------------------------------------ */
26
27
28 /*=========================================================================
29   Program:   bbtk
30   Module:    $RCSfile: bbtkInterpreter.cxx,v $
31   Language:  C++
32   Date:      $Date: 2012/11/16 08:49:01 $
33   Version:   $Revision: 1.95 $
34 =========================================================================*/
35
36
37
38 /**
39  *  \file 
40  *  \brief class Interpreter :
41  */
42
43 #include "bbtkInterpreter.h"
44 #include "bbtkExecuter.h"
45 #include "bbtkTranscriptor.h"
46 #include "bbtkMessageManager.h"
47 #include "bbtkConfigurationFile.h"
48 #include "bbtkUtilities.h"
49 #include "bbtkAtomicBlackBox.h"
50 #include "bbtkWxBlackBox.h"
51 #include <sys/stat.h>
52 #include <algorithm>
53 #ifdef CMAKE_HAVE_TERMIOS_H
54 #include <termios.h>
55 #define BBTK_USE_TERMIOS_BASED_PROMPT
56 #endif
57
58 #include <string>
59
60 namespace bbtk
61 {
62
63  //=======================================================================
64   Interpreter::Pointer Interpreter::New(const std::string& cpp_file) 
65   {
66     bbtkDebugMessage("kernel",9,"Interpreter::New('"<<cpp_file<<"')"<<std::endl);
67     return MakePointer(new Interpreter(cpp_file));
68   }
69  //=======================================================================
70
71  //=======================================================================
72   Interpreter::Pointer Interpreter::New(VirtualExec::Pointer e) 
73   {
74     bbtkDebugMessage("kernel",9,"Interpreter::New(VirtualExec)"<<std::endl);
75     return MakePointer(new Interpreter(e));
76   }
77  //=======================================================================
78
79  //=======================================================================
80   Interpreter::Interpreter(const std::string& cpp_file) 
81   {
82     bbtkDebugMessage("object",2,"==> Interpreter("<<cpp_file<<")"<<std::endl);
83     Init(VirtualExec::Pointer(), cpp_file);
84     bbtkDebugMessage("object",2,"<== Interpreter("<<cpp_file<<")"<<std::endl);
85   }
86   //=======================================================================
87
88  //=======================================================================
89   Interpreter::Interpreter(VirtualExec::Pointer e) 
90   {
91     bbtkDebugMessage("object",2,"==> Interpreter(VirtualExec)"<<std::endl);
92     Init(e,"");
93     bbtkDebugMessage("object",2,"<== Interpreter(VirtualExec)"<<std::endl);
94   }
95   //=======================================================================
96
97   //=======================================================================
98   void Interpreter::Init(VirtualExec::Pointer e, const std::string& cpp_file) 
99   {
100     if (e) {
101                 mVirtualExecuter = e;
102     } else if (cpp_file.size()!=0){
103                 mVirtualExecuter = boost::static_pointer_cast<VirtualExec>(bbtk::Transcriptor::New(cpp_file));
104     } else  {
105                 bbtk::Executer::Pointer exe = bbtk::Executer::New();
106                 mRealExecuter = exe;
107                 mVirtualExecuter = boost::static_pointer_cast<VirtualExec>(exe);
108       }
109
110     // Lock this pointer or will auto-destruct !!
111     if (!e) mVirtualExecuter->SetInterpreter(MakePointer(this,true));
112
113           
114           bbtk::InterpreterVirtual::Init();
115   } 
116   //=======================================================================
117   
118   
119   
120   //=======================================================================  
121   /**
122    *  
123    */
124   Interpreter::~Interpreter()
125   {
126     bbtkDebugMessage("object",2,"==> ~Interpreter()" <<std::endl);
127     mVirtualExecuter = VirtualExec::Pointer();
128     bbtkDebugMessage("object",2,"<== ~Interpreter()" <<std::endl);
129   }
130   //=======================================================================
131
132 /*EED Borrame
133   //=======================================================================
134   InterpreterException::InterpreterException( const std::string& message,
135                                       bool in_script_file,
136                                       const std::string& script_file,
137                                       int script_line 
138                                       )
139     : Exception("interpreter",0,message),
140       mInScriptFile(in_script_file),
141       mScriptFile(script_file),
142       mScriptLine(script_line)
143   {
144   }
145   //=======================================================================
146   //=======================================================================
147   InterpreterException::InterpreterException( const Exception& excep,
148                       bool in_script_file,
149                       const std::string& script_file,
150                       int script_line 
151                       )
152     : Exception(excep),
153       mInScriptFile(in_script_file),
154       mScriptFile(script_file),
155       mScriptLine(script_line)
156   {
157   }
158   //=======================================================================
159 */
160
161   //=======================================================================
162   void Interpreter::CatchInterpreterException( const InterpreterException& e )
163   {
164     if (GetExecuter()->GetNoErrorMode()) 
165       {
166         bbtkWarning("ERROR :"<<e.GetErrorMessage()
167                     <<" ("<<e.GetScriptFile()<<":"<<e.GetScriptLine()
168                     <<" skipped");
169
170         return;
171       }
172           
173           bbtk::InterpreterVirtual::CatchInterpreterException(  e );      
174   }
175   //=======================================================================
176
177   //=======================================================================
178   void Interpreter::CatchBbtkException( const bbtk::Exception& e )
179   {
180     if (GetExecuter()->GetNoErrorMode()) 
181       {
182         std::string file("?");
183         int line = 0;
184         if (mFileName.size()) {
185           file = mFileName.back();
186           line = mLine.back();
187         }    
188         bbtkWarning("ERROR '"<<e.GetErrorMessage()
189                     <<"' ("<<file<<":"<<line<<") skipped");
190         
191         return;
192       }
193           
194           bbtk::InterpreterVirtual::CatchBbtkException(  e );     
195   }
196   //=======================================================================
197   
198   //=======================================================================
199   void Interpreter::CatchStdException( const std::exception& e )
200   {  
201         if (GetExecuter()->GetNoErrorMode()) 
202         {
203                 std::string file("?");
204                 int line = 0;
205                 if (mFileName.size()) 
206                 {
207                         file = mFileName.back();
208                         line = mLine.back();
209                 }    
210                 bbtkWarning("ERROR '"<<e.what() <<"' ("<<file<<":"<<line<<") skipped");
211                 return;
212       }
213           bbtk::InterpreterVirtual::CatchStdException(  e );      
214   }
215   //=======================================================================
216
217   //=======================================================================
218   void Interpreter::CatchUnknownException()
219   {
220         if (GetExecuter()->GetNoErrorMode()) 
221         {
222                 std::string file("?");
223                 int line = 0;
224                 if (mFileName.size()) 
225                 {
226                         file = mFileName.back();
227                         line = mLine.back();
228                 }  
229                 bbtkWarning("UNDEFINED ERROR " <<"("<<file<<":"<<line<<") skipped");
230                 return;
231         }
232
233           bbtk::InterpreterVirtual::CatchUnknownException( );     
234   }
235   //=======================================================================
236
237   //=======================================================================
238   
239 #define CATCH_MACRO                                     \
240   catch (InterpreterException e)                        \
241     {                                                   \
242       CatchInterpreterException(e);                     \
243     }                                                   \
244   catch (bbtk::Exception e)                             \
245     {                                                   \
246       CatchBbtkException(e);                            \
247     }                                                   \
248   catch (std::exception& e)                             \
249     {                                                   \
250       CatchStdException(e);                             \
251     }                                                   \
252   catch (...)                                           \
253     {                                                   \
254       CatchUnknownException();                          \
255     }                                           
256   //=======================================================================
257    
258 /*EED Borrame
259   //=======================================================================
260   Interpreter::ExitStatus Interpreter::InterpretFile( const std::string& filename, bool source )
261   {
262     bbtkDebugMessage("interpreter",4,"==> Interpreter::InterpretFile(\""<<filename<<"\")"<<std::endl);
263
264     bool exm = mCommandLine;
265     mCommandLine = false;
266
267     try 
268     {
269       mStatus = Interpreter_OK;
270       SwitchToFile(filename,source);
271       mInsideComment = false;
272       InterpretCurrentStreams();
273     } 
274     CATCH_MACRO;
275     
276     bbtkDebugMessage("interpreter",4,
277                      "<== Interpreter::InterpretFile(\""
278                      <<filename<<"\")"<<std::endl);
279
280
281     mCommandLine = exm;
282     
283     return mStatus;
284   }
285   //=======================================================================
286
287
288   //=======================================================================
289   Interpreter::ExitStatus 
290   Interpreter::InterpretBuffer( std::stringstream* buffer )
291   {
292     bbtkDebugMessage("interpreter",4,"==> Interpreter::InterpretBuffer()"<<std::endl);
293
294     bool exm = mCommandLine;
295     mCommandLine = false;
296
297     try 
298     {
299       mStatus = Interpreter_OK;
300       SwitchToStream(buffer);
301       mInsideComment = false;
302       InterpretCurrentStreams();
303     }
304     CATCH_MACRO;
305     
306     //    CloseAllFiles();
307     bbtkDebugMessage("interpreter",4,"<== Interpreter::InterpretBuffer()"<<std::endl);
308
309     
310     mCommandLine = exm;
311     return mStatus;
312   }
313   //=======================================================================
314
315   //=======================================================================
316   /// Interprets the currently open streams
317   Interpreter::ExitStatus Interpreter::InterpretCurrentStreams()
318   {
319     bbtkDebugMessage("interpreter",4,
320                      "==> Interpreter::InterpretCurrentStreams()"<<std::endl);
321
322     while (mFile.size()>0) 
323       {
324         while (!mFile.back()->eof()) {
325           mLine.back()++;
326           char buf[500];
327           mFile.back()->getline(buf,500);
328           std::string str(buf);
329           //size 0 JCP 21-09-2009
330           int size=str.length();
331           if(size != 0){
332                   if ( str[ size-1 ]==13  )
333             {
334               str.erase(size-1,1);
335             }
336                   try
337                         {
338                           DoInterpretLine(str);
339                         }
340                   CATCH_MACRO;
341           }
342           
343         } 
344         CloseCurrentFile();
345       }
346     bbtkDebugMessage("interpreter",4,
347                      "<== Interpreter::InterpretCurrentStreams()"<<std::endl);
348
349     return mStatus;
350   }
351   //=======================================================================
352
353   //=======================================================================
354   /// Runs the interpretation of a command
355   Interpreter::ExitStatus Interpreter::InterpretLine( const std::string& line )
356   {
357     bbtkDebugMessage("interpreter",5,"==> Interpreter::InterpretLine('"<<line<<"')"<<std::endl);
358
359     try 
360     {
361       mStatus = Interpreter_OK;
362       mInsideComment = false;
363 //std::cout<<"JCP bbtkInterpreter.cxx Interpreter::InterpretLine("<<std::endl;
364       DoInterpretLine(line );
365     }
366     CATCH_MACRO;
367     
368     
369    bbtkDebugMessage("interpreter",5,"<== Interpreter::InterpretLine('"<<line<<"')"<<std::endl);
370     
371     return mStatus;
372   }
373   //=======================================================================  
374 */
375         
376         
377         void Interpreter::commandNew(const std::string &boxType,const  std::string &boxName)  //virtual
378     {
379                 mVirtualExecuter->Create(boxType,boxName);
380     }
381         
382         void Interpreter::commandDelete(const std::string &boxName)  //virtual
383     {
384                 mVirtualExecuter->Destroy(boxName);
385     }
386
387         void Interpreter::commandConnection(const std::string &nodeFrom,const  std::string &outputLabel,const  std::string &nodeTo,const  std::string &inputLabel) //virtual
388     {
389                 mVirtualExecuter->Connect(nodeFrom,outputLabel,nodeTo,inputLabel);
390     }
391                 
392         void Interpreter::commandPackage(const std::string &packageName) //virtual
393     {
394                 mVirtualExecuter->BeginPackage(packageName);
395     }
396         
397         void Interpreter::commandEndPackage() //virtual
398     {
399                 mVirtualExecuter->EndPackage();
400     }
401         
402         void Interpreter::commandDefine(const std::string &name,const  std::string &pack,const  std::string &scriptfilename) //virtual
403     {
404                 mVirtualExecuter->Define(name,pack,scriptfilename);
405     }
406
407         void Interpreter::commandEndDefine() //virtual
408     {
409                 mVirtualExecuter->EndDefine();
410     }
411
412         void Interpreter::commandKind(const std::string &kind) //virtual
413     {
414                 mVirtualExecuter->Kind(kind);
415     }
416         
417         void Interpreter::commandPrint(const std::string &value) //virtual
418     {
419                 mVirtualExecuter->Print(value);
420     }
421         
422         
423         void Interpreter::commandExec(const std::string &word) //virtual
424     {
425                 if (word=="freeze") 
426                 {
427                         mVirtualExecuter->SetNoExecMode(true);
428                         mThrow = false;
429                 }
430                 else if (word=="freeze_no_error") 
431                 {
432                         mVirtualExecuter->SetNoExecMode(true);
433                         mVirtualExecuter->SetNoErrorMode(true);
434                         mThrow = false;
435                 }
436                 else if (word=="unfreeze") 
437                 {
438                         mVirtualExecuter->SetNoExecMode(false);
439                         mVirtualExecuter->SetNoErrorMode(false);
440                 }
441                 else
442                 {
443                         mVirtualExecuter->Execute(word);
444                 } // if
445     }
446         
447         
448         void Interpreter::commandInput(const std::string &name,const std::string &box,const std::string &input,const std::string  &help) //virtual
449     {
450                 mVirtualExecuter->DefineInput(name,box,input,help);
451     }
452         
453         void Interpreter::commandOutput(const std::string &name,const std::string &box,const std::string &output,const std::string  &help) //virtual
454     {
455                 mVirtualExecuter->DefineOutput(name,box,output,help);
456     }
457         
458         void Interpreter::commandSet(const std::string &box,const std::string &input,const std::string &value) //virtual
459     {
460                 mVirtualExecuter->Set(box,input,value);
461     }
462
463         void Interpreter::commandAuthor(const std::string &author) //virtual
464     {
465                 mVirtualExecuter->Author(author);
466     }
467
468         void Interpreter::commandCategory(const std::string &categorytype) //virtual
469     {
470                 mVirtualExecuter->Category(categorytype);
471     }
472         
473         void Interpreter::commandDescription(const std::string &description) //virtual
474     {
475                 mVirtualExecuter->Description(description);
476     }
477
478         
479         void Interpreter::commandClear() //virtual
480     {
481                 mVirtualExecuter->Clear();
482     }
483         
484         void Interpreter::commandInclude(const std::string &word, bool ok) //virtual
485     {
486                 // if 'source' was given (words.size()==3) then tell to set the 
487                 // source file name of the current complex box with the full file name included
488                 if (mCommandLine)
489                 {
490                         InterpretFile(word, ok ); 
491                 }
492                 else
493                 {
494                         SwitchToFile(word , ok );
495                 }
496     }
497         
498         
499         void Interpreter::commandLoad(const std::string &packageName) //virtual
500     {
501                 GetExecuter()->LoadPackage(packageName);
502     }
503
504         void Interpreter::commandUnload(const std::string &packageName) //virtual
505     {
506                 GetExecuter()->UnLoadPackage(packageName);
507     }
508         
509         void Interpreter::commandBreak() //virtual
510     {
511             /*
512                  std::cout << "BreakException(" 
513                  <<in_script<<","
514                  <<file<<","
515                  <<line<<")"<<std::endl;
516                  */
517                 bbtkError("break");//,in_script,file,line);
518             //      throw BreakException(in_script,file,line);
519     }
520         
521         void Interpreter::commandQuit() //virtual
522     {
523                 bbtkError("quit");//,in_script,file,line);
524                 //throw QuitException(in_script,file,line);
525     }
526         
527         void Interpreter::commandMessage() //virtual
528     {
529                 mVirtualExecuter->HelpMessages();
530     }
531         
532         void Interpreter::commandMessage(const std::string &kind,const std::string &levelstr) //virtual
533     {
534                 int level=0;
535                 sscanf(levelstr.c_str(),"%d",&level);
536                 mVirtualExecuter->SetMessageLevel(kind,level);
537
538     }
539         
540         
541 /*EED Borrame   
542   //=======================================================================  
543   void Interpreter::DoInterpretLine( const std::string& line ) //virtual
544    {
545     bbtkDebugMessage("interpreter",6,"==> Interpreter::DoInterpretLine(\""
546                      <<line<<"\")"<<std::endl);
547     std::vector<std::string> words;
548     SplitLine(line,words);
549
550     // Empty line
551     if (words.size()<1) 
552     {
553        bbtkDebugDecTab("interpreter",9);
554        return;
555     }
556
557     // Single line comment : # or //
558     if ( words[0][0]=='#' || (words[0][0]=='/' && words[0][1]=='/') ) 
559     {  
560        bbtkDebugDecTab("interpreter",9);
561        bbtkMessage("interpreter",9,"Comment"<<std::endl);
562        return;
563     }
564
565     // Multi line comment ( / * ... * / ) -delimiters on different lines !-   <<<<<<<  / *     * /
566     
567     if (words[0][0]=='/' && words[0][1]=='*') 
568     {  
569        bbtkDebugDecTab("interpreter",9);
570        bbtkMessage("interpreter",9,"In multiline comment"<<std::endl);
571        mInsideComment = true;
572        return;
573     }
574
575     if (words[0][0]=='*' && words[0][1]=='/') 
576     {  
577        bbtkDebugDecTab("interpreter",9);
578        bbtkMessage("interpreter",9,"Out multiline comment"<<std::endl);
579        if ( !mInsideComment ) {
580           bbtkDebugDecTab("interpreter",9);
581           bbtkMessage("interpreter",9,"Comment mismatch : '* /' with no matching '/ *'"<<std::endl);        <<<<<<<<< * /       / * 
582        }
583        mInsideComment = false;
584        return;
585     }
586
587     if (mInsideComment) 
588     {  
589        bbtkDebugDecTab("interpreter",9);
590        bbtkMessage("interpreter",9,"Multiline Comment"<<std::endl);
591        return;
592     }
593
594     // Command 
595     CommandInfoType command;
596     InterpretCommand(words,command);
597 //std::cout<<"JCP bbtkInterpreter command.keyword ="<<command.keyword<<std::endl;
598     bbtkDebugMessage("interpreter",9,
599                      "Command='"<<command.keyword
600                       <<"' code="<<command.code<<std::endl); 
601           
602     std::string left,right,left2,right2;
603     std::string filename;
604
605 //ups1 EED borrame        
606     // message command
607     if (command.code==cMessage)
608       {
609         if (words.size()<3)
610           {
611                   commandMessage();
612 //EED Borrame       mVirtualExecuter->HelpMessages();
613           }
614         else
615           {
616                 commandMessage(words[1],words[2]);
617 //EED Borrame           sscanf(words[2].c_str(),"%d",&level);
618 //EED Borrame       mVirtualExecuter->SetMessageLevel(words[1],level);
619           }
620         return;
621       }
622     else 
623       {
624         bbtkMessage("echo",2,line<<std::endl);
625       }
626
627     // break and quit commands
628     if ((command.code==cBreak) || (command.code==cQuit))
629       {
630         bool in_script = false;
631         std::string file("");
632         int line = 0;
633
634         if (mFileName.size()) 
635           {
636             std::ifstream* fs = dynamic_cast<std::ifstream*>(mFile.back());
637             if (fs!=0) in_script = true;          
638             file = mFileName.back();
639             line = mLine.back();
640           } 
641         if (command.code==cBreak)
642           {
643 //          std::cout << "BreakException(" 
644 //                    <<in_script<<","
645 //                    <<file<<","
646 //                    <<line<<")"<<std::endl;
647                   commandBreak();
648 //EED Borrame       bbtkError("break");//,in_script,file,line);
649             //      throw BreakException(in_script,file,line);
650           }       
651         else 
652           {
653                   commandQuit();
654 //EED Borrame       bbtkError("quit");//,in_script,file,line);
655               //throw QuitException(in_script,file,line);
656           }
657         return;
658       }   
659 //std::cout<<" mVirtualExecuter->Create(words[1],words[2]); "<<line<<std::endl;
660     // other cammands
661
662     switch (command.code) 
663       {
664       case cNew :
665                 commandNew(words[1],words[2]);
666 //EED Borrame        mVirtualExecuter->Create(words[1],words[2]);
667         break;
668
669       case cDelete :
670                           commandDelete(words[1]);
671 //EED Borrame   mVirtualExecuter->Destroy(words[1]);
672         break;
673
674       case cConnect :
675         Utilities::SplitAroundFirstDot(words[1],left,right);
676         Utilities::SplitAroundFirstDot(words[2],left2,right2);      
677         commandConnection(left,right,left2,right2);
678 //EED Borrame        mVirtualExecuter->Connect(left,right,left2,right2);
679         break;
680
681       case cPackage :
682                           commandPackage(words[1]);
683 //EED Borrame                mVirtualExecuter->BeginPackage(words[1]);
684         break;
685
686       case cEndPackage :
687                           commandEndPackage();
688 //EED Borrame        mVirtualExecuter->EndPackage();
689         break;
690
691       case cDefine :
692         if (mFileName.size()>0) 
693         {
694 //???                   commandDefine(????);
695                    filename = mFileName.back(); //mIncludeFileName.back(); //Utilities::get_file_name(mFileName.back());
696         }
697         if (words.size()==2) 
698         {
699                         commandDefine(words[1],"",filename);
700 //EED Borrame           mVirtualExecuter->Define(words[1],"",filename);
701         }
702         else
703         {
704                         commandDefine(words[1],words[2],filename);
705 //EED Borrame           mVirtualExecuter->Define(words[1],words[2],filename);
706         }
707         break;
708
709       case cEndDefine :
710                 commandEndDefine();
711 //EED Borrame        mVirtualExecuter->EndDefine();
712         break;
713
714       case cKind :
715                         commandKind(words[1]);
716 //EED Borrame        mVirtualExecuter->Kind(words[1]);
717         break;
718
719       case cPrint :
720                           commandPrint(words[1]);
721 //EED Borrame        mVirtualExecuter->Print(words[1]);
722         break;
723                           
724       case cExec :
725                           commandExec(words[1]);
726 //EED Borrame        if (words[1]=="freeze") 
727 //EED Borrame     {
728 //EED Borrame       mVirtualExecuter->SetNoExecMode(true);
729 //EED Borrame       mThrow = false;
730 //EED Borrame     }
731 //EED Borrame   else if (words[1]=="freeze_no_error") 
732 //EED Borrame     {
733 //EED Borrame       mVirtualExecuter->SetNoExecMode(true);
734 //EED Borrame       mVirtualExecuter->SetNoErrorMode(true);
735 //EED Borrame       mThrow = false;
736 //EED Borrame     }
737 //EED Borrame   else if (words[1]=="unfreeze") 
738 //EED Borrame     {
739 //EED Borrame       mVirtualExecuter->SetNoExecMode(false);
740 //EED Borrame       mVirtualExecuter->SetNoErrorMode(false);
741 //EED Borrame     }
742 //EED Borrame   else
743 //EED Borrame     {
744 //EED Borrame       mVirtualExecuter->Execute(words[1]);
745 //EED Borrame     }
746                           
747         break;
748
749       case cInput :
750         Utilities::SplitAroundFirstDot(words[2],left,right);
751                           commandInput(words[1],left,right,words[3]);
752 //EED Borrame        mVirtualExecuter->DefineInput(words[1],left,right,words[3]);
753         break;
754
755       case cOutput :
756         Utilities::SplitAroundFirstDot(words[2],left,right);
757                 commandOutput(words[1],left,right,words[3]);
758 //EED Borrame         mVirtualExecuter->DefineOutput(words[1],left,right,words[3]);
759         break;
760
761       case cSet :
762         Utilities::SplitAroundFirstDot(words[1],left,right);
763                 commandSet(left,right,words[2]);
764 //EED Borrame        mVirtualExecuter->Set(left,right,words[2]);
765         break;
766
767       case cAuthor :
768                 commandAuthor(words[1]);
769 //EED Borrame        mVirtualExecuter->Author(words[1]);
770         break;
771
772       case cNewGUI :
773                 commandNewGUI(words[1],words[2]);
774         break;
775
776       case cCategory :
777                 commandCategory(words[1]);
778 //EED Borrame   mVirtualExecuter->Category(words[1]);
779         break;
780
781       case cIndex :
782         if (words.size()==1)
783                         commandIndex("tmp_index.html");
784         else if (words.size()==2)
785                         commandIndex(words[1]);
786         else if (words.size()==3)
787                         commandIndex(words[1],words[2]);
788         break;
789
790       case cDescription :
791                 commandDescription(words[1]);
792 //EED Borrame        mVirtualExecuter->Description(words[1]);
793         break;
794
795       case cHelp :
796         commandHelp(words);
797         break;
798
799
800       case cGraph :
801         commandGraph(words);
802         break;
803
804       case cConfig :
805         commandConfig();
806         break;
807
808       case cReset :  
809         commandReset();
810         break;
811         
812       case cClear :  
813                 commandClear();
814 //EED Borrame           mVirtualExecuter->Clear();
815         break;
816
817       case cInclude :
818                           commandInclude( words[1] , (words.size()==3) );
819 //EED Borrame           // if 'source' was given (words.size()==3) then tell to set the 
820 //EED Borrame           // source file name of the current complex box with the full file name included
821 //EED Borrame           if (mCommandLine)
822 //EED Borrame        {
823 //EED Borrame           InterpretFile(words[1],(words.size()==3)); 
824 //EED Borrame        } else{
825 //EED Borrame            SwitchToFile(words[1],(words.size()==3) );
826 //EED Borrame        }
827                 break;
828
829       case cLoad:
830                 commandLoad( words[1] );
831 //EED Borrame        GetExecuter()->LoadPackage(words[1]);
832         break;
833
834       case cUnload:
835                 commandUnload( words[1] );
836 //EED Borrame        GetExecuter()->UnLoadPackage(words[1]);
837         break;
838
839       case cDebug :
840                           if (words.size()==2) commandDebug(words[1]);
841                                 else commandDebug("");
842         break;
843                           
844         // obsolete
845     //  case cWorkspace :
846     //    if (words.size() == 2) 
847     //    {
848     //       if (words[1]=="freeze")        mVirtualExecuter->SetNoExecMode(true);
849     //       else if (words[1]=="unfreeze") mVirtualExecuter->SetNoExecMode(false);
850     //    }
851     //    else
852     //    {
853     //       mVirtualExecuter->SetWorkspaceName(words[2]);
854     //    }
855     //    break;
856
857                 default:
858         bbtkInternalError("should not reach here !!!");
859    }
860
861     bbtkDebugMessage("interpreter",6,"<== Interpreter::DoInterpretLine(\""
862                      <<line<<"\")"<<std::endl);
863     
864   }
865   //=======================================================================  
866
867
868
869
870   //=======================================================================
871   void Interpreter::SplitLine ( const std::string& str, std::vector<std::string>& tokens)
872 {
873     bbtkDebugMessage("interpreter",9,"==> Interpreter::SplitLine(\""<<str<<"\")"<<std::endl);
874
875     std::string delimiters = "\"";
876     std::vector<std::string> quote;
877     Utilities::SplitString(str,delimiters,quote);
878
879     delimiters = " \t";
880     std::vector<std::string>::iterator i;
881     for (i=quote.begin(); i!=quote.end(); ) 
882     {
883        Utilities::SplitString(*i,delimiters,tokens);
884        ++i;
885        if (i!=quote.end()) 
886        {
887         //    bbtkDebugMessage("interpreter",0,"\""<<*i<<"\""<<std::endl);
888           tokens.push_back(*i);
889           ++i;
890        }
891     }
892
893     for (i=tokens.begin(); i!=tokens.end(); ++i) 
894     {
895       bbtkDebugMessage("interpreter",9,"--["<<*i<<"]"<<std::endl);
896     }
897     bbtkDebugMessage("interpreter",9,"<== Interpreter::SplitLine(\""<<str<<"\")"<<std::endl);
898
899  }
900   //=======================================================================
901 */
902
903
904   //=======================================================================
905   void Interpreter::commandReset()  // virtual
906   {
907     // Cannot close all files if the reset command is read from a file !
908     CloseAllFiles();
909     mFileNameHistory.clear();
910     this->mVirtualExecuter->Reset();
911   }
912   //=======================================================================
913
914   //=======================================================================
915   /**
916    *
917    */
918   /*
919   void Interpreter::Print( const std::string& str)
920   {
921     if (mVirtualExecuter->GetNoExecMode()) return;
922
923     bbtkDebugMessageInc("interpreter",9,"Interpreter::Print(\""<<str<<"\")"<<std::endl);
924
925  // TO DO :
926  // InterpretLine ("load std")
927  // InterpretLine("new ConcatStrings _C_ ") -> trouver un nom unique : # commande 
928  // InterpretLine("new Print _P_") 
929  // InterpretLine("connect _C_.Out _P_.In")
930  // int num = 1
931  
932
933     std::vector<std::string> chains;
934     std::string delimiters("$");
935
936     // Skip delimiters at beginning.
937     std::string::size_type lastPos = str.find_first_not_of(delimiters, 0);
938     bool is_text = true;
939     if (lastPos>0) is_text = false;
940
941     // Find first delimiter.
942     std::string::size_type pos     = str.find_first_of(delimiters, lastPos);
943
944     while (std::string::npos != pos || std::string::npos != lastPos)
945     {
946        if (is_text) 
947        {
948           // Found a text token, add it to the vector.
949           chains.push_back(str.substr(lastPos, pos - lastPos));
950  // std::string token = str.substr(lastPos, pos - lastPos)
951  // InterpretLine("set _C_.In%num% %token%")
952  
953        }
954        else 
955        {
956
957        // is an output (between $$) : decode 
958          std::string tok,box,output;
959          tok = str.substr(lastPos, pos - lastPos);
960          Utilities::SplitAroundFirstDot(tok,box,output);
961          chains.push_back( mVirtualExecuter->Get(box,output) );
962
963 // InterpretLine("connect %tok% _C_.In%num%") 
964
965        }
966         // Skip delimiters.  Note the "not_of"
967        lastPos = str.find_first_not_of(delimiters, pos);
968         // Find next delimiter
969        pos = str.find_first_of(delimiters, lastPos);
970     //
971        is_text = !is_text;
972 // num ++;
973      }
974 // InterpretLine("exec _P_")
975 // if (IS_IN_WORKSPACE) InterpretLine("delete _C_; delete _P_");
976
977      std::vector<std::string>::iterator i;
978      for (i= chains.begin(); i!=chains.end(); ++i) 
979      {
980
981        Utilities::SubsBackslashN(*i);
982        std::cout << *i;
983      }
984      std::cout << std::endl;
985      bbtkDebugDecTab("interpreter",9);
986  }
987 */
988
989   //=======================================================================
990   /**
991    *
992    */
993 /*EED Borrame
994   // =========================================================================
995   void Interpreter::SwitchToFile( const std::string& name , bool source )
996   {
997   // Note : in the following :
998   // name : the user supplied name 
999   //      - abreviated name    e.g.       scr   scr.bbs
1000   //      - relative full name e.g.       ./scr.bbs   ../../scr.bbs 
1001   //      - absolute full name e.g.       /home/usrname/proj/dir/scr.bbs
1002   //          same for Windows, with      c:, d: ...
1003   //
1004   // use ./directory/subdir/scrname.bbs
1005   //
1006
1007     bbtkDebugMessage("interpreter",4,"==> Interpreter::SwitchToFile( \""
1008                      <<name<<"\")"<<std::endl);
1009
1010     std::vector<std::string> script_paths;
1011     std::string fullPathScriptName;  // full path script name
1012     std::string pkgname;             // e.g. <scriptname>.bbs
1013     std::vector<std::string> Filenames;
1014
1015     // The following is *NOT* a debug time message :
1016     // It's a user intended message.
1017     // Please don't remove it.
1018     bbtkMessage("interpreter",1,
1019         "look for : [" << name
1020         << "]" << std::endl);
1021
1022
1023     std::string upath;
1024     pkgname = Utilities::ExtractScriptName(name,upath);
1025
1026     bbtkMessage("interpreter",3,
1027                 "package name:[" << pkgname
1028                  << "] path:[" << upath << "]" << std::endl);
1029     bool fullnameGiven = false; 
1030     bool foundFile     = false;
1031
1032     // ==== "*" provided : load all scripts in given path 
1033     // relative (e.g. std/boxes/ *) or absolute      <<<<<<<< / *
1034     if (pkgname == "*") 
1035       {
1036
1037         std::stringstream* stream = new std::stringstream;
1038         //if (upath.size()!=0) // avoid troubles for "*"
1039         
1040         // ==== no path provided : look in root bbs path
1041         if (upath.size()==0)
1042           {
1043             //      bbtkMessage("interpreter",1,
1044             // LG : add all bbs path
1045             //  script_paths.push_back(  ConfigurationFile::GetInstance().Get_root_bbs_path() );
1046             std::vector<std::string>::const_iterator i;
1047             for (i=ConfigurationFile::GetInstance().Get_bbs_paths().begin();
1048                  i!=ConfigurationFile::GetInstance().Get_bbs_paths().end();
1049                  i++)
1050               {
1051                 script_paths.push_back(*i);
1052               }
1053           }
1054         // ==== absolute path provided 
1055         else if (upath[0]=='/' || upath[1] == ':' ) 
1056           {
1057             if ( Utilities::IsDirectory( upath ) )
1058               {
1059                 script_paths.push_back(upath);
1060               }
1061             else 
1062               {
1063                 bbtkError("'"<<upath<<"' : directory does not exist"); 
1064               }
1065           }
1066         // ==== relative path provided : search all bbs path appended with 
1067         // the relative path provided
1068         else
1069           {    
1070             std::vector<std::string>::const_iterator i;
1071             for (i=ConfigurationFile::GetInstance().Get_bbs_paths().begin();
1072                  i!=ConfigurationFile::GetInstance().Get_bbs_paths().end();
1073                  i++)
1074               {
1075                 std::string full_path(*i);
1076                 // we *really* want '.' to be the current working directory
1077                 if (full_path == ".") 
1078                   {
1079                     char buf[2048]; // for getcwd
1080                     char * currentDir = getcwd(buf, 2048);
1081                     std::string cwd(currentDir);
1082                     full_path = currentDir;
1083                   } // if full_path
1084                 
1085                 full_path += ConfigurationFile::GetInstance().Get_file_separator();
1086                 full_path += upath;
1087                 
1088                 if ( Utilities::IsDirectory( full_path ) )
1089                   {
1090                     script_paths.push_back(full_path);
1091                   }
1092               } 
1093             if (script_paths.empty())
1094               {
1095                 bbtkError("no '"<<upath<<"' subdir found in search paths" 
1096                           << std::endl);
1097               }
1098           }
1099         
1100         
1101         // === search paths list complete : now explore it
1102         int nbBssFiles = 0;     
1103         // ==== relative name, iterate + load all .bbs/.bbp files
1104         std::vector<std::string>::iterator i;
1105         for (i=script_paths.begin();i!=script_paths.end();i++)
1106           {
1107             bbtkMessage("interpreter",1,
1108                         "--> Looking in '" << *i << "'" << std::endl);
1109             
1110             Filenames.clear();
1111             //int nbFiles = 
1112             Utilities::Explore(*i, false, Filenames);
1113             
1114             for (std::vector<std::string>::iterator j = Filenames.begin(); 
1115                  j!= Filenames.end(); ++j)
1116               {
1117                 int lgr = (*j).size();
1118                 if (lgr < 5) continue;  
1119                 // ignore non .bbp file
1120                 if ( (*j).substr(lgr-4, 4) != ".bbp") continue; 
1121                 
1122                 (*stream) << "include \"" << *j << "\"\n";
1123                 bbtkMessage("interpreter",2,"  --> Found '" << *j << "'" << std::endl);
1124                 
1125                 nbBssFiles++;
1126               } // for (std::vector...
1127           } // for (i=script_...
1128
1129         // === Result ...
1130         if (nbBssFiles==0)
1131           {
1132             bbtkMessage("interpreter",1,
1133                         "  --> No .bbp found"<< std::endl);
1134           } 
1135         else 
1136           {
1137             bbtkMessage("interpreter",1,
1138                         "  --> "<<nbBssFiles<<" .bbp found"<< std::endl);
1139             SwitchToStream(stream);
1140           }
1141         return;
1142       }  
1143     //=============== end pkgname=="*" ===========
1144     
1145     
1146     // if name starts with a / or a . or contains : user is assumed to have passed a relative/absolute name
1147     // (not only a plain script name)
1148     // we trust him, and try to expland the directory name
1149     // WARNING : starting from current local directory :  ./whatYouWant  (./ mandatory!)
1150
1151     if (name[0]=='/' || name[1] == ':' || name[0]=='.')  // absolute path (linux/windows) or relative path
1152     { 
1153
1154       // ===========================================================check user supplied location
1155       fullnameGiven = true;
1156
1157       fullPathScriptName =  Utilities::ExpandLibName(name, false);
1158
1159       // allow user to always forget ".bbs"
1160       int l = fullPathScriptName.size();
1161
1162       if (l!=0) 
1163           {
1164          if ((fullPathScriptName.substr(l-4, 4) != ".bbs")&&
1165                          (fullPathScriptName.substr(l-4, 4) != ".bbp"))
1166          {
1167                         std::string tfullPathScriptName = fullPathScriptName + ".bbs";
1168                         if ( Utilities::FileExists(tfullPathScriptName) )
1169                         {
1170                                 fullPathScriptName = tfullPathScriptName;
1171                                 foundFile = true;
1172                         }
1173                         else 
1174                         {
1175                                 tfullPathScriptName = fullPathScriptName + ".bbp";
1176                                 if ( Utilities::FileExists(tfullPathScriptName) )
1177                                 {
1178                                         fullPathScriptName = tfullPathScriptName;
1179                                         foundFile = true;
1180                                 }
1181                         }
1182                  }
1183                  else 
1184                  {
1185                         if ( Utilities::FileExists(fullPathScriptName) )
1186                         {
1187                                 foundFile = true;
1188                         }
1189                  }
1190           } // endif l != 0
1191   }
1192   else
1193   // =============================== iterate on the paths
1194   {
1195       script_paths = ConfigurationFile::GetInstance().Get_bbs_paths();
1196       std::string path;
1197       std::vector<std::string>::iterator i;
1198       for (i=script_paths.begin();i!=script_paths.end();++i)
1199           {
1200                 path = *i;
1201                 // we *really* want '.' to be the current working directory
1202                 if (path == ".") 
1203                 {
1204                         char buf[2048]; // for getcwd
1205                         char * currentDir = getcwd(buf, 2048);
1206                         std::string cwd(currentDir);
1207                         path = currentDir;
1208                 }
1209           
1210                 std::string tfullPathScriptName = Utilities::MakePkgnameFromPath(path, name, false);
1211 //Addition JCP tfullPathScriptName.size()>=4 
1212                 if(tfullPathScriptName.size()>=4){
1213                         if (tfullPathScriptName.substr(tfullPathScriptName.size()-4, 3)==".bb")
1214                         {
1215                           fullPathScriptName = tfullPathScriptName;
1216                                 if ( ! Utilities::FileExists(fullPathScriptName) )
1217                                 {
1218                                         // The following is *NOT* a debug time message :
1219                                         // It's a user intended message.
1220                                         // Please don't remove it.
1221                                         bbtkMessage("interpreter",2,
1222                                   "   [" <<fullPathScriptName <<"] : does not exist" 
1223                                   <<std::endl);
1224                                         continue;  // try next path
1225                                 }
1226                                 bbtkMessage("interpreter",2,
1227                                           "   [" <<fullPathScriptName 
1228                                           <<"] : found" <<std::endl);
1229                                 foundFile = true;
1230                                 break; // a script was found; we stop iterating
1231                         }
1232                         else 
1233                         {
1234                                 fullPathScriptName = tfullPathScriptName + ".bbs";
1235                                 // Check if library exists
1236                                 if ( ! Utilities::FileExists(fullPathScriptName) )
1237                                 {
1238                                         fullPathScriptName = tfullPathScriptName + ".bbp";
1239                                         if ( ! Utilities::FileExists(fullPathScriptName) )
1240                                         {
1241                                                 // The following is *NOT* a debug time message :
1242                                                 // It's a user intended message.
1243                                                 // Please don't remove it.
1244                                                 bbtkMessage("interpreter",2,
1245                                                 "   [" <<tfullPathScriptName <<".bbs/.bbp] : do not exist" 
1246                                                 <<std::endl);
1247                                                 continue;  // try next path
1248                                         }
1249                                 }
1250                                 bbtkMessage("interpreter",2,
1251                                   "   [" <<fullPathScriptName 
1252                                   <<"] : found" <<std::endl);
1253                                 foundFile = true;
1254                                 break; // a script was found; we stop iterating
1255                         }
1256                 }               
1257         } //------------------ // end for ( package_paths.begin();i!=package_paths.end() )
1258   }
1259
1260     if (!foundFile)
1261       {
1262         if (fullnameGiven)
1263           if(fullPathScriptName == "")
1264             bbtkError("Path ["<<upath<<"] doesn't exist");
1265           else
1266             bbtkError("Script ["<<fullPathScriptName<<"] not found");
1267         else
1268           bbtkError("No ["<<pkgname<<".bbs/.bbp] script found");
1269         return;
1270       }
1271     else
1272         {
1273       LoadScript(fullPathScriptName,name);
1274           if (source) SetCurrentFileName(fullPathScriptName);
1275         }
1276     
1277     return;
1278   }
1279   //=======================================================================
1280 */
1281
1282         //=======================================================================
1283         void Interpreter::SetCurrentFileName(const std::string &fullPathScriptName)  // virtual 
1284         {
1285                 GetExecuter()->SetCurrentFileName(fullPathScriptName);
1286         }       
1287         //=======================================================================
1288         
1289         
1290         void Interpreter::SetTypeOfScript_Application()
1291         {
1292                 GetExecuter()->SetTypeOfScript_Application();
1293         }
1294
1295         
1296         
1297 /*EED Borrame   
1298   //=======================================================================
1299 void Interpreter::SwitchToStream( std::stringstream* stream )
1300 {
1301   bbtkDebugMessage("interpreter",4,"==> Interpreter::SwitchToStream()"
1302                    <<std::endl);
1303    mFile.push_back(stream);
1304     std::ostringstream buffer_name;
1305     bufferNb++;
1306     buffer_name << "buffer_" ;
1307
1308     if (mFileName.size()>0 )
1309     {
1310        buffer_name << mFileName.back() << "_" << mLine.back();
1311     }
1312     mFileName.push_back(buffer_name.str());
1313     mIncludeFileName.push_back(buffer_name.str());
1314     mLine.push_back(0);
1315 }
1316   //=======================================================================
1317 */
1318         
1319 /*      
1320   //=======================================================================
1321   void Interpreter::LoadScript( std::string fullPathScriptName,
1322                                 std::string includeScriptName)
1323   {
1324     bbtkDebugMessage("interpreter",4,"==> Interpreter::LoadScript("
1325                      <<fullPathScriptName<<")"
1326                      <<std::endl);
1327
1328     Utilities::replace( fullPathScriptName , 
1329                          INVALID_FILE_SEPARATOR , VALID_FILE_SEPARATOR);
1330    
1331      if (find(mFileNameHistory.begin(),
1332               mFileNameHistory.end(),
1333               fullPathScriptName)!=mFileNameHistory.end())
1334      {
1335         return;
1336      }
1337
1338     std::ifstream* s;
1339     s = new std::ifstream;
1340     s->open(fullPathScriptName.c_str());
1341     if (!s->good())
1342     {
1343         bbtkError("Could not open file ["<<fullPathScriptName<<"]");
1344         return;
1345     }
1346
1347     bbtkMessage("interpreter",1,"   -->[" << fullPathScriptName 
1348                 << "] found" << std::endl);
1349
1350     mFile.push_back(s);
1351     mFileName.push_back(fullPathScriptName);
1352     mFileNameHistory.push_back(fullPathScriptName);
1353     mIncludeFileName.push_back(includeScriptName);
1354     mLine.push_back(0);
1355
1356     return;
1357   }
1358   //=======================================================================
1359 */
1360
1361 /*EED Borrame
1362   //=======================================================================
1363   void Interpreter::CloseCurrentFile()
1364   {
1365     bbtkDebugMessage("interpreter",9,"==> Interpreter::CloseCurrentFile()"
1366                       <<std::endl);
1367
1368     if (mFile.size()==0)
1369     {
1370       bbtkDebugMessage("interpreter",9," -> no file left open"<<std::endl);
1371       return;
1372     }
1373
1374     bbtkDebugMessage("interpreter",9," Closing file '"<<mFileName.back()<<"'"<<std::endl);
1375
1376     std::ifstream* file = dynamic_cast<std::ifstream*>(mFile.back());
1377     if (file!=0) file->close();
1378
1379     delete mFile.back();
1380     mFile.pop_back();
1381     mFileName.pop_back();
1382     mIncludeFileName.pop_back();
1383     mLine.pop_back();
1384
1385     bbtkDebugMessage("interpreter",9," Remains "
1386                      <<mFile.size()
1387                      <<" open"<<std::endl);
1388     bbtkDebugMessage("interpreter",9,"<== Interpreter::CloseCurrentFile()"
1389                      <<std::endl);
1390   }
1391   //=======================================================================
1392
1393  //=======================================================================
1394   void Interpreter::CloseAllFiles()
1395   {
1396     bbtkDebugMessage("interpreter",9,"==> Interpreter::CloseAllFiles()"
1397                       <<std::endl);
1398
1399     while (mFile.size() != 0) 
1400     {
1401        CloseCurrentFile();
1402     }
1403     bbtkDebugMessage("interpreter",9,"<== Interpreter::CloseAllFiles()"
1404                       <<std::endl);
1405   }
1406   //=======================================================================
1407
1408
1409   //=======================================================================
1410   void Interpreter::InterpretCommand( const std::vector<std::string>& words,
1411                                       CommandInfoType& info )
1412   {
1413     bbtkDebugMessage("interpreter",9,"==> Interpreter::InterpretCommand(...)"<<std::endl);
1414
1415     // searches the command keyword
1416     CommandDictType::iterator c;
1417     c = mCommandDict.find(words[0]);
1418     if ( c == mCommandDict.end() ) {
1419       bbtkError(words[0]<<" : unknown command");
1420     }
1421
1422     // tests the number of args 
1423     if ( ( ((int)words.size())-1 < c->second.argmin ) ||
1424          ( ((int)words.size())-1 > c->second.argmax ) )
1425     {
1426        commandHelp(words[0]);
1427        bbtkError(words[0]<<" : wrong number of arguments");
1428     }
1429 //std::cout<<"Interpreter::InterpretCommand( const std::vector<std::string>& words,"<<std::endl;
1430     info = c->second;
1431
1432     bbtkDebugMessage("interpreter",9,"<== Interpreter::InterpretCommand(...)"<<std::endl);
1433
1434   }
1435   //=======================================================================
1436  */
1437
1438
1439   //=======================================================================
1440   /// Displays help on all the commands
1441 void Interpreter::commandHelp(const std::vector<std::string>& words)
1442 {
1443     unsigned int nbarg = words.size()-1;
1444
1445     if (nbarg==0) 
1446     {
1447        HelpCommands();
1448     }
1449     else if (nbarg==1) 
1450     {
1451       if (words[1]=="packages") 
1452       {
1453          GetExecuter()->GetFactory()->PrintHelpListPackages(true);
1454          return;
1455       }
1456       try 
1457       {
1458           commandHelp(words[1]);
1459       }
1460       catch (bbtk::Exception e) 
1461       {
1462          try 
1463          {
1464             GetExecuter()->GetFactory()->PrintHelpPackage(words[1]);
1465             if ( mUser != 0 )
1466               {
1467                 std::string url = 
1468                   ConfigurationFile::GetInstance().Get_doc_path();
1469                 url += "/bbdoc/" + words[1] + "/index.html";
1470                 if (Utilities::FileExists(url)) 
1471                   {
1472                     mUser->InterpreterUserViewHtmlPage(url);
1473                   }
1474               }
1475          }
1476          catch (bbtk::Exception f) 
1477          {
1478            try 
1479              {
1480                std::string package;
1481                GetExecuter()->GetFactory()->PrintHelpDescriptor(words[1],
1482                                                                 package);
1483                if ( mUser != 0 )
1484                  {
1485                    std::string url = 
1486                      ConfigurationFile::GetInstance().Get_doc_path();
1487                    url += "/bbdoc/" + package + "/index.html";
1488                    if (Utilities::FileExists(url)) 
1489                      {
1490                        url += "#" + words[1];
1491                        mUser->InterpreterUserViewHtmlPage(url);
1492                      }
1493                  }
1494              }
1495            catch (bbtk::Exception g) 
1496              {
1497                try
1498                  {
1499                    GetExecuter()->PrintHelpBlackBox(words[1],"0","9999");
1500                  }
1501                catch (bbtk::Exception h){
1502                  bbtkError("\""<<words[1].c_str()
1503                            <<"\" is not a known command, package, black box type or black box name");
1504                }
1505              }
1506          }
1507       }
1508     }
1509     else if (nbarg==2) 
1510     {
1511       if (words[2]=="all")
1512       {
1513          if ( words[1]=="packages" )
1514          {
1515             GetExecuter()->GetFactory()->PrintHelpListPackages(true,true);
1516             return;
1517           }
1518          try 
1519          {
1520             GetExecuter()->GetFactory()->PrintHelpPackage(words[1],true);
1521          }
1522          catch (bbtk::Exception f) 
1523          {
1524          }
1525      }
1526      else 
1527      {
1528         commandHelp(words[0]);
1529         bbtkError(words[0]<<" : syntax error");
1530      }
1531   }
1532   else 
1533   {
1534      bbtkError("Should not reach here !!!");
1535   }
1536 }
1537   //=======================================================================
1538
1539    //===================================================================    
1540   /// Displays the Configuration
1541   void Interpreter::commandConfig() const
1542   {
1543     ConfigurationFile::GetInstance().GetHelp(1);
1544   }  
1545    //===================================================================    
1546
1547   //=======================================================================
1548   /// Displays help on all the commands
1549   void Interpreter::HelpCommands()
1550   {
1551     std::cout << "Available commands :" << std::endl;
1552     CommandDictType::iterator i;
1553     for ( i =  mCommandDict.begin();
1554           i != mCommandDict.end();
1555         ++i) {
1556               std::cout << " " << i->first << std::endl;
1557       //      std::cout << "   usage : " << i->second.syntax << std::endl;
1558       //     std::cout << "    " << i->second.help << std::endl;
1559
1560     }
1561   }
1562   //=======================================================================
1563
1564
1565         
1566   //=======================================================================
1567   /// Displays help on a particular commands
1568   void Interpreter::commandHelp(const std::string& s)
1569   {
1570     CommandDictType::iterator c;
1571     c = mCommandDict.find(s);
1572     if ( c == mCommandDict.end() ) {
1573
1574 //EED 2016-12-22
1575 //      bbtkError(s<<" : Unknown command");
1576      std::string tmpSS=s+" : Unknown command";
1577       bbtkError(tmpSS);
1578     }   
1579     //    std::cout << " " << s << " : "<<  std::endl;
1580     //    CommandParamDictType::iterator i;
1581     //    for ( i =  c->second.begin();
1582     //      i != c->second.end();
1583     //      ++i) {
1584     std::cout << " usage : " << c->second.syntax << std::endl;
1585     std::cout << "  " << c->second.help << std::endl;
1586
1587   }
1588   //=======================================================================
1589
1590 /*EED Borrame
1591   //=======================================================================
1592   /// Fills the vector commands with the commands which 
1593   /// have the first n chars of buf for prefix
1594   /// TODO : skip initial spaces in buf and also return the position of first
1595   /// non blank char in buf
1596   void Interpreter::FindCommandsWithPrefix( char* buf,
1597                                             int n,
1598                                             std::vector<std::string>& commands )
1599   {
1600     CommandDictType::const_iterator i;
1601     for (i=mCommandDict.begin(); i!=mCommandDict.end(); ++i)
1602     {
1603       if ((i->first).find(buf,0,n) == 0) 
1604         commands.push_back(i->first);
1605     }
1606   }
1607   //=======================================================================
1608 */
1609  
1610
1611 /*EED Borrame
1612   //=======================================================================
1613 #ifdef BBTK_USE_TERMIOS_BASED_PROMPT
1614   
1615   inline void PrintChar(char c) { write(STDOUT_FILENO,&c,1); }
1616   inline void BackSpace() { write(STDOUT_FILENO,"\b \b",3); }
1617   
1618   // LG : KEYBOARD CODES AS SCANNED ON MY TTY : UNIVERSAL ?
1619   // IF NOT THE USER SHOULD BE ABLE TO CONFIGURE IT
1620   // E.G. STORE THIS IN bbtk_config.xml
1621 #define BBTK_UP_ARROW_KBCODE    0x00415B1B
1622 #define BBTK_DOWN_ARROW_KBCODE  0x00425B1B
1623 #define BBTK_RIGHT_ARROW_KBCODE 0x00435B1B
1624 #define BBTK_LEFT_ARROW_KBCODE  0x00445B1B
1625 #define BBTK_BACKSPACE_KBCODE   0x00000008
1626 #define BBTK_DEL_KBCODE         0x0000007F
1627 #define BBTK_SPACE_KBCODE       0x00000020 
1628
1629   //=======================================================================
1630   void Interpreter::GetLineFromPrompt(std::string& s)
1631   {
1632     int c;
1633     unsigned int ind=0;
1634
1635     unsigned int MAX_LINE_SIZE = 160;
1636     unsigned int MAX_HISTORY_SIZE = 100;
1637
1638     char* newline = new char[MAX_LINE_SIZE];
1639     memset(newline,0,MAX_LINE_SIZE);
1640     char* histline = new char[MAX_LINE_SIZE];
1641     memset(histline,0,MAX_LINE_SIZE);
1642
1643     char* line = newline;
1644     unsigned int hist = mHistory.size();
1645
1646     write(1,"> ",2);
1647     while(1)
1648     {
1649        c=0;
1650        read ( STDIN_FILENO, &c, 4) ;
1651
1652        bbtkDebugMessage("debug",9,"[0x"<<std::hex<<c<<"]\n");
1653
1654        // Printable character
1655        if ( (ind<MAX_LINE_SIZE-1) &&
1656             ( c >= BBTK_SPACE_KBCODE ) && 
1657             ( c <  BBTK_DEL_KBCODE )) 
1658        {
1659           PrintChar(c);
1660           line[ind++]=c;
1661        }
1662       // CR
1663        else if (c=='\n')
1664        {
1665        // delete the unused line
1666           if (line==newline)
1667               delete histline;
1668           else
1669               delete newline;
1670    
1671     // empty lines are not stored in from history
1672           if (strlen(line)) 
1673           {
1674              // if history too long : delete oldest command
1675              if (mHistory.size()>MAX_HISTORY_SIZE) 
1676              {
1677                 delete mHistory.front();
1678                 mHistory.pop_front();
1679              }
1680              mHistory.push_back(line);
1681           }
1682           break;
1683         }
1684        // Backspace
1685         else if ( (ind>0) && 
1686                   ((c == BBTK_BACKSPACE_KBCODE) ||
1687                    (c == BBTK_DEL_KBCODE)) )
1688           {
1689             line[ind--]=' ';
1690             BackSpace();
1691           }
1692         // Tab 
1693         else if (c=='\t')
1694           {
1695             // TODO : Command completion  
1696             std::vector<std::string> commands;
1697             FindCommandsWithPrefix( line,ind,commands);
1698             if (commands.size()==1) 
1699               {
1700                 std::string com = *commands.begin();
1701                 for (; ind<com.size(); ++ind) 
1702                   {
1703                     PrintChar(com[ind]); 
1704                     line[ind]=com[ind];
1705                   }
1706                 PrintChar(' '); 
1707                 line[ind++]=' ';
1708               }
1709             else if (commands.size()>1) 
1710               {
1711                 std::vector<std::string>::iterator i;
1712                 write(1,"\n",1);
1713                 for (i=commands.begin();i!=commands.end();++i) 
1714                   {
1715                     write(STDOUT_FILENO,(*i).c_str(),strlen((*i).c_str()));
1716                     PrintChar(' ');
1717                   }
1718                 write(STDOUT_FILENO,"\n> ",3);
1719                 //for (int j=0;j<ind;++j) 
1720                   //{
1721                     write(STDOUT_FILENO,line,ind); 
1722                     //  }
1723               }
1724           }
1725         // Arrow up : back in history
1726         else if (c==BBTK_UP_ARROW_KBCODE)
1727           {
1728             if (hist) 
1729               {
1730                 // erase current line
1731                 while (ind--) BackSpace();
1732                 // 
1733                 hist--;
1734                 // 
1735                 strcpy(histline,mHistory[hist]);
1736                 line = histline;
1737                 ind = strlen(line);
1738                 
1739                 write(STDOUT_FILENO,line,ind);
1740               }
1741           }
1742         // Arrow down : down in history
1743         else if (c==BBTK_DOWN_ARROW_KBCODE)
1744           {
1745             if (hist<mHistory.size()-1) 
1746               {
1747                 // erase current line
1748                 while (ind--) BackSpace();
1749                 // 
1750                 hist++;
1751                 // 
1752                 strcpy(histline,mHistory[hist]);
1753                 line = histline;
1754                 ind = strlen(line);
1755                 
1756                 write(STDOUT_FILENO,line,ind);
1757               }
1758             // end of history : switch back to newline
1759             else if (hist==mHistory.size()-1)
1760               {
1761                 // erase current line
1762                 while (ind--) BackSpace();
1763                 // 
1764                 hist++;
1765                 // 
1766                 line = newline;
1767                 ind = strlen(line);
1768                 
1769                 write(STDOUT_FILENO,line,ind);
1770               }
1771           }
1772         // Arrow right
1773         else if (line[ind]!=0 && c==BBTK_RIGHT_ARROW_KBCODE)
1774           {
1775             PrintChar(line[ind]);
1776             ind++;
1777           }
1778
1779         // Arrow left
1780         else if (ind>0 && c==BBTK_LEFT_ARROW_KBCODE)
1781           {
1782             PrintChar('\b');
1783             ind--;
1784     
1785           }
1786
1787       }
1788     write(STDOUT_FILENO,"\n\r",2);
1789     
1790     
1791     s = line;
1792     
1793   }
1794 #else
1795
1796   //=======================================================================
1797   void Interpreter::GetLineFromPrompt(std::string& s)
1798   {  
1799     s.clear();
1800
1801     putchar('>');
1802     putchar(' ');
1803
1804     do 
1805     {
1806       char c = getchar();
1807       if (c=='\n') 
1808       {
1809         putchar('\n');
1810         break;
1811       }
1812       if (c=='\t') 
1813       {
1814         // putchar('T');
1815         continue;
1816       }
1817       // putchar(c);
1818       s += c;
1819     } 
1820     while (true);  
1821     
1822   }
1823   //=======================================================================  
1824
1825 #endif
1826 */
1827
1828         
1829         
1830         
1831         
1832         
1833 /*EED Borrame
1834   //=======================================================================
1835   void Interpreter::CommandLineInterpreter()
1836   {
1837     bbtkDebugMessageInc("interpreter",9,
1838                         "Interpreter::CommandLineInterpreter()"<<std::endl);
1839
1840 #ifdef BBTK_USE_TERMIOS_BASED_PROMPT  
1841     // Initialise the tty in non canonical mode with no echo
1842     // oter remembers the previous settings to restore them after 
1843     struct termios ter,oter;
1844     tcgetattr(0,&ter);
1845     oter=ter;
1846     ter.c_lflag &= ~ECHO;
1847     ter.c_lflag &= ~ICANON;
1848     ter.c_cc[VMIN]=1;
1849     ter.c_cc[VTIME]=0;
1850     tcsetattr(0,TCSANOW,&ter);
1851 #endif
1852     
1853     mCommandLine = true;
1854     bool again = true;
1855     // bool insideComment = false; // for multiline comment  
1856     mInsideComment = false;
1857     do 
1858     {
1859       try
1860       {
1861         std::string line;
1862         GetLineFromPrompt(line);
1863         DoInterpretLine(line); //, insideComment);
1864       }
1865  //     catch (QuitException e)
1866  //     {
1867  //     bbtkMessage("interpreter",1,"Interpreter : Quit"<<std::endl);
1868  //        again = false;
1869       }
1870       catch (bbtk::Exception e) 
1871       {
1872         e.Print();
1873       }
1874         catch (std::exception& e) 
1875       {
1876         std::cerr << "* ERROR :: "<<e.what()<<" (not in bbtk)"<<std::endl;
1877       }
1878       catch (...)
1879       {
1880         std::cerr << "* UNDEFINED ERROR (not a bbtk nor a std exception)"<<std::endl;
1881       }
1882     }
1883     while (again);
1884
1885 #ifdef BBTK_USE_TERMIOS_BASED_PROMPT
1886     tcsetattr(0,TCSANOW,&oter);
1887 #endif
1888
1889     std::cout << "Good bye !" << std::endl;
1890
1891     bbtkDebugDecTab("interpreter",9);
1892   }
1893 */
1894                   
1895 //=======================================================================
1896 void Interpreter::commandGraph(const std::vector<std::string>& words)
1897 {
1898   std::string page;
1899     bool system_display = true;
1900
1901     if ( ( mUser != 0 ) && ( mUser->InterpreterUserHasOwnHtmlPageViewer() ) )
1902       system_display = false; 
1903  
1904     if (words.size()==1) 
1905     {
1906       page = mVirtualExecuter->ShowGraph(".","0","0","","","",system_display);
1907     }
1908     else if (words.size()==2) 
1909     {
1910       page = mVirtualExecuter->ShowGraph(words[1],"0","0","","","",system_display);
1911     }
1912     else if (words.size()==3) 
1913     {
1914       page = mVirtualExecuter->ShowGraph(words[1],words[2],"0","","","",system_display);
1915     }
1916     else if (words.size()==4) 
1917     {
1918       page = mVirtualExecuter->ShowGraph(words[1],words[2],words[3],"","","",system_display);
1919     } 
1920     else if (words.size()==5) 
1921     {
1922       page = mVirtualExecuter->ShowGraph(words[1],words[2],words[3],words[4],"","",system_display);
1923     } 
1924     else if (words.size()==6) 
1925     {
1926       page = mVirtualExecuter->ShowGraph(words[1],words[2],words[3],words[4],words[5],"",system_display);
1927     } 
1928     else if (words.size()==7) 
1929       {
1930         page = mVirtualExecuter->ShowGraph(words[1],words[2],words[3],words[4],words[5],words[6],system_display);
1931       } 
1932     
1933     if ( ( mUser != 0 ) && ( mUser->InterpreterUserHasOwnHtmlPageViewer() ) )
1934       mUser->InterpreterUserViewHtmlPage(page);
1935
1936   }
1937 //=======================================================================
1938
1939
1940 //=======================================================================
1941 void  Interpreter::commandIndex(const std::string& filename, 
1942                          const std::string& type)
1943 {
1944   Factory::IndexEntryType t;
1945   if (type=="Initials") t = Factory::Initials;
1946   else if (type=="Categories") t = Factory::Categories;
1947   else if (type=="Packages") t = Factory::Packages;
1948   else if (type=="Adaptors") t = Factory::Adaptors;
1949   
1950   GetExecuter()->GetFactory()->CreateHtmlIndex(t,filename);
1951 }
1952 //=======================================================================
1953
1954
1955 //=======================================================================
1956 void  Interpreter::commandNewGUI(const std::string& boxname,
1957                              const std::string& instanceName)
1958 {
1959   if (mRealExecuter.expired())
1960     {
1961       bbtkError("command 'newgui' cannot be compiled yet");
1962     }
1963
1964   std::string typeName = instanceName+"Type";
1965   std::stringstream* s = new std::stringstream;
1966   // create the complex box
1967   (*s) << "define "<<typeName<<std::endl;
1968   //  (*s) << "  description 'Automatically generated user interface for the box "
1969   //       << boxname << "'" <<std::endl;
1970   // create the Layout box
1971   (*s) << "  load wx"<<std::endl;
1972   (*s) << "  new LayoutLine layout"<<std::endl;
1973   // create the output 'Widget'
1974   (*s) << "  output Widget layout.Widget Widget"<<std::endl;
1975   // the box change output 
1976   (*s) << "  new MultipleInputs change"<<std::endl;
1977   (*s) << "  output BoxChange change.Out BoxChange"<<std::endl;
1978
1979   // Browse the inputs of the box in order to find which ones are not 
1980   // connected and can be adapted from a widget adaptor
1981   // vector which stores the list of inputs of the box which must be connected
1982   std::vector<std::string> in;
1983  
1984   Factory::Pointer F = mVirtualExecuter->GetFactory();
1985   /*
1986   Package::Pointer user = F->GetPackage("user");
1987   */
1988   ComplexBlackBoxDescriptor::Pointer workspace = 
1989     mRealExecuter.lock()->GetCurrentDescriptor();
1990
1991   if (workspace==0)
1992     {
1993       delete s;
1994       bbtkError("interpreter::CreateGUI : could not access the executer currently defined complex box");
1995     }
1996  
1997
1998   /*
1999     (ComplexBlackBoxDescriptor::Pointer)(user->GetBlackBoxMap().find("workspace")->second.get());
2000   */
2001
2002   BlackBox::Pointer box = workspace->GetPrototype()->bbGetBlackBox(boxname);
2003   //  BlackBox::InputConnectorMapType incm = box->bbGetInputConnectorMap();
2004   // int nb = 0;
2005   BlackBox::InputConnectorMapType::iterator i;
2006   for (i=box->bbGetInputConnectorMap().begin();
2007        i!=box->bbGetInputConnectorMap().end();
2008        ++i)
2009     {
2010       // If the input is connected : continue
2011       if (i->second->IsConnected()) continue;
2012       // Get the input descriptor 
2013       const BlackBoxInputDescriptor* d = box->bbGetDescriptor()->GetInputDescriptor(i->first);
2014       // If it is a "system" input : skip it
2015 #ifdef USE_WXWIDGETS
2016       if ( ( d->GetCreatorTypeInfo() == typeid(AtomicBlackBoxDescriptor)) ||
2017            ( d->GetCreatorTypeInfo() == typeid(WxBlackBoxDescriptor)) )
2018         continue;
2019 #else
2020 // JFGA 12/12/2014 Adding WT options for compile with it.
2021
2022 /*#if USE_WT
2023
2024         if ( ( d->GetCreatorTypeInfo() == typeid(AtomicBlackBoxDescriptor)) ||
2025            ( d->GetCreatorTypeInfo() == typeid(WtBlackBoxDescriptor)) )
2026         continue;
2027         
2028
2029 #else
2030 */
2031       if ( ( d->GetCreatorTypeInfo() == typeid(AtomicBlackBoxDescriptor)) )
2032         continue;
2033 //#endif
2034
2035 #endif
2036       bool widok = true;
2037       std::string widget,adaptor;
2038       // try to find a widget adaptor
2039       if (F->FindWidgetAdaptor(DataInfo(d->GetTypeInfo(),""),
2040                                d->GetDataInfo(),
2041                                adaptor))
2042         {
2043           // command to create the adaptor
2044           (*s) << "  new "<<adaptor<<" "<<i->first<<std::endl;
2045           // Sets the label of the widget adaptor to the name of the input
2046           (*s) << "  set "<<i->first<<".Label "<<i->first<<std::endl;
2047           // Sets the initial value of the widget to the value of the input
2048           (*s) << "  set "<<i->first<<".In \" "
2049                <<box->bbGetInputAsString(i->first)<<"\""
2050                << std::endl;
2051           // store the input name
2052           in.push_back(i->first);
2053           (*s) << "  connect "<<i->first<<".Widget layout.Widget"<<in.size()<<std::endl;
2054             //<i->first<<"'"<<std::endl;
2055           (*s) << "  connect "<<i->first<<".BoxChange change.In"<<in.size()<<std::endl;
2056         }
2057       // try to find a two pieces adaptor
2058       else if (F->FindWidgetAdaptor2(DataInfo(d->GetTypeInfo(),""),
2059                                      d->GetDataInfo(),
2060                                      widget,adaptor) )
2061         {
2062           // command to create the widget
2063           (*s) << "  new "<<widget<<" "<<i->first<<"Widget"<<std::endl;
2064           // command to create the adaptor
2065           (*s) << "  new "<<adaptor<<" "<<i->first<<std::endl;
2066           // connect the two
2067           (*s) << "  connect "<<i->first<<"Widget.Out "
2068                <<i->first<<".In"<<std::endl;
2069           // Sets the label of the widget adaptor to the name of the input
2070           (*s) << "  set "<<i->first<<"Widget.Label "<<i->first<<std::endl;
2071           // Sets the initial value of the widget to the value of the input
2072           (*s) << "  set "<<i->first<<"Widget.In \" "
2073                <<box->bbGetInputAsString(i->first)<<"\""<< std::endl;
2074           // store the input name
2075           in.push_back(i->first);
2076           (*s) << "  connect "<<i->first<<"Widget.Widget layout.Widget"<<in.size()<<std::endl;
2077             //<i->first<<"'"<<std::endl;
2078           (*s) << "  connect "<<i->first<<"Widget.BoxChange change.In"<<in.size()<<std::endl;
2079
2080         }
2081       // try to find an adaptor from string 
2082       // If found then can create a text input which 
2083       // will be automatically adapted 
2084       else if (F->FindAdaptor(DataInfo(typeid(std::string),""),
2085                                d->GetDataInfo(),
2086                                adaptor))
2087         {
2088           // command to create the adaptor
2089           (*s) << "  new InputText "<<i->first<<std::endl;
2090           // Sets the label of the widget adaptor to the name of the input
2091           (*s) << "  set "<<i->first<<".Title "<<i->first<<std::endl;
2092           // Sets the initial value of the widget to the value of the input
2093           (*s) << "  set "<<i->first<<".In \" "
2094                <<box->bbGetInputAsString(i->first)<<"\""<< std::endl;
2095           // store the input name
2096           in.push_back(i->first);
2097           (*s) << "  connect "<<i->first<<".Widget layout.Widget"<<in.size()<<std::endl;
2098             //<i->first<<"'"<<std::endl;
2099           (*s) << "  connect "<<i->first<<".BoxChange change.In"<<in.size()<<std::endl;
2100
2101         }
2102       else 
2103         {
2104           widok = false;
2105         }
2106       if (widok)
2107         {
2108           // command to create the output
2109           (*s) << "  output "<<i->first<<" "
2110                <<i->first<<".Out "<<i->first<<std::endl;
2111             //         <<" Output of the widget which allows to set "
2112           
2113         }
2114     }   
2115   // Inputs for window properties
2116   (*s) << "  input WinTitle layout.WinTitle Title"<<std::endl;
2117   (*s) << "  input WinWidth layout.WinWidth Width"<<std::endl;
2118   (*s) << "  input WinHeight layout.WinHeight Height"<<std::endl;
2119   (*s) << "  input WinDialog layout.WinDialog Dialog"<<std::endl;
2120   (*s) << "  input WinHide layout.WinHide Hide"<<std::endl;
2121
2122   
2123   
2124   // Execute the box executes the layout
2125   (*s) << "  exec layout" << std::endl;
2126   (*s) << "endefine" << std::endl;
2127   // (*s) << "help "<< typeName<< std::endl;
2128   // instanciate the box and connect it
2129   (*s) << "new "<<typeName<<" "<<instanceName<<std::endl;
2130   // connections
2131   std::vector<std::string>::iterator j;
2132   for (j=in.begin();j!=in.end();++j)
2133     {
2134       // connect
2135       (*s) << "connect "<<instanceName<<"."<<*j<<" "
2136            << boxname<<"."<<*j<<std::endl;
2137     }
2138   // That's all folks ! now execute the commands :
2139   SwitchToStream(s);
2140 }
2141 //=======================================================================
2142
2143
2144
2145  //==========================================================================
2146   void Interpreter::commandDebug(const std::string& name)
2147   {
2148     if ((name.length()==2)&&(name[0]=='-'))
2149       {
2150         if (name[1]=='D')
2151           {
2152             bbtk::StaticInitTime::PrintObjectListInfo = true;
2153           }
2154         if (name[1]=='C')
2155           {
2156             //      int o = MessageManager::GetMessageLevel("debug");
2157             //      if (o<2) MessageManager::SetMessageLevel("debug",2);
2158             mVirtualExecuter->GetFactory()->Check();
2159             //      MessageManager::SetMessageLevel("debug",o);
2160           }
2161       }
2162     else 
2163       {
2164         Object:: PrintObjectListInfo(name);
2165       }
2166   }
2167  //==========================================================================
2168
2169   /*
2170   //==========================================================================
2171   // Adds a callback when 'break' command issued
2172   void Interpreter::AddBreakObserver( BreakCallbackType c )
2173   {
2174     mBreakSignal.connect(c);
2175   }
2176  //==========================================================================
2177  */
2178
2179  //==========================================================================
2180   std::string Interpreter::GetObjectName() const
2181   {
2182     return std::string("Interpreter");
2183   }
2184   //==========================================================================
2185   
2186   //==========================================================================
2187   std::string  Interpreter::GetObjectInfo() const 
2188   {
2189     std::stringstream i;
2190     return i.str();
2191   }
2192   //==========================================================================
2193
2194   //==========================================================================
2195 size_t  Interpreter::GetObjectSize() const 
2196 {
2197   size_t s = Superclass::GetObjectSize();
2198   s += Interpreter::GetObjectInternalSize();
2199   return s;
2200   }
2201   //==========================================================================
2202   //==========================================================================
2203 size_t  Interpreter::GetObjectInternalSize() const 
2204 {
2205   size_t s = sizeof(Interpreter);
2206   return s;
2207   }
2208   //==========================================================================
2209   //==========================================================================
2210   size_t  Interpreter::GetObjectRecursiveSize() const 
2211   {
2212     size_t s = Superclass::GetObjectRecursiveSize();
2213     s += Interpreter::GetObjectInternalSize();
2214     s += mVirtualExecuter->GetObjectRecursiveSize();
2215     return s;
2216   }
2217   //==========================================================================
2218 }//namespace
2219
2220