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
1286     bbtkMessage("interpreter",3,
1287                 "package name:[" << pkgname
1288                  << "] path:[" << upath << "]" << std::endl);
1289     bool fullnameGiven = false;
1290     bool foundFile     = false;
1291
1292     // ==== "*" provided : load all scripts in given path
1293     // relative (e.g. std/boxes/*) or absolute
1294     if (pkgname == "*")
1295       {
1296
1297         std::stringstream* stream = new std::stringstream;
1298         //if (upath.size()!=0) // avoid troubles for "*"
1299
1300         // ==== no path provided : look in root bbs path
1301         if (upath.size()==0)
1302           {
1303             //      bbtkMessage("interpreter",1,
1304             // LG : add all bbs path
1305             //  script_paths.push_back(  ConfigurationFile::GetInstance().Get_root_bbs_path() );
1306             std::vector<std::string>::const_iterator i;
1307             for (i=ConfigurationFile::GetInstance().Get_bbs_paths().begin();
1308                  i!=ConfigurationFile::GetInstance().Get_bbs_paths().end();
1309                  i++)
1310               {
1311                 script_paths.push_back(*i);
1312               }
1313           }
1314         // ==== absolute path provided
1315         else if (upath[0]=='/' || upath[1] == ':' )
1316           {
1317             if ( Utilities::IsDirectory( upath ) )
1318               {
1319                 script_paths.push_back(upath);
1320               }
1321             else
1322               {
1323                 bbtkError("'"<<upath<<"' : directory does not exist");
1324               }
1325           }
1326         // ==== relative path provided : search all bbs path appended with
1327         // the relative path provided
1328         else
1329           {
1330             std::vector<std::string>::const_iterator i;
1331             for (i=ConfigurationFile::GetInstance().Get_bbs_paths().begin();
1332                  i!=ConfigurationFile::GetInstance().Get_bbs_paths().end();
1333                  i++)
1334               {
1335                 std::string full_path(*i);
1336                 // we *really* want '.' to be the current working directory
1337                 if (full_path == ".")
1338                   {
1339                     char buf[2048]; // for getcwd
1340                     char * currentDir = getcwd(buf, 2048);
1341                     std::string cwd(currentDir);
1342                     full_path = currentDir;
1343                   } // if full_path
1344
1345                 full_path += ConfigurationFile::GetInstance().Get_file_separator();
1346                 full_path += upath;
1347
1348                 if ( Utilities::IsDirectory( full_path ) )
1349                   {
1350                     script_paths.push_back(full_path);
1351                   }
1352               }
1353             if (script_paths.empty())
1354               {
1355                 bbtkError("no '"<<upath<<"' subdir found in search paths"
1356                           << std::endl);
1357               }
1358           }
1359
1360         // === search paths list complete : now explore it
1361         int nbBssFiles = 0;
1362         // ==== relative name, iterate + load all .bbs/.bbp files
1363         std::vector<std::string>::iterator i;
1364         for (i=script_paths.begin();i!=script_paths.end();i++)
1365           {
1366             bbtkMessage("interpreter",1,
1367                         "--> Looking in '" << *i << "'" << std::endl);
1368
1369             Filenames.clear();
1370             //int nbFiles =
1371             Utilities::Explore(*i, false, Filenames);
1372
1373             for (std::vector<std::string>::iterator j = Filenames.begin();
1374                  j!= Filenames.end(); ++j)
1375               {
1376                 int lgr = (*j).size();
1377                 if (lgr < 5) continue;
1378                 // ignore non .bbp file
1379                 if ( (*j).substr(lgr-4, 4) != ".bbp") continue;
1380
1381                 (*stream) << "include \"" << *j << "\"\n";
1382                 bbtkMessage("interpreter",2,"  --> Found '" << *j << "'" << std::endl);
1383
1384                 nbBssFiles++;
1385               } // for (std::vector...
1386           } // for (i=script_...
1387
1388         // === Result ...
1389         if (nbBssFiles==0)
1390           {
1391             bbtkMessage("interpreter",1,
1392                         "  --> No .bbp found"<< std::endl);
1393           }
1394         else
1395           {
1396             bbtkMessage("interpreter",1,
1397                         "  --> "<<nbBssFiles<<" .bbp found"<< std::endl);
1398             SwitchToStream(stream);
1399           }
1400         return;
1401       }
1402     //=============== end pkgname=="*" ===========
1403
1404
1405     // if name starts with a / or a . or contains : user is assumed to have passed a relative/absolute name
1406     // (not only a plain script name)
1407     // we trust him, and try to expland the directory name
1408     // WARNING : starting from current local directory :  ./whatYouWant  (./ mandatory!)
1409
1410     if (name[0]=='/' || name[1] == ':' || name[0]=='.')  // absolute path (linux/windows) or relative path
1411     {
1412
1413       // ===========================================================check user supplied location
1414       fullnameGiven = true;
1415
1416       fullPathScriptName =  Utilities::ExpandLibName(name, false);
1417
1418       // allow user to always forget ".bbs"
1419       int l = fullPathScriptName.size();
1420
1421       if (l!=0)
1422           {
1423          if ((fullPathScriptName.substr(l-4, 4) != ".bbs")&&
1424                          (fullPathScriptName.substr(l-4, 4) != ".bbp"))
1425          {
1426                         std::string tfullPathScriptName = fullPathScriptName + ".bbs";
1427                         if ( Utilities::FileExists(tfullPathScriptName) )
1428                         {
1429                                 fullPathScriptName = tfullPathScriptName;
1430                                 foundFile = true;
1431                         }
1432                         else
1433                         {
1434                                 tfullPathScriptName = fullPathScriptName + ".bbp";
1435                                 if ( Utilities::FileExists(tfullPathScriptName) )
1436                                 {
1437                                         fullPathScriptName = tfullPathScriptName;
1438                                         foundFile = true;
1439                                 }
1440                         }
1441                  }
1442                  else
1443                  {
1444                         if ( Utilities::FileExists(fullPathScriptName) )
1445                         {
1446                                 foundFile = true;
1447                         }
1448                  }
1449           } // endif l != 0
1450   }
1451   else
1452   // =============================== iterate on the paths
1453   {
1454       script_paths = ConfigurationFile::GetInstance().Get_bbs_paths();
1455       std::string path;
1456       std::vector<std::string>::iterator i;
1457       for (i=script_paths.begin();i!=script_paths.end();++i)
1458           {
1459                 path = *i;
1460                 // we *really* want '.' to be the current working directory
1461                 if (path == ".")
1462                 {
1463                         char buf[2048]; // for getcwd
1464                         char * currentDir = getcwd(buf, 2048);
1465                         std::string cwd(currentDir);
1466                         path = currentDir;
1467                 }
1468
1469                 std::string tfullPathScriptName = Utilities::MakePkgnameFromPath(path, name, false);
1470 //Addition JCP tfullPathScriptName.size()>=4
1471                 if(tfullPathScriptName.size()>=4){
1472                         if (tfullPathScriptName.substr(tfullPathScriptName.size()-4, 3)==".bb")
1473                         {
1474                           fullPathScriptName = tfullPathScriptName;
1475                                 if ( ! Utilities::FileExists(fullPathScriptName) )
1476                                 {
1477                                         // The following is *NOT* a debug time message :
1478                                         // It's a user intended message.
1479                                         // Please don't remove it.
1480                                         bbtkMessage("interpreter",2,
1481                                   "   [" <<fullPathScriptName <<"] : does not exist"
1482                                   <<std::endl);
1483                                         continue;  // try next path
1484                                 }
1485                                 bbtkMessage("interpreter",2,
1486                                           "   [" <<fullPathScriptName
1487                                           <<"] : found" <<std::endl);
1488                                 foundFile = true;
1489                                 break; // a script was found; we stop iterating
1490                         }
1491                         else
1492                         {
1493                                 fullPathScriptName = tfullPathScriptName + ".bbs";
1494                                 // Check if library exists
1495                                 if ( ! Utilities::FileExists(fullPathScriptName) )
1496                                 {
1497                                         fullPathScriptName = tfullPathScriptName + ".bbp";
1498                                         if ( ! Utilities::FileExists(fullPathScriptName) )
1499                                         {
1500                                                 // The following is *NOT* a debug time message :
1501                                                 // It's a user intended message.
1502                                                 // Please don't remove it.
1503                                                 bbtkMessage("interpreter",2,
1504                                                 "   [" <<tfullPathScriptName <<".bbs/.bbp] : do not exist"
1505                                                 <<std::endl);
1506                                                 continue;  // try next path
1507                                         }
1508                                 }
1509                                 bbtkMessage("interpreter",2,
1510                                   "   [" <<fullPathScriptName
1511                                   <<"] : found" <<std::endl);
1512                                 foundFile = true;
1513                                 break; // a script was found; we stop iterating
1514                         }
1515                 }
1516         } //------------------ // end for ( package_paths.begin();i!=package_paths.end() )
1517   }
1518
1519     if (!foundFile)
1520       {
1521         if (fullnameGiven)
1522           if(fullPathScriptName == "")
1523             bbtkError("Path ["<<upath<<"] doesn't exist");
1524           else
1525             bbtkError("Script ["<<fullPathScriptName<<"] not found");
1526         else
1527           bbtkError("No ["<<pkgname<<".bbs/.bbp] script found");
1528         return;
1529       } else {
1530                 LoadScript(fullPathScriptName,name);
1531 //EED Borrame     if (source) GetExecuter()->SetCurrentFileName(fullPathScriptName);
1532                 if (source) SetCurrentFileName(fullPathScriptName);
1533         }
1534
1535     return;
1536   }
1537   //=======================================================================
1538
1539         //=======================================================================
1540         void InterpreterVirtual::SetCurrentFileName(const std::string &fullPathScriptName)  // virtual
1541         {
1542         }
1543         //=======================================================================
1544
1545   //=======================================================================
1546 void InterpreterVirtual::SwitchToStream( std::stringstream* stream )
1547 {
1548   bbtkDebugMessage("interpreter",4,"==> InterpreterVirtual::SwitchToStream()"
1549                    <<std::endl);
1550    mFile.push_back(stream);
1551     std::ostringstream buffer_name;
1552     bufferNb++;
1553     buffer_name << "buffer_" ;
1554
1555     if (mFileName.size()>0 )
1556     {
1557        buffer_name << mFileName.back() << "_" << mLine.back();
1558     }
1559     mFileName.push_back(buffer_name.str());
1560     mIncludeFileName.push_back(buffer_name.str());
1561     mLine.push_back(0);
1562 }
1563   //=======================================================================
1564
1565   //=======================================================================
1566
1567   void InterpreterVirtual::LoadScript( std::string fullPathScriptName,
1568                                 std::string includeScriptName)
1569   {
1570     bbtkDebugMessage("interpreter",4,"==> InterpreterVirtual::LoadScript("
1571                      <<fullPathScriptName<<")"
1572                      <<std::endl);
1573
1574     Utilities::replace( fullPathScriptName ,
1575                          INVALID_FILE_SEPARATOR , VALID_FILE_SEPARATOR);
1576
1577      if (find(mFileNameHistory.begin(),
1578               mFileNameHistory.end(),
1579               fullPathScriptName)!=mFileNameHistory.end())
1580      {
1581         return;
1582      }
1583
1584     std::ifstream* s;
1585     s = new std::ifstream;
1586     s->open(fullPathScriptName.c_str());
1587     if (!s->good())
1588     {
1589         bbtkError("Could not open file ["<<fullPathScriptName<<"]");
1590         return;
1591     }
1592
1593     bbtkMessage("interpreter",1,"   -->[" << fullPathScriptName
1594                 << "] found" << std::endl);
1595
1596     mFile.push_back(s);
1597     mFileName.push_back(fullPathScriptName);
1598     mFileNameHistory.push_back(fullPathScriptName);
1599     mIncludeFileName.push_back(includeScriptName);
1600     mLine.push_back(0);
1601
1602     return;
1603   }
1604   //=======================================================================
1605
1606   //=======================================================================
1607   void InterpreterVirtual::CloseCurrentFile()
1608   {
1609     bbtkDebugMessage("interpreter",9,"==> InterpreterVirtual::CloseCurrentFile()"
1610                       <<std::endl);
1611
1612     if (mFile.size()==0)
1613     {
1614       bbtkDebugMessage("interpreter",9," -> no file left open"<<std::endl);
1615       return;
1616     }
1617
1618     bbtkDebugMessage("interpreter",9," Closing file '"<<mFileName.back()<<"'"<<std::endl);
1619
1620     std::ifstream* file = dynamic_cast<std::ifstream*>(mFile.back());
1621     if (file!=0) file->close();
1622
1623     delete mFile.back();
1624     mFile.pop_back();
1625     mFileName.pop_back();
1626     mIncludeFileName.pop_back();
1627     mLine.pop_back();
1628
1629     bbtkDebugMessage("interpreter",9," Remains "
1630                      <<mFile.size()
1631                      <<" open"<<std::endl);
1632     bbtkDebugMessage("interpreter",9,"<== InterpreterVirtual::CloseCurrentFile()"
1633                      <<std::endl);
1634   }
1635   //=======================================================================
1636
1637  //=======================================================================
1638   void InterpreterVirtual::CloseAllFiles()
1639   {
1640     bbtkDebugMessage("interpreter",9,"==> InterpreterVirtual::CloseAllFiles()"
1641                       <<std::endl);
1642
1643     while (mFile.size() != 0)
1644     {
1645        CloseCurrentFile();
1646     }
1647     bbtkDebugMessage("interpreter",9,"<== InterpreterVirtual::CloseAllFiles()"
1648                       <<std::endl);
1649   }
1650   //=======================================================================
1651
1652
1653
1654   //=======================================================================
1655   void InterpreterVirtual::InterpretCommand( const std::vector<std::string>& words,
1656                                       CommandInfoType& info )
1657   {
1658
1659     bbtkDebugMessage("interpreter",9,"==> InterpreterVirtual::InterpretCommand(...)"<<std::endl);
1660
1661     // searches the command keyword
1662     CommandDictType::iterator c;
1663     c = mCommandDict.find(words[0]);
1664     if ( c == mCommandDict.end() ) {
1665       bbtkError(words[0]<<" : unknown command");
1666     }
1667
1668     // tests the number of args
1669     if ( ( ((int)words.size())-1 < c->second.argmin ) ||
1670          ( ((int)words.size())-1 > c->second.argmax ) )
1671     {
1672
1673 //EED       HelpCommand(words[0]);
1674                 commandHelp(words[0]);
1675        bbtkError(words[0]<<" : wrong number of arguments");
1676     }
1677 //std::cout<<"InterpreterVirtual::InterpretCommand( const std::vector<std::string>& words,"<<std::endl;
1678     info = c->second;
1679     bbtkDebugMessage("interpreter",9,"<== InterpreterVirtual::InterpretCommand(...)"<<std::endl);
1680
1681   }
1682   //=======================================================================
1683
1684
1685   //=======================================================================
1686   /// Displays help on all the commands
1687   void InterpreterVirtual::commandHelp(const std::vector<std::string>& words)
1688   {
1689   }
1690   //=======================================================================
1691   void InterpreterVirtual::commandHelp(const std::string &words)
1692   {
1693   }
1694         //=======================================================================
1695
1696    //===================================================================
1697   /// Displays the Configuration
1698   void InterpreterVirtual::commandConfig() const
1699   {
1700   }
1701    //===================================================================
1702
1703
1704
1705   //=======================================================================
1706   /// Fills the vector commands with the commands which
1707   /// have the first n chars of buf for prefix
1708   /// TODO : skip initial spaces in buf and also return the position of first
1709   /// non blank char in buf
1710   void InterpreterVirtual::FindCommandsWithPrefix( char* buf,
1711                                             int n,
1712                                             std::vector<std::string>& commands )
1713   {
1714     CommandDictType::const_iterator i;
1715     for (i=mCommandDict.begin(); i!=mCommandDict.end(); ++i)
1716     {
1717       if ((i->first).find(buf,0,n) == 0)
1718         commands.push_back(i->first);
1719     }
1720   }
1721   //=======================================================================
1722
1723
1724
1725   //=======================================================================
1726 #ifdef BBTK_USE_TERMIOS_BASED_PROMPT
1727
1728   inline void PrintChar(char c) { write(STDOUT_FILENO,&c,1); }
1729   inline void BackSpace() { write(STDOUT_FILENO,"\b \b",3); }
1730
1731   // LG : KEYBOARD CODES AS SCANNED ON MY TTY : UNIVERSAL ?
1732   // IF NOT THE USER SHOULD BE ABLE TO CONFIGURE IT
1733   // E.G. STORE THIS IN bbtk_config.xml
1734 #define BBTK_UP_ARROW_KBCODE    0x00415B1B
1735 #define BBTK_DOWN_ARROW_KBCODE  0x00425B1B
1736 #define BBTK_RIGHT_ARROW_KBCODE 0x00435B1B
1737 #define BBTK_LEFT_ARROW_KBCODE  0x00445B1B
1738 #define BBTK_BACKSPACE_KBCODE   0x00000008
1739 #define BBTK_DEL_KBCODE         0x0000007F
1740 #define BBTK_SPACE_KBCODE       0x00000020
1741
1742   //=======================================================================
1743   void InterpreterVirtual::GetLineFromPrompt(std::string& s)
1744   {
1745     int c;
1746     unsigned int ind=0;
1747
1748     unsigned int MAX_LINE_SIZE = 160;
1749     unsigned int MAX_HISTORY_SIZE = 100;
1750
1751     char* newline = new char[MAX_LINE_SIZE];
1752     memset(newline,0,MAX_LINE_SIZE);
1753     char* histline = new char[MAX_LINE_SIZE];
1754     memset(histline,0,MAX_LINE_SIZE);
1755
1756     char* line = newline;
1757     unsigned int hist = mHistory.size();
1758
1759     write(1,"> ",2);
1760     while(1)
1761     {
1762        c=0;
1763        read ( STDIN_FILENO, &c, 4) ;
1764
1765        bbtkDebugMessage("debug",9,"[0x"<<std::hex<<c<<"]\n");
1766
1767        // Printable character
1768        if ( (ind<MAX_LINE_SIZE-1) &&
1769             ( c >= BBTK_SPACE_KBCODE ) &&
1770             ( c <  BBTK_DEL_KBCODE ))
1771        {
1772           PrintChar(c);
1773           line[ind++]=c;
1774        }
1775       // CR
1776        else if (c=='\n')
1777        {
1778        // delete the unused line
1779           if (line==newline)
1780               delete histline;
1781           else
1782               delete newline;
1783
1784     // empty lines are not stored in from history
1785           if (strlen(line))
1786           {
1787              // if history too long : delete oldest command
1788              if (mHistory.size()>MAX_HISTORY_SIZE)
1789              {
1790                 delete mHistory.front();
1791                 mHistory.pop_front();
1792              }
1793              mHistory.push_back(line);
1794           }
1795           break;
1796         }
1797        // Backspace
1798         else if ( (ind>0) &&
1799                   ((c == BBTK_BACKSPACE_KBCODE) ||
1800                    (c == BBTK_DEL_KBCODE)) )
1801           {
1802             line[ind--]=' ';
1803             BackSpace();
1804           }
1805         // Tab
1806         else if (c=='\t')
1807           {
1808             // TODO : Command completion
1809             std::vector<std::string> commands;
1810             FindCommandsWithPrefix( line,ind,commands);
1811             if (commands.size()==1)
1812               {
1813                 std::string com = *commands.begin();
1814                 for (; ind<com.size(); ++ind)
1815                   {
1816                     PrintChar(com[ind]);
1817                     line[ind]=com[ind];
1818                   }
1819                 PrintChar(' ');
1820                 line[ind++]=' ';
1821               }
1822             else if (commands.size()>1)
1823               {
1824                 std::vector<std::string>::iterator i;
1825                 write(1,"\n",1);
1826                 for (i=commands.begin();i!=commands.end();++i)
1827                   {
1828                     write(STDOUT_FILENO,(*i).c_str(),strlen((*i).c_str()));
1829                     PrintChar(' ');
1830                   }
1831                 write(STDOUT_FILENO,"\n> ",3);
1832                 //for (int j=0;j<ind;++j)
1833                   //{
1834                     write(STDOUT_FILENO,line,ind);
1835                     //  }
1836               }
1837           }
1838         // Arrow up : back in history
1839         else if (c==BBTK_UP_ARROW_KBCODE)
1840           {
1841             if (hist)
1842               {
1843                 // erase current line
1844                 while (ind--) BackSpace();
1845                 //
1846                 hist--;
1847                 //
1848                 strcpy(histline,mHistory[hist]);
1849                 line = histline;
1850                 ind = strlen(line);
1851
1852                 write(STDOUT_FILENO,line,ind);
1853               }
1854           }
1855         // Arrow down : down in history
1856         else if (c==BBTK_DOWN_ARROW_KBCODE)
1857           {
1858             if (hist<mHistory.size()-1)
1859               {
1860                 // erase current line
1861                 while (ind--) BackSpace();
1862                 //
1863                 hist++;
1864                 //
1865                 strcpy(histline,mHistory[hist]);
1866                 line = histline;
1867                 ind = strlen(line);
1868
1869                 write(STDOUT_FILENO,line,ind);
1870               }
1871             // end of history : switch back to newline
1872             else if (hist==mHistory.size()-1)
1873               {
1874                 // erase current line
1875                 while (ind--) BackSpace();
1876                 //
1877                 hist++;
1878                 //
1879                 line = newline;
1880                 ind = strlen(line);
1881
1882                 write(STDOUT_FILENO,line,ind);
1883               }
1884           }
1885         // Arrow right
1886         else if (line[ind]!=0 && c==BBTK_RIGHT_ARROW_KBCODE)
1887           {
1888             PrintChar(line[ind]);
1889             ind++;
1890           }
1891
1892         // Arrow left
1893         else if (ind>0 && c==BBTK_LEFT_ARROW_KBCODE)
1894           {
1895             PrintChar('\b');
1896             ind--;
1897
1898           }
1899
1900       }
1901     write(STDOUT_FILENO,"\n\r",2);
1902
1903
1904     s = line;
1905
1906   }
1907 #else
1908
1909   //=======================================================================
1910   void InterpreterVirtual::GetLineFromPrompt(std::string& s)
1911   {
1912     s.clear();
1913
1914     putchar('>');
1915     putchar(' ');
1916
1917     do
1918     {
1919       char c = getchar();
1920       if (c=='\n')
1921       {
1922         putchar('\n');
1923         break;
1924       }
1925       if (c=='\t')
1926       {
1927         // putchar('T');
1928         continue;
1929       }
1930       // putchar(c);
1931       s += c;
1932     }
1933     while (true);
1934
1935   }
1936   //=======================================================================
1937
1938 #endif
1939
1940
1941
1942   //=======================================================================
1943   void InterpreterVirtual::CommandLineInterpreter()
1944   {
1945     bbtkDebugMessageInc("interpreter",9,
1946                         "InterpreterVirtual::CommandLineInterpreter()"<<std::endl);
1947
1948 #ifdef BBTK_USE_TERMIOS_BASED_PROMPT
1949     // Initialise the tty in non canonical mode with no echo
1950     // oter remembers the previous settings to restore them after
1951     struct termios ter,oter;
1952     tcgetattr(0,&ter);
1953     oter=ter;
1954     ter.c_lflag &= ~ECHO;
1955     ter.c_lflag &= ~ICANON;
1956     ter.c_cc[VMIN]=1;
1957     ter.c_cc[VTIME]=0;
1958     tcsetattr(0,TCSANOW,&ter);
1959 #endif
1960
1961
1962     mCommandLine = true;
1963     bool again = true;
1964     // bool insideComment = false; // for multiline comment
1965     mInsideComment = false;
1966     do
1967     {
1968       try
1969       {
1970         std::string line;
1971         GetLineFromPrompt(line);
1972         DoInterpretLine(line); //, insideComment);
1973       }
1974       /*
1975       catch (QuitException e)
1976       {
1977         bbtkMessage("interpreter",1,"Interpreter : Quit"<<std::endl);
1978         again = false;
1979       }
1980       */
1981       catch (bbtk::Exception e)
1982       {
1983         e.Print();
1984       }
1985         catch (std::exception& e)
1986       {
1987         std::cerr << "* ERROR :: "<<e.what()<<" (not in bbtk)"<<std::endl;
1988       }
1989       catch (...)
1990       {
1991         std::cerr << "* UNDEFINED ERROR (not a bbtk nor a std exception)"<<std::endl;
1992       }
1993     }
1994     while (again);
1995
1996 #ifdef BBTK_USE_TERMIOS_BASED_PROMPT
1997     tcsetattr(0,TCSANOW,&oter);
1998 #endif
1999
2000     std::cout << "Good bye !" << std::endl;
2001
2002     bbtkDebugDecTab("interpreter",9);
2003   }
2004
2005 //=======================================================================
2006 void InterpreterVirtual::commandGraph(const std::vector<std::string>& words)
2007 {
2008 }
2009 //=======================================================================
2010
2011
2012 //=======================================================================
2013 void  InterpreterVirtual::commandIndex(const std::string& filename, const std::string& type)
2014 {
2015 }
2016 //=======================================================================
2017
2018
2019 //=======================================================================
2020 void  InterpreterVirtual::commandNewGUI(const std::string& boxname,const std::string& instanceName)
2021 {
2022 }
2023 //=======================================================================
2024
2025
2026
2027  //==========================================================================
2028   void InterpreterVirtual::commandDebug(const std::string& name)
2029   {
2030   }
2031  //==========================================================================
2032
2033   /*
2034   //==========================================================================
2035   // Adds a callback when 'break' command issued
2036   void InterpreterVirtual::AddBreakObserver( BreakCallbackType c )
2037   {
2038     mBreakSignal.connect(c);
2039   }
2040  //==========================================================================
2041  */
2042
2043  //==========================================================================
2044   std::string InterpreterVirtual::GetObjectName() const
2045   {
2046     return std::string("InterpreterVirtual");
2047   }
2048   //==========================================================================
2049
2050   //==========================================================================
2051   std::string  InterpreterVirtual::GetObjectInfo() const
2052   {
2053     std::stringstream i;
2054     return i.str();
2055   }
2056   //==========================================================================
2057
2058   //==========================================================================
2059 size_t  InterpreterVirtual::GetObjectSize() const
2060 {
2061   size_t s = Superclass::GetObjectSize();
2062   s += InterpreterVirtual::GetObjectInternalSize();
2063   return s;
2064   }
2065   //==========================================================================
2066   //==========================================================================
2067 size_t  InterpreterVirtual::GetObjectInternalSize() const
2068 {
2069   size_t s = sizeof(InterpreterVirtual);
2070   return s;
2071   }
2072   //==========================================================================
2073   //==========================================================================
2074   size_t  InterpreterVirtual::GetObjectRecursiveSize() const
2075   {
2076     size_t s = Superclass::GetObjectRecursiveSize();
2077     s += InterpreterVirtual::GetObjectInternalSize();
2078     return s;
2079   }
2080   //==========================================================================
2081 }//namespace
2082
2083