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