kernel/src/bbtkInterpreterVirtual.cxx

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