diff --git a/src/plugins/shell-functions.cpp b/src/plugins/shell-functions.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..069d0024b1aa3d1720d1c4fe46719050bbd26c20
--- /dev/null
+++ b/src/plugins/shell-functions.cpp
@@ -0,0 +1,517 @@
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ * Copyright Projet JRL-Japan, 2007
+ *+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ *
+ * File: shell-functions.cpp
+ * Project: DYNAMIC-GRAPH
+ * Author: François Bleibel, Nicolas Mansard
+ *
+ * Version control
+ * ===============
+ *
+ * $Id$
+ *
+ * Description
+ * ============
+ *
+ *
+ * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
+
+#include <dynamic-graph/shell-functions.h>
+#include <dynamic-graph/plugin-loader.h>
+#include <dynamic-graph/factory.h>
+#include <dynamic-graph/debug.h>
+#include <dynamic-graph/entity.h>
+#include <dynamic-graph/signal.h>
+#include <dynamic-graph/exception-signal.h>
+
+#ifdef WIN32
+#include <Windows.h>
+#endif
+
+#include <fstream>
+using namespace std;
+using namespace dynamicgraph;
+
+void ShellFunctions::
+cmdTry( const std::string cmdLine, istringstream& cmdArg, std::ostream& os )
+{
+ if( cmdLine == "help" )
+ {
+ os << " - try <cmd...>"
+ << "\t\t\t\tTry <cmd> and display the caught exception." <<endl;
+ return;
+ }
+ string cmdLine2;
+ cmdArg>>cmdLine2;
+ dgDEBUG(5)<<"Try <" <<cmdLine2<<">"<<endl;
+ try{
+ g_shell.cmd(cmdLine2,cmdArg,os);
+ } catch ( const ExceptionAbstract& e ) { os << "dgERROR catch: " <<endl<< e<<endl; }
+ catch( ... ) { os<<"Unknown error catch." <<endl; }
+
+}
+void ShellFunctions::
+cmdLoadPlugins( const std::string cmdLine, std::istringstream& cmdArg, std::ostream& os )
+{
+ if( cmdLine == "help" )
+ {
+ os << " - loadPlugins <file.txt> <directory>"
+ << "\t\tLoad the plugins listed in the file." <<endl;
+ return;
+ }
+ if( NULL!=g_shell.dlPtr )
+ {
+ string pluginName,directory;
+ cmdArg >> pluginName;
+ cmdArg >> directory;
+ dgDEBUG(15) << "Load plugin list <" <<pluginName<<"> from dir <" << directory<<">."<<endl;
+ if( directory.length() != 0 ) g_shell.dlPtr->setDirectory( directory );
+ g_shell.dlPtr ->loadPluginList( pluginName );
+ g_shell.dlPtr->loadPlugins();
+ }
+ else { os << "!! Dynamic loading functionalities not accessible through the shell." <<endl; }
+}
+void ShellFunctions::
+cmdClearPlugin( const std::string cmdLine, std::istringstream& cmdArg, std::ostream& os )
+{
+ if( cmdLine == "help" )
+ {
+ os << " - clearPlugin <className>"
+ << "\t\tDestroy all the objects of type <className>." <<endl;
+ return;
+ }
+
+ string pluginName;
+ cmdArg >> pluginName;
+ g_pool.clearPlugin( pluginName );
+
+}
+
+void ShellFunctions::
+cmdDisplayPlugins( const std::string cmdLine, std::istringstream& cmdArg, std::ostream& os )
+{
+ if( cmdLine == "help" )
+ {
+ os << " - displayPlugins "
+ << "\t\t\t\tDisplay the name of the loaded plugins." <<endl;
+ return;
+ }
+ if( NULL!=g_shell.dlPtr )
+ {
+ std::map< std::string,std::string > m = g_shell.dlPtr->getLoadedPluginNames();
+ for( std::map< std::string,std::string >::const_iterator iter = m.begin();
+ iter!=m.end(); ++iter )
+ {
+ os << " - <"<<iter->first<<">:\t"<<iter->second<<endl;
+ }
+
+ }
+ else { os << "!! Dynamic loading functionalities not accessible through the shell." <<endl; }
+
+
+}
+
+
+
+void ShellFunctions::
+cmdDisplayFactory( const std::string cmdLine, std::istringstream& cmdArg,
+ std::ostream& os )
+{
+ if( cmdLine == "help" )
+ {
+ os << " - "; g_factory.commandLine(cmdLine,cmdArg,os);
+ return;
+ }
+
+ string cmd2; cmdArg >> cmd2;
+ g_factory.commandLine( cmd2,cmdArg,os );
+}
+
+void ShellFunctions::
+cmdCommentary( const std::string cmdLine, std::istringstream& cmdArg, std::ostream& os )
+{
+ if( cmdLine == "help" )
+ { os << " # comment with '#': ignore the end of the line." <<endl; }
+ return;
+}
+
+
+void ShellFunctions::
+cmdUnplug( const std::string cmdLine, istringstream& cmdArg, std::ostream& os )
+{
+ if( cmdLine == "help" )
+ {
+ os << " - unplug <obj2.sig2>"
+ << "\t\t\t\tPlug on sig2 (consumer) in sig1->sig2." <<endl;
+ return;
+ }
+ string ssig;
+ cmdArg>>ssig;
+
+ string obj2,fun2;
+ istringstream str2(ssig);
+ if( !Interpreter::objectNameParser(str2,obj2,fun2) )
+ {
+ DG_THROW ExceptionFactory( ExceptionFactory::SYNTAX_ERROR,
+ "Plug function: syntax is unplug OBJ2.SIG2.",
+ "(while calling plug %s %s).",ssig.c_str() );
+ }
+
+ dgDEBUG(20) << "Get Ent2 <"<<obj2<<"> ."<<endl;
+ Entity& ent2 = g_pool.getEntity(obj2);
+ dgDEBUG(20) << "Get Sig2 <"<<fun2<<"> ."<<endl;
+ SignalBase<int> &sig2 = ent2.getSignal(fun2);
+
+
+ dgDEBUG(25) << "Unplug..."<<endl;
+ sig2.unplug();
+}
+
+void ShellFunctions::
+cmdSignalTime( const std::string cmdLine, istringstream& cmdArg, std::ostream& os )
+{
+ if( cmdLine == "help" )
+ {
+ os << " - signalTime <obj.sig>"
+ << "\t\t\t\tDisplay the time of sig." <<endl;
+ return;
+ }
+
+ string ssig;
+ cmdArg>>ssig;
+
+ string obj2,fun2;
+ istringstream str2(ssig);
+ if( !Interpreter::objectNameParser(str2,obj2,fun2) )
+ {
+ DG_THROW ExceptionFactory( ExceptionFactory::SYNTAX_ERROR,
+ "Plug function: syntax is unplug OBJ2.SIG2.",
+ "(while calling plug %s %s).",ssig.c_str() );
+ }
+
+ dgDEBUG(20) << "Get Ent2 <"<<obj2<<"> ."<<endl;
+ Entity& ent2 = g_pool.getEntity(obj2);
+ dgDEBUG(20) << "Get Sig2 <"<<fun2<<"> ."<<endl;
+ SignalBase<int> &sig2 = ent2.getSignal(fun2);
+
+ os << sig2.getTime() << endl;
+}
+
+void ShellFunctions::
+cmdSynchroSignal( const std::string cmdLine, std::istringstream& cmdArg, std::ostream& os )
+{
+ if( cmdLine == "help" )
+ {
+ os << " - synchro <obj.sig> [<period>]"
+ << "\t\t\t\tGet/Set the syncho of a signal <sig>." <<endl;
+ return;
+ }
+
+ SignalBase<int> & sig = g_pool.getSignal( cmdArg );
+ cmdArg >>ws;
+ if( cmdArg.good() )
+ {
+ int period; cmdArg>>period;
+ sig.setPeriodTime( period );
+ cmdArg >>ws;
+ if( cmdArg.good() )
+ {
+ /* The sig is recomputed at the given period from the
+ * current time, at any time T so that T%p==0, p the period.
+ * By modifying the current time, the sig reomputation is done
+ * at T s.t. T%p=d, d the desynchro. */
+ int currTime = sig.getTime ();
+ int desynchro; cmdArg>>desynchro;
+ sig.setTime( currTime+desynchro );
+ }
+ }
+ else
+ {
+ os << "period = " << sig.getPeriodTime() << std::endl;
+ }
+}
+
+void ShellFunctions::
+cmdEcho( const std::string cmdLine, std::istringstream& cmdArg, std::ostream& os )
+{
+ if( cmdLine == "help" )
+ {
+ os << " - echo <string>"
+ << "\t\t\t\tPrint <string. on the standard output." <<endl;
+ return;
+ }
+
+ cmdArg >>ws;
+ while( cmdArg.good() )
+ {
+ std::string toPrint; cmdArg>>toPrint;
+ os<<toPrint<<" ";
+ }
+ os<<std::endl;
+}
+
+void ShellFunctions::
+cmdCopy( const std::string cmdLine, istringstream& cmdArg, std::ostream& os )
+{
+ if( cmdLine == "help" )
+ {
+ os << " - copy <obj1.sig1> <obj2.sig2>"
+ << "\t\tCopy the value of sig1 to constant value in sig2." <<endl;
+ return;
+ }
+ string ssig1,ssig2;
+ cmdArg>>ssig1>>ssig2;
+ istringstream str1(ssig1),str2(ssig2);
+
+ try {
+ SignalBase<int> &sig1 = g_pool.getSignal( str1 );
+ SignalBase<int> &sig2 = g_pool.getSignal( str2 );
+
+ dgDEBUG(25) << "Copy..."<<endl;
+ sig2.plug(&sig1);
+ sig2.setConstantDefault();
+ sig2.plug(&sig2);
+ } catch( ExceptionAbstract & err ) { throw; }
+ catch( ... ) {
+ DG_THROW ExceptionFactory( ExceptionFactory::SYNTAX_ERROR,
+ "Copy: syntax is copy OBJ1.SIG1 OBJ2.SIG2.",
+ "(while calling copy %s %s).",ssig1.c_str(),
+ ssig2.c_str() );
+ }
+
+}
+
+void ShellFunctions::
+cmdFreeze( const std::string cmdLine, istringstream& cmdArg, std::ostream& os )
+{
+ if( cmdLine == "help" )
+ {
+ os << " - freeze <obj.sig> "
+ << "\t\tOn a ptr-sig: save the current value from the source "
+ << "and unplug the signal." <<endl;
+ return;
+ }
+ string ssig1;
+ cmdArg>>ssig1;
+ istringstream str1(ssig1);
+
+ try {
+ SignalBase<int> &sig1 = g_pool.getSignal( str1 );
+
+ dgDEBUG(25) << "Unplug..."<<endl;
+ sig1.setConstantDefault();
+ sig1.plug(&sig1);
+ } catch( ... ) {
+ DG_THROW ExceptionFactory( ExceptionFactory::SYNTAX_ERROR,
+ "Freeze: syntax is freeze OBJ.SIG.",
+ "(while calling freeze %s ).",ssig1.c_str());
+ }
+
+}
+
+void ShellFunctions::
+cmdSqueeze( const std::string cmdLine, istringstream& cmdArg, std::ostream& os )
+{
+ if( cmdLine == "help" )
+ {
+ os << " - squeeze <mainObj.mainSig> <squeezeObj.sigIn> <squeezeObj.sigOut>"
+ << "\t\tIntercalate squeezeObj between mainObj and its source." <<endl;
+ return;
+ }
+
+ string ssigMain,ssigIn,ssigOut;
+ cmdArg>>ssigMain>>ssigIn>>ssigOut;
+ istringstream strMain(ssigMain);
+ istringstream strIn(ssigIn);
+ istringstream strOut(ssigOut);
+
+ try {
+ SignalBase<int> &sigMain = g_pool.getSignal(strMain );
+ SignalBase<int> &sigIn = g_pool.getSignal( strIn );
+ SignalBase<int> &sigOut = g_pool.getSignal( strOut );
+
+ SignalBase<int> *sigMainSource = sigMain.getPluged();
+ if( sigMainSource==&sigMain )
+ {
+ DG_THROW ExceptionFactory( ExceptionFactory::SYNTAX_ERROR,
+ "The main signal is autopluged (or set constant). ",
+ "(while calling freeze %s ).",ssigMain.c_str());
+ }
+
+ sigMain.plug( &sigOut );
+ sigIn.plug( sigMainSource );
+ }
+ catch( ExceptionFactory& exc ) {
+ switch( exc.getCode() )
+ {
+ case ExceptionFactory::UNREFERED_SIGNAL:
+ DG_THROW ExceptionFactory( ExceptionFactory::SYNTAX_ERROR,
+ "Sqeeze: unknown signal. ",
+ "(error while searching signal: %s ).",
+ exc.getMessage() );
+ break;
+ default:
+ throw;
+ }
+ }
+
+}
+
+
+void ShellFunctions::
+cmdEnableTrace( const std::string cmdLine, istringstream& cmdArg, std::ostream& os )
+{
+ if( cmdLine == "help" )
+ {
+ os << " - debugtrace [{true|false}] [<filename>="
+ << DebugTrace::DEBUG_FILENAME_DEFAULT <<"]"
+ << "\t\tOpen/close the file <filename> for debug tracing." <<endl;
+ return;
+ }
+ string opt,filename;
+
+ cmdArg >> ws;
+ if( cmdArg.good() )
+ {
+ cmdArg>>opt>>ws;
+ if( opt=="true" )
+ if( cmdArg.good() )
+ {
+ cmdArg>>filename;
+ DebugTrace::openFile( filename.c_str() );
+ }
+ else { DebugTrace::openFile(); }
+ else DebugTrace::closeFile();
+ }
+ else
+ {
+ if( dgDEBUGFLOW.outputbuffer.good() ) os << "true" <<endl;
+ else os << "false" <<endl;
+ }
+
+}
+
+void ShellFunctions::
+cmdSetPrompt( const std::string cmdLine, istringstream& cmdArg, std::ostream& os )
+{
+ if( cmdLine == "help" )
+ {
+ os << " - prompt [<string>] "
+ << "\t\tSet/get the default prompt." <<endl;
+ return;
+ }
+
+ string opt;
+ cmdArg >> ws;
+ if( cmdArg. good() )
+ {
+ char buffer [80]; cmdArg .getline(buffer,80);
+ g_shell .prompt = buffer;
+ } else { os << "Current prompt is <" << g_shell. prompt << ">." << endl; }
+}
+
+void ShellFunctions::
+cmdSleep( const std::string cmdLine, istringstream& cmdArg, std::ostream& os )
+{
+ if( cmdLine == "help" )
+ {
+ os << " - sleep [<float> secs] "
+ << "\t\tSleep (time in secs)." <<endl;
+ return;
+ }
+
+ string opt;
+ cmdArg >> ws;
+ if( cmdArg. good() )
+ {
+ double secs; cmdArg >> secs;
+ if( secs > 0 )
+#ifndef WIN32
+ usleep( int(secs*1000000) );
+#else
+ Sleep( int(secs*1000) );
+#endif
+ } else { /* TODO ERROR */ }
+}
+
+void ShellFunctions::
+cmdBeep( const std::string cmdLine, istringstream& cmdArg, std::ostream& os )
+{
+ if( cmdLine == "help" )
+ {
+ os << " - beep [<float> secs] "
+ << "\t\tSend a bip to the std::cout." <<endl;
+ return;
+ }
+
+ os << char(7) << "Beep!" << std::endl;
+}
+
+void ShellFunctions::
+cmdCompletionList( const std::string cmdLine, istringstream& cmdArg, std::ostream& os )
+{
+ if( cmdLine == "help" )
+ {
+ os << " - completion <filename>"
+ << "\t\tGenerate the completion list for current graph." <<endl;
+ return;
+ }
+
+ try {
+
+ std::string aFileName; cmdArg >> aFileName;
+ std::ofstream completionFile((char *)aFileName.c_str());
+ g_pool.writeCompletionList( completionFile );
+
+
+ } catch( ExceptionAbstract & err ) { throw; }
+ catch( ... ) {
+ DG_THROW ExceptionFactory( ExceptionFactory::SYNTAX_ERROR,
+ "setflag: sig should be of flag type. ",
+ "(while calling setflag).");
+ }
+
+}
+
+
+extern "C" {
+ ShellFunctionRegisterer regFun1
+ ( "try",boost::bind(ShellFunctions::cmdTry,_1,_2,_3) );
+ ShellFunctionRegisterer regFun2
+ ( "loadPlugins",boost::bind(ShellFunctions::cmdLoadPlugins,_1,_2,_3) );
+ ShellFunctionRegisterer regFun3
+ ( "displayPlugins",boost::bind(ShellFunctions::cmdDisplayPlugins,_1,_2,_3) );
+ ShellFunctionRegisterer regFun4
+ ( "factory",boost::bind(ShellFunctions::cmdDisplayFactory,_1,_2,_3) );
+ ShellFunctionRegisterer regFun5
+ ( "#",boost::bind(ShellFunctions::cmdCommentary,_1,_2,_3) );
+ ShellFunctionRegisterer regFun7
+ ( "unplug",boost::bind(ShellFunctions::cmdUnplug,_1,_2,_3) );
+ ShellFunctionRegisterer regFun8
+ ( "clearPlugin",boost::bind(ShellFunctions::cmdClearPlugin,_1,_2,_3) );
+ ShellFunctionRegisterer regFun9
+ ( "signalTime",boost::bind(ShellFunctions::cmdSignalTime,_1,_2,_3) );
+ ShellFunctionRegisterer regFun10
+ ( "synchro",boost::bind(ShellFunctions::cmdSynchroSignal,_1,_2,_3) );
+ ShellFunctionRegisterer regFun11
+ ( "echo",boost::bind(ShellFunctions::cmdEcho,_1,_2,_3) );
+ ShellFunctionRegisterer regFun12
+ ( "copy",boost::bind(ShellFunctions::cmdCopy,_1,_2,_3) );
+ ShellFunctionRegisterer regFun13
+ ( "freeze",boost::bind(ShellFunctions::cmdFreeze,_1,_2,_3) );
+ ShellFunctionRegisterer regFun13b
+ ( "squeeze",boost::bind(ShellFunctions::cmdSqueeze,_1,_2,_3) );
+ ShellFunctionRegisterer regFun14
+ ( "debugtrace",boost::bind(ShellFunctions::cmdEnableTrace,_1,_2,_3) );
+ ShellFunctionRegisterer regFun15
+ ( "prompt",boost::bind(ShellFunctions::cmdSetPrompt,_1,_2,_3) );
+ ShellFunctionRegisterer regFun16
+ ( "sleep",boost::bind(ShellFunctions::cmdSleep,_1,_2,_3) );
+ ShellFunctionRegisterer regFun17
+ ( "beep",boost::bind(ShellFunctions::cmdBeep,_1,_2,_3) );
+ ShellFunctionRegisterer regFun19
+ ( "completion",boost::bind(ShellFunctions::cmdCompletionList,_1,_2,_3) );
+
+}
+
diff --git a/src/plugins/shell-procedure.cpp b/src/plugins/shell-procedure.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3a3a6f344dacf419c4b22ad4ea039fefe01ee642
--- /dev/null
+++ b/src/plugins/shell-procedure.cpp
@@ -0,0 +1,278 @@
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ * Copyright Projet JRL-Japan, 2007
+ *+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ *
+ * File: shell-procedure.cpp
+ * Project: DYNAMIC-GRAPH
+ * Author: François Bleibel, Nicolas Mansard
+ *
+ * Version control
+ * ===============
+ *
+ * $Id$
+ *
+ * Description
+ * ============
+ *
+ *
+ * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
+
+#include <dynamic-graph/shell-procedure.h>
+#include <dynamic-graph/plugin-loader.h>
+#include <dynamic-graph/factory.h>
+#include <dynamic-graph/debug.h>
+#include <dynamic-graph/entity.h>
+
+#include <fstream>
+using namespace std;
+using namespace dynamicgraph;
+
+void ShellProcedure::
+cmdStartProcedure( const std::string& cmdLine,std::istringstream& args,std::ostream& os )
+{
+ if( cmdLine == "help" )
+ {
+ os << " - proc <name>"
+ << "\t\t\t\tProcedure header." <<endl;
+ return;
+ }
+
+ args>>procName;
+ dgDEBUG(5)<<"Proc <" <<procName<<">"<<endl;
+
+ currentProc.clear();
+ args >> ws;
+ while( args.good() )
+ {
+ std::string next;
+ args>>next>>ws;
+ currentProc.params.push_back(next);
+ }
+}
+
+void ShellProcedure::
+cmdContinueProcedure( const std::string& cmdLine,std::istringstream& args,std::ostream& os )
+{
+ if( cmdLine == "help" )
+ {
+ os << " - -> cmd args..."
+ << "\t\t\t\tProcedure body." <<endl;
+ return;
+ }
+
+ std::string cmd2;
+ args>>ws>>cmd2;
+ dgDEBUG(5)<<"Proc <" <<procName<<">: "<<cmd2<<endl;
+
+ Instruction ins; ins.cmd=cmd2;
+ args >> ws;
+ while( args.good() )
+ {
+ std::string next; int param=-1;
+ args>>next>>ws;
+ for( unsigned int i=0;i<currentProc.params.size();++i )
+ { if( next==currentProc.params[i] ) { param=i; break; } }
+ ins.args.push_back(next);
+ ins.params.push_back( param );
+ }
+
+ currentProc.instructions.push_back( ins );
+}
+
+void ShellProcedure::
+cmdEndProcedure( const std::string& cmdLine,std::istringstream& args,std::ostream& os )
+{
+ if( cmdLine == "help" )
+ {
+ os << " - endproc..."
+ << "\t\t\t\tProcedure end." <<endl;
+ return;
+ }
+
+ dgDEBUG(5)<<"Proc <" <<procName<<">: endproc"<<endl;
+ procedureList[ procName ] = currentProc;
+
+// std::string toto="toto";
+// for( Procedure::iterator ins=procedureList[ toto ].begin();
+// ins!=procedureList[ toto ].end(); ++ins )
+// {
+// dgDEBUG(15) << "Proc <" << procName << "> : "
+// << ins->cmd << " -> " << ins->args <<endl;
+// }
+
+ currentProc.clear();
+
+ if( g_shell.deregisterFunction( procName ))
+ { os<< "Redefining proc <"<<procName<<">: procedure already defined. "
+ << "Overwrite it."<<endl; }
+ ShellFunctionRegisterer registration
+ ( procName.c_str(),boost::bind(&ShellProcedure::cmdProcedure,
+ this,procName,_1,_2,_3) );
+
+}
+
+void ShellProcedure::
+cmdProcedure( const std::string& procname,
+ const std::string& cmdLine,std::istringstream& args,std::ostream& os )
+{
+ if( cmdLine == "help" )
+ {
+ os<<" - "<<procname<<"\t\t\t\t\tUser-defined procedure"<<endl;
+ args >> ws;
+ if( args.good() )
+ {
+ std::string argname;
+ const unsigned int gc = args.tellg();
+ args >> argname;
+ args.seekg(gc); args.clear();
+ if( procname==argname )
+ {
+ /* if cmdline = "Help <procname>", then display
+ * the proc instruction. */
+ ProcedureList::iterator pair = procedureList.find( argname );
+ if( pair==procedureList.end() )
+ {
+ DG_THROW ExceptionFactory( ExceptionFactory::UNREFERED_FUNCTION,
+ "Undefined procedure",
+ ": procedure <%s> not defined.",
+ argname.c_str() );
+ }
+
+ Procedure & proc = pair->second;
+ unsigned int cmdnum=1;
+ for( std::list<Instruction>::iterator ins=proc.instructions.begin();
+ ins!=proc.instructions.end(); ++ins )
+ {
+ os<<"\t#" <<cmdnum++<<" "<<ins->cmd; // <<" "<<ins->args <<endl;
+ for( unsigned int i=0;i<ins->args.size();++i )
+ { os << " " << ins->args[i]; }
+ os << endl;
+ }
+
+ }
+ }
+ return;
+ }
+
+
+ dgDEBUG(15) << " Calling procedure <" <<cmdLine<<"> " <<endl;
+ ProcedureList::iterator pair = procedureList.find( cmdLine );
+ if( pair==procedureList.end() )
+ {
+ DG_THROW ExceptionFactory( ExceptionFactory::UNREFERED_FUNCTION,
+ "Undefined procedure",
+ ": procedure <%s> not defined.",cmdLine.c_str() );
+ }
+
+ /* You need a copy here, in case the proc is removed from the
+ * list by itself:
+ * % proc next
+ * % -> proc next
+ * % -> -> echo TOTO
+ * % -> endproc
+ * % endproc
+ */
+ Procedure proc = pair->second;
+
+ std::vector< std::string > paramValue;
+ for( unsigned int i=0;i<proc.params.size();++i )
+ {
+ args>>ws;
+ if( args.good() )
+ {
+ std::string next; args>>next>>ws;
+ paramValue.push_back( next );
+ dgDEBUG(25) << "Args : <" << next << ">"<<endl;
+ }
+ else { paramValue.push_back(""); }
+ }
+
+ istringstream iss; ostringstream oss;
+ for( std::list<Instruction>::iterator ins=proc.instructions.begin();
+ ins!=proc.instructions.end(); ++ins )
+ {
+ dgDEBUG(15) << "Proc <" << cmdLine << "> : " << ins->cmd << endl;
+ oss.clear(); oss.str("");
+ for( unsigned int i=0;i<ins->params.size();++i )
+ {
+ int paramArg = ins->params[i];
+ if( paramArg==-1 ) oss << ins->args[i] << " ";
+ else oss << paramValue[paramArg] << " ";
+ }
+
+ dgDEBUG(15) << " Args = " << oss.str() << endl;
+ iss.str(oss.str()); iss.clear();
+ g_shell.cmd(ins->cmd,iss,os);
+ }
+}
+
+void ShellProcedure::
+cmdFor( const std::string& cmdLine,std::istringstream& args,std::ostream& os )
+{
+ if( cmdLine == "help" )
+ {
+ os << " - for 1 5 instruction "<<endl;
+ return;
+ }
+
+ std::string cmd2,idx;
+ int istart,iend;
+
+ {
+ stringstream oss;
+
+ args >> cmd2; oss.str( cmd2 );
+ const unsigned int SIZE = 32; char b1[SIZE],b2[SIZE],b3[SIZE];
+ oss.getline( b1,SIZE,'=' );
+ oss.getline( b2,SIZE,':' );
+ oss.getline( b3,SIZE );
+ dgDEBUG(15) << b1 << "/" << b2 << "/" << b3 << endl;
+
+ idx = b1; istart = atoi(b2); iend = atoi(b3);
+ args >> cmd2;
+
+ dgDEBUG(15) << "FOR <" << idx << "> = " << istart << " TO " << iend
+ << " DO " << cmd2 <<endl;
+ }
+
+ string argsstr;
+ {
+ const unsigned int SIZE = 1024; char buffer[SIZE];
+ args.getline( buffer,SIZE );
+ argsstr = buffer;
+ }
+ for( int i=istart;i<=iend;++i )
+ {
+ istringstream iss; stringstream oss;
+
+ std::string insp;
+ istringstream issargs( argsstr );
+ while( issargs.good() )
+ {
+ issargs >> insp;
+ if( insp == idx ) { oss << i << " "; } else { oss<<insp<< " "; }
+ }
+ iss.str( oss.str() );
+ g_shell.cmd(cmd2,iss,os);
+ }
+}
+
+ShellProcedure sotShellProceduror;
+
+extern "C" {
+ ShellFunctionRegisterer regFun1
+ ( "proc",boost::bind(&ShellProcedure::cmdStartProcedure,
+ &sotShellProceduror,_1,_2,_3) );
+
+ ShellFunctionRegisterer regFun2
+ ( "->",boost::bind(&ShellProcedure::cmdContinueProcedure,
+ &sotShellProceduror,_1,_2,_3) );
+ ShellFunctionRegisterer regFun3
+ ( "endproc",boost::bind(&ShellProcedure::cmdEndProcedure,
+ &sotShellProceduror,_1,_2,_3) );
+
+ ShellFunctionRegisterer regFun4
+ ( "for",boost::bind(&ShellProcedure::cmdFor,
+ _1,_2,_3) );
+}
+