Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
tree: f60b3e3090
Fetching contributors…

Cannot retrieve contributors at this time

659 lines (581 sloc) 16.066 kB
#ifndef INCLUDE_BLASSIC_RUNNER_H
#define INCLUDE_BLASSIC_RUNNER_H
// runner.h
// Revision 6-feb-2005
//#include "program.h"
class Program;
#include "blassic.h"
#include "error.h"
#include "file.h"
#include "codeline.h"
#include "var.h"
#include "element.h"
//#include "runnerline.h"
#include <iostream>
#include <stack>
#include <vector>
#include <map>
// ********************* GlobalRunner **********************
namespace blassic {
namespace onbreak {
enum BreakState { BreakStop, BreakCont, BreakGosub };
} // namespace onbreak
} // namespace blassic
enum TrigonometricMode { TrigonometricRad, TrigonometricDeg };
// We encapsulate the random generator in a class to have all code
// related to it in a place, and to be able to change it easily.
// random in some systems may not use the RAND_MAX value,
// then we use it only in linux.
class RandomGenerator {
public:
BlNumber operator () ()
{
#if defined __linux__
return BlNumber (random () ) / (RAND_MAX + 1.0);
#else
return BlNumber (rand () ) / (RAND_MAX + 1.0);
#endif
}
void seed (unsigned int value)
{
#if defined __linux__
srandom (value);
#else
srand (value);
#endif
}
};
class GlobalRunner {
public:
GlobalRunner (Program & prog);
~GlobalRunner ();
// Program
private:
Program & program;
public:
Program & getprogram () { return program; }
// TRON stuff
private:
bool fTron, fTronLine;
BlChannel blcTron;
void do_tronline (const CodeLine & line);
public:
void tron (bool fLine, BlChannel blc);
void troff ();
void tronline (const CodeLine & codeline)
{
if (fTron)
do_tronline (codeline);
}
// GlobalRunner Channel stuff
public:
typedef std::map <BlChannel, blassic::file::BlFile *> ChanFile;
typedef std::map <BlChannel, BlLineNumber> ChanPolled;
private:
ChanFile chanfile;
ChanPolled chanpolled;
bool alreadypolled;
bool clearingpolled;
public:
bool assign_channel_var
(const std::string & var, const Dimension & dim,
const std::string & value,
blassic::file::BlFile::Align align);
bool assign_mid_channel_var
(const std::string & var, const Dimension & dim,
const std::string & value,
size_t inipos, std::string::size_type len);
bool isfileopen (BlChannel channel) const
{ return chanfile.find (channel) != chanfile.end (); }
BlChannel freefile () const;
blassic::file::BlFile & getfile (BlChannel channel) const;
void setfile (BlChannel channel, blassic::file::BlFile * npfile);
void resetfile0 ();
void resetfileprinter ();
void close_all ();
void destroy_windows ();
void closechannel (BlChannel channel);
void windowswap (BlChannel ch1, BlChannel ch2);
void pollchannel (BlChannel ch, BlLineNumber line);
bool channelspolled ();
BlLineNumber getpollnumber ();
void setpolled ();
void clearpolled ();
// GlobalRunner DATA / READ / RESTORE stuff
private:
BlLineNumber datanumline;
BlChunk datachunk;
unsigned short dataelem;
public:
BlLineNumber & getdatanumline () { return datanumline; }
BlChunk & getdatachunk () { return datachunk; }
unsigned short & getdataelem () { return dataelem; }
void setreadline (BlLineNumber bln)
{
datanumline= bln;
datachunk= 0;
dataelem= 0;
}
void clearreadline ()
{
datanumline= LineBeginProgram;
datachunk= 0;
dataelem= 0;
}
// GlobalRunner ON ERROR GOTO stuff.
private:
BlLineNumber blnErrorGoto;
BlLineNumber blnErrorGotoSource;
public:
void clearerrorgoto ();
void seterrorgoto (BlLineNumber line, BlLineNumber source);
BlLineNumber geterrorgoto () const
{ return blnErrorGoto; }
BlLineNumber geterrorgotosource () const
{ return blnErrorGotoSource; }
// GlobalRunner ON BREAK
private:
blassic::onbreak::BreakState breakstate;
BlLineNumber breakgosubline;
public:
void setbreakstate (blassic::onbreak::BreakState newstate)
{
breakstate= newstate;
}
blassic::onbreak::BreakState getbreakstate () const
{ return breakstate; }
void setbreakgosub (BlLineNumber bln)
{
breakstate= blassic::onbreak::BreakGosub;
breakgosubline= bln;
}
BlLineNumber getbreakgosub () { return breakgosubline; }
// Control of depth of fn calls.
private:
size_t fn_current_level;
public:
size_t fn_level () const { return fn_current_level; }
void inc_fn_level ();
void dec_fn_level ();
// Trigonometric mode.
private:
TrigonometricMode trigmode;
public:
TrigonometricMode trigonometric_mode () const { return trigmode; }
void trigonometric_default () { trigmode= TrigonometricRad; }
void trigonometric_mode (TrigonometricMode trigmode_n)
{ trigmode= trigmode_n; }
// Random number generator.
private:
RandomGenerator randgen;
public:
BlNumber getrandom () { return randgen (); }
void seedrandom (unsigned int value) { randgen.seed (value); }
};
// ********************* Runner **********************
class GosubStack {
private:
GlobalRunner & globalrunner;
typedef std::stack <GosubElement> st_t;
st_t st;
public:
typedef st_t::size_type size_type;
public:
GosubStack (GlobalRunner & globalrunner);
~GosubStack ();
bool empty () const
{
return st.empty ();
}
size_type size () const
{
return st.size ();
}
void check_fn () const
{
if (st.empty () )
throw ErrUnexpectedFnEnd;
if (st.top ().isgosub () )
throw ErrGosubWithoutReturn;
}
void erase ();
void push (ProgramPos pos, bool is_polled)
{
st.push (GosubElement (pos, is_polled) );
if (is_polled)
globalrunner.setpolled ();
}
void push (LocalLevel & ll)
{
st.push (GosubElement (ll) );
}
void pop (ProgramPos & ppos)
{
if (st.empty () )
throw ErrReturnWithoutGosub;
GosubElement & go= st.top ();
if (! go.isgosub () )
throw ErrReturnWithoutGosub;
ppos= go.getpos ();
go.freelocalvars ();
if (go.ispolled () )
globalrunner.clearpolled ();
st.pop ();
}
void popfn ()
{
if (st.empty () )
throw ErrReturnWithoutGosub;
GosubElement & go= st.top ();
if (go.isgosub () )
throw ErrGosubWithoutReturn;
go.freelocalvars ();
st.pop ();
}
void addlocalvar (const std::string & name)
{
if (st.empty () )
throw ErrMisplacedLocal;
GosubElement go= st.top ();
go.addlocalvar (name);
}
};
class Runner {
public:
enum RunnerStatus {
Ended,
FnEnded,
ReadyToRun,
Running,
Stopped,
Jump,
Goto,
//InitingCommand,
//Command,
JumpResumeNext,
LastStatus= JumpResumeNext,
};
private:
enum StatusRun { KeepRunning, StopNow };
typedef StatusRun (Runner::* checkstatusfunc)
(CodeLine &, const CodeLine &);
static checkstatusfunc checkstatus [LastStatus + 1];
StatusRun checkstatusEnded
(CodeLine & line, const CodeLine & line0);
StatusRun checkstatusFnEnded
(CodeLine & line, const CodeLine & line0);
StatusRun checkstatusReadyToRun
(CodeLine & line, const CodeLine & line0);
StatusRun checkstatusRunning
(CodeLine & line, const CodeLine & line0);
StatusRun checkstatusStopped
(CodeLine & line, const CodeLine & line0);
StatusRun checkstatusJump
(CodeLine & line, const CodeLine & line0);
StatusRun checkstatusGoto
(CodeLine & line, const CodeLine & line0);
//StatusRun checkstatusInitingCommand
// (CodeLine & line, const CodeLine & line0);
//StatusRun checkstatusCommand
// (CodeLine & line, const CodeLine & line0);
StatusRun checkstatusJumpResumeNext
(CodeLine & line, const CodeLine & line0);
bool is_run_status (CodeLine & line, const CodeLine & line0);
GlobalRunner & globalrunner;
Program & program;
RunnerStatus status;
bool fInElse;
bool fInWend;
public:
//Runner (Program & prog);
Runner (GlobalRunner & gr);
Runner (const Runner & runner);
~Runner ();
Program & getprogram () { return program; }
void clear ();
void getline (std::string & line);
void runline_catch (const CodeLine & codeline, ProgramPos pos,
BlError & berr, bool & endloop, bool & dobreak);
void runline (const CodeLine & codeline0);
void run ();
bool editline (BlLineNumber bln, std::string & str);
void interactive ();
// Runner *********** Errors **************
private:
BlCode codprev;
BlError berrLast;
public:
BlErrNo geterr () const;
ProgramPos geterrpos () const;
BlLineNumber geterrline () const;
void clearerror ();
BlError geterror () const;
void seterror (const BlError & er);
// Runner *********** Flow control **************
private:
ProgramPos posgoto;
public:
void setstatus (RunnerStatus stat) { status= stat; }
void run_to (BlLineNumber line)
{
posgoto= line;
status= ReadyToRun;
}
void run_to (ProgramPos pos)
{
posgoto= pos;
status= ReadyToRun;
}
void jump_to (BlLineNumber line)
{
posgoto= line;
status= Jump;
}
void jump_to (ProgramPos pos)
{
posgoto= pos;
status= Jump;
}
void goto_to (BlLineNumber line)
{
posgoto= line;
status= Goto;
}
void goto_to (ProgramPos pos)
{
posgoto= pos;
status= Goto;
}
void resume_next (ProgramPos pos)
{
posgoto= pos;
status= JumpResumeNext;
}
// Runner *********** FOR / NEXT **************
private:
std::stack <ForElement *, std::vector <ForElement *> > forstack;
public:
void push_for (ForElement * pfe)
{
forstack.push (pfe);
}
//bool for_empty () const { return forstack.empty (); }
ForElement & for_top ()
{
if (forstack.empty () )
throw ErrNextWithoutFor;
return * forstack.top ();
}
void for_pop () { delete forstack.top (); forstack.pop (); }
// New version, supposed faster.
bool next ();
bool next (const std::string & varname);
// Runner *********** GOSUB / RETURN / FN **************
private:
GosubStack gosubstack;
public:
bool gosub_empty () const
{ return gosubstack.empty (); }
size_t gosub_size () const
{ return gosubstack.size (); }
void gosub_check_fn () const
{ gosubstack.check_fn (); }
void gosub_pop (ProgramPos & pos)
{ gosubstack.pop (pos); }
void fn_pop () { gosubstack.popfn (); }
void gosub_addlocalvar (const std::string & str)
{
gosubstack.addlocalvar (str);
}
void gosub_push (LocalLevel & ll)
{
gosubstack.push (ll);
}
void gosub_line (BlLineNumber dest, ProgramPos posgosub,
bool is_polled= false)
{
gosubstack.push (posgosub, is_polled);
goto_to (dest);
}
size_t fn_level () const { return globalrunner.fn_level (); }
void inc_fn_level ()
{ globalrunner.inc_fn_level (); }
void dec_fn_level ()
{ globalrunner.dec_fn_level (); }
// Runner *********** REPEAT / UNTIL **************
private:
std::stack <RepeatElement> repeatstack;
public:
bool repeat_empty () const { return repeatstack.empty (); }
void repeat_pop () { repeatstack.pop (); }
RepeatElement & repeat_top () { return repeatstack.top (); }
void repeat_push (const RepeatElement & re) { repeatstack.push (re); }
// Runner *********** WHILE / WEND **************
private:
std::stack <WhileElement> whilestack;
public:
bool in_wend () { return fInWend; }
void in_wend (bool f) { fInWend= f; }
bool while_empty () { return whilestack.empty (); }
void while_pop () { whilestack.pop (); }
WhileElement & while_top () { return whilestack.top (); }
void while_push (const WhileElement & we) { whilestack.push (we); }
// Runner *********** TRON **************
void tron (bool fLine, BlChannel blc);
void troff ();
void tronline (const CodeLine & line)
{ globalrunner.tronline (line); }
// Runner *********** BREAK / CONT **************
private:
ProgramPos posbreak;
public:
void jump_break ()
{
//if (! posbreak)
if (posbreak.getnum () == LineEndProgram ||
posbreak.getnum () == LineDirectCommand)
throw ErrNoContinue;
posgoto= posbreak;
//posbreak= 0;
posbreak= LineEndProgram;
status= Jump;
}
void set_break (ProgramPos pos) { posbreak= pos; }
#if 0
void setbreakstate (BreakState newstate)
{
breakstate= newstate;
}
BreakState getbreakstate () { return breakstate; }
void setbreakgosub (BlLineNumber bln)
{
breakstate= BreakGosub;
breakgosubline= bln;
}
BlLineNumber getbreakgosub () { return breakgosubline; }
#else
void setbreakstate (blassic::onbreak::BreakState newstate)
{
globalrunner.setbreakstate (newstate);
}
blassic::onbreak::BreakState getbreakstate () const
{
return globalrunner.getbreakstate ();
}
void setbreakgosub (BlLineNumber bln)
{
globalrunner.setbreakgosub (bln);
}
BlLineNumber getbreakgosub ()
{
return globalrunner.getbreakgosub ();
}
#endif
// Runner *********** DATA / READ / RESTORE **************
BlLineNumber & getdatanumline ()
{ return globalrunner.getdatanumline (); }
BlChunk & getdatachunk ()
{ return globalrunner.getdatachunk (); }
unsigned short & getdataelem ()
{ return globalrunner.getdataelem (); }
// Runner *********** ON ERROR GOTO **************
void showfailerrorgoto () const;
void clearerrorgoto ()
{ globalrunner.clearerrorgoto (); }
void seterrorgoto (BlLineNumber line, BlLineNumber source)
{ globalrunner.seterrorgoto (line, source); }
BlLineNumber geterrorgoto () const
{ return globalrunner.geterrorgoto (); }
BlLineNumber geterrorgotosource () const
{ return globalrunner.geterrorgotosource (); }
// Runner *********** Channels **************
#if 0
void assign_channel_var
(const std::string & var, const std::string & value,
blassic::file::BlFile::Align align)
{
for (ChanFile::iterator it= chanfile.begin ();
it != chanfile.end ();
++it)
{
it->second->assign (var, value, align);
}
}
#else
bool assign_channel_var
(const std::string & var, const Dimension & dim,
const std::string & value,
blassic::file::BlFile::Align align)
{ return globalrunner.assign_channel_var (var, dim, value, align); }
#endif
bool assign_mid_channel_var
(const std::string & var, const Dimension & dim,
const std::string & value,
size_t inipos, std::string::size_type len)
{
return globalrunner.assign_mid_channel_var
(var, dim, value, inipos, len);
}
//bool isfileopen (BlChannel channel) const
//{ return chanfile.find (channel) != chanfile.end (); }
bool isfileopen (BlChannel channel) const
{ return globalrunner.isfileopen (channel); }
BlChannel freefile () const
{ return globalrunner.freefile (); }
blassic::file::BlFile & getfile (BlChannel channel) const
{ return globalrunner.getfile (channel); }
blassic::file::BlFile & getfile0 () const
{ return globalrunner.getfile (DefaultChannel); }
void setfile (BlChannel channel, blassic::file::BlFile * npfile)
{ globalrunner.setfile (channel, npfile); }
void resetfile0 ()
{ globalrunner.resetfile0 (); }
void close_all ()
{ globalrunner.close_all (); }
void destroy_windows ()
{ globalrunner.destroy_windows (); }
void closechannel (BlChannel channel)
{ globalrunner.closechannel (channel); }
void windowswap (BlChannel ch1, BlChannel ch2)
{ globalrunner.windowswap (ch1, ch2); }
void pollchannel (BlChannel ch, BlLineNumber line)
{ globalrunner.pollchannel (ch, line); }
bool channelspolled ()
{ return globalrunner.channelspolled (); }
BlLineNumber getpollnumber ()
{ return globalrunner.getpollnumber (); }
void spectrumwindows ();
// Runner *********** DATA / READ / RESTORE **************
void setreadline (BlLineNumber bln)
{ globalrunner.setreadline (bln); }
void clearreadline ()
{ globalrunner.clearreadline (); }
// Runner *********** AUTO **************
private:
BlLineNumber blnAuto, blnAutoInc;
public:
void setauto (BlLineNumber line, BlLineNumber inc)
{ blnAuto= line; blnAutoInc= inc; }
// Runner *********** Trigonometric mode **************
TrigonometricMode trigonometric_mode ()
{ return globalrunner.trigonometric_mode (); }
void trigonometric_default ()
{ globalrunner.trigonometric_default (); }
void trigonometric_mode (TrigonometricMode trigmode_n)
{ globalrunner.trigonometric_mode (trigmode_n); }
private:
bool processline (const std::string & line);
public:
// Runner *********** Random number generator **************
BlNumber getrandom ()
{ return globalrunner.getrandom (); }
void seedrandom (unsigned int value)
{ globalrunner.seedrandom (value); }
// Runner *********** Auxiliars **************
void clean_input ();
void ring ();
void set_title (const std::string & str);
};
std::ostream & operator << (std::ostream & os, Runner::RunnerStatus status);
#endif
// Fin de runner.h
Jump to Line
Something went wrong with that request. Please try again.