// execute one line of code (commands and statements)
DInterpreter::CommandCode DInterpreter::ExecuteLine( istream* in, SizeT lineOffset)
{
string line = (in != NULL) ? ::GetLine(in) : GetLine();
// cout << "ExecuteLine: " << line << endl;
string firstChar = line.substr(0,1);
// command
if( firstChar == ".")
{
return ExecuteCommand( line.substr(1));
}
// online help (if possible, start a browser)
if( firstChar == "?")
{
// later, we will have to check whether we have X11/Display or not
// on some computing nodes on supercomputers, this is de-activated.
if (line.substr(1).length() > 0) {
line=line.substr(1);
StrTrim(line);
line="online_help, '"+line+"'"; //'
} else {
line="online_help";
}
}
// shell command
if( firstChar == "#")
{
if (line.substr(1).length() > 0) {
line=line.substr(1);
StrTrim(line);
line=StrUpCase(line);
//cout << "yes ! >>"<<StrUpCase(line)<<"<<" << endl;
SizeT nProFun;
int nbFound=0;
// looking in internal procedures
nProFun=libProList.size();
for( SizeT i = 0; i<nProFun; ++i)
{
if (line.compare(libProList[ i]->Name()) == 0) {
cout << "Internal PROCEDURE : " << libProList[ i]->ToString() << endl;
nbFound++;
break;
}
}
// looking in internal functions
nProFun = libFunList.size();
for( SizeT i = 0; i<nProFun; ++i)
{
if (line.compare(libFunList[ i]->Name()) == 0) {
cout << "Internal FUNCTION : " << libFunList[ i]->ToString() << endl;
nbFound++;
break;
}
}
// looking in compiled functions
nProFun = funList.size();
for( SizeT i = 0; i<nProFun; ++i)
{
if (line.compare(funList[ i]->Name()) == 0) {
cout << "Compiled FUNCTION : " << funList[ i]->ToString() << endl;
nbFound++;
break;
}
}
// looking in compiled procedures
nProFun = proList.size();
for( SizeT i = 0; i<nProFun; ++i)
{
if (line.compare(proList[ i]->Name()) == 0) {
cout << "Compiled PROCEDURE : " << proList[ i]->ToString() << endl;
nbFound++;
break;
}
}
if (nbFound == 0) {
cout << "No Procedure/Function, internal or compiled, with name : "<< line << endl;
}
} else {
cout << "Please provide a pro/fun name !" << endl;
}
return CC_OK;
}
// shell command
if( firstChar == "$")
{
ExecuteShellCommand( line.substr(1));
return CC_OK;
}
// include (only when at $MAIN$)
// during compilation this is handled by the interpreter
if( firstChar == "@" && callStack.size() <= 1)
{
string fileRaw = line.substr(1);
StrTrim( fileRaw);
string file = fileRaw;
AppendExtension( file);
bool found = CompleteFileName( file);
if( !found)
{
file = fileRaw;
CompleteFileName( file);
}
ExecuteFile( file);
return CC_OK;
}
// statement -> execute it
executeLine.clear(); // clear EOF (for executeLine)
executeLine.str( line + "\n"); // append new line
RefDNode theAST;
try {
Guard<GDLLexer> lexer;
// LineContinuation LC
// conactenate the strings and insert \n
// the resulting string can be fed to the lexer
// print if expr parse ok
int lCNum = 0;
for(;;)
{
lexer.Reset( new GDLLexer(executeLine, "", callStack.back()->CompileOpt()));
try {
// works, but ugly -> depends from parser detecting an error
// (which it always will due to missing END_U token in case of LC)
//lexer->Parser().SetCompileOpt(callStack.back()->CompileOpt());
lexer.Get()->Parser().interactive();
break; // no error -> everything ok
}
catch( GDLException& e)
{
int lCNew = lexer.Get()->LineContinuation();
if( lCNew == lCNum)
// throw; // no LC -> real error
{
#ifdef AUTO_PRINT_EXPR
#ifndef GDL_DEBUG
try {
// executeLine.clear(); // clear EOF (for executeLine)
// lexer.reset( new GDLLexer(executeLine, "", callStack.back()->CompileOpt()));
// lexer->Parser().expr();
executeLine.clear(); // clear EOF (for executeLine)
executeLine.str( "print," + executeLine.str()); // append new line
lexer.reset( new GDLLexer(executeLine, "", callStack.back()->CompileOpt()));
lexer->Parser().interactive();
break; // no error -> everything ok
}
catch( GDLException& e2)
#endif
#endif
{
throw e;
}
}
lCNum = lCNew; // save number to see if next line also has LC
}
// line continuation -> get next line
if( in != NULL && !in->good())
throw GDLException( "End of file encountered during line continuation.");
string cLine = (in != NULL) ? ::GetLine(in) : GetLine();
executeLine.clear(); // clear EOF (for executeLine)
executeLine.str( executeLine.str() + cLine + "\n"); // append new line
}
// lexer->Parser().interactive();
theAST = lexer.Get()->Parser().getAST();
}
catch( GDLException& e)
{
ReportCompileError( e);
return CC_OK;
}
catch( ANTLRException& e)
{
cerr << "Lexer/Parser exception: " << e.getMessage() << endl;
return CC_OK;
}
if( theAST == NULL) return CC_OK;
// consider line offset
if( lineOffset > 0)
AddLineOffset( lineOffset, theAST);
#ifdef GDL_DEBUG
antlr::print_tree pt;
cout << "Parser output:" << endl;
pt.pr_tree(static_cast<antlr::RefAST>(theAST));
cout << "ExecuteLine: Parser end." << endl;
#endif
ProgNodeP progAST = NULL;
RefDNode trAST;
assert( dynamic_cast<EnvUDT*>(callStack.back()) != NULL);
EnvUDT* env = static_cast<EnvUDT*>(callStack.back());
int nForLoopsIn = env->NForLoops();
try
{
GDLTreeParser treeParser( callStack.back());
treeParser.interactive(theAST);
trAST=treeParser.getAST();
if( trAST == NULL)
{
// normal condition for cmd line procedure calls
return CC_OK;
}
#ifdef GDL_DEBUG
cout << "Tree parser output (RefDNode):" << endl;
pt.pr_tree(static_cast<antlr::RefAST>(trAST));
cout << "ExecuteLine: Tree parser end." << endl;
#endif
// **************************************
// this is the call of the ProgNode factory
// **************************************
progAST = ProgNode::NewProgNode( trAST);
assert( dynamic_cast<EnvUDT*>(callStack.back()) != NULL);
EnvUDT* env = static_cast<EnvUDT*>(callStack.back());
int nForLoops = ProgNode::NumberForLoops( progAST, nForLoopsIn);
env->ResizeForLoops( nForLoops);
}
catch( GDLException& e)
{
env->ResizeForLoops( nForLoopsIn);
ReportCompileError( e);
return CC_OK;
}
catch( ANTLRException& e)
{
env->ResizeForLoops( nForLoopsIn);
cerr << "Compiler exception: " << e.getMessage() << endl;
return CC_OK;
}
Guard< ProgNode> progAST_guard( progAST);
try
{
#ifdef GDL_DEBUG
cout << "Converted tree (ProgNode):" << endl;
pt.pr_tree( progAST);
cout << "end." << endl;
#endif
RetCode retCode = interactive( progAST);
env->ResizeForLoops( nForLoopsIn);
// write to journal file
string actualLine = GetClearActualLine();
if( actualLine != "") lib::write_journal( actualLine);
if( retCode == RC_RETURN) return CC_RETURN;
return CC_OK;
}
catch( GDLException& e)
{
env->ResizeForLoops( nForLoopsIn);
cerr << "Unhandled GDL exception: " << e.toString() << endl;
return CC_OK;
}
catch( ANTLRException& e)
{
env->ResizeForLoops( nForLoopsIn);
cerr << "Interpreter exception: " << e.getMessage() << endl;
return CC_OK;
}
return CC_OK;
}
