ScriptInterpreter.h

Go to the documentation of this file.

#pragma once
#include <misc/gen/ElapseTimer.h>
#include <misc/gen/ScriptEngine.h>
#include <misc/gen/TListener.h>
#include <misc/global.h>
 
namespace sf
{
 
class _MISC_CLASS ScriptInterpreter : public ScriptEngine
{
  public:
    typedef TListener<const ScriptInterpreter*> ChangeListener;
 
    ScriptInterpreter();
 
    ~ScriptInterpreter() override;
 
    ChangeListener::emitter_type& getChangeEmitter()
    {
      return _emitterChange;
    }
 
    [[nodiscard]] std::string getScriptName() const;
 
    void setScriptName(const std::string& name);
 
    void setOutputStream(std::ostream* os);
 
    enum EState
    {
      esError = 0,
      esEmpty,
      esCompiled,
      esRunning,
      esReady,
      esCurrent
    };
 
    enum EExecMode
    {
      emInit,
      emRun,
      emStart,
      emStep,
      emAbort,
    };
 
    struct CodePos
    {
        CodePos() = default;
 
        CodePos(pos_type line, pos_type offset)
          : _line(line)
          , _offset(offset)
        {}
 
        pos_type _line{0};
        pos_type _offset{0};
    };
 
    EState Execute(EExecMode exec_mode = emRun);
 
    bool compile(const char* cmd);
 
    [[nodiscard]] const char* getStateName(EState exec_state = esCurrent) const;
 
    [[nodiscard]] EState getState() const;
 
    [[nodiscard]] std::string getDebugText() const;
 
    [[nodiscard]] CodePos getErrorPos() const;
 
    [[nodiscard]] ip_type getInstructionPtr() const;
 
    [[nodiscard]] ip_type getErrorInstructionPtr() const;
 
    [[nodiscard]] std::string getInstructionText(ip_type ip) const;
 
    void flush();
 
    bool callFunction(const std::string& name, bool step_mode);
 
    void callFunction(ip_type ip, bool step_mode);
 
    void setMaxLoopTime(unsigned long usec);
 
    // Overloaded from base class.
    [[nodiscard]] strings getInfoNames() const override;
 
    [[nodiscard]] const IdInfo* getInfo(const std::string& name) const override;
 
    struct _MISC_CLASS Instruction
    {
        enum EInstr
        {
          eiGoto = -3,
          eiContinue = -2,
          eiBreak = -1,
          eiNone = 0,
          eiCalculate,
          eiTestJump,
          eiJump,
          eiCall,
          eiRetFunction,
          eiLastEntry
        };
 
        Instruction() = default;
 
        Instruction(EInstr instr, ip_type ip, const CodePos& pos, std::string script = std::string());
 
        EInstr _instr{eiNone};
        CodePos _codePos{0, 0};
        std::string _script{};
        ip_type _absIp{-1};
 
        [[nodiscard]] const char* getMnemonic() const;
 
        [[nodiscard]] ip_type getJumpIp() const;
    };
 
    struct VariableInfo;
    struct LabelInfo;
 
    [[nodiscard]] const TVector<Instruction>& getInstructions() const
    {
      return _instructions;
    }
 
    [[nodiscard]] const TVector<VariableInfo*>& getVariables() const
    {
      return _variables;
    }
 
    [[nodiscard]] strings getIdentifiers(EIdentifier id) const override;
 
    [[nodiscard]] bool isStepMode() const;
 
  protected:
    enum EExitCode
    {
      ecNormal = 0,
      ecError,
      ecScript,
      ecApplication,
    };
 
    enum EKeyWord
    {
      kwNone = 0,
      kwIf,
      kwWhile,
      kwElse,
      kwGoto,
      kwBreak,
      kwContinue,
      kwSubroutine,
      kwReturn,
      kwExternal,
      kwExtern,
    };
 
    bool getSetValue(const IdInfo* info, Value* value, Value::vector_type* params, bool flag_set) override;
 
    virtual bool compileAdditionalStatement(const IdInfo* info, const std::string& source);
 
    virtual void exitFunction(EExitCode exitcode, const Value& value);
 
    virtual void clear();
 
    virtual void linkInstruction();
 
    void setState(EState exec_state);
 
    ip_type getLabelIp(const std::string& name);
 
    ElapseTimer _loopTimer;
    std::ostream* _outputStream{nullptr};
 
  private:
    void getExternalSource(std::string& source);
 
    ip_type addInstruction(Instruction::EInstr instr, ip_type ip, pos_type pos, const std::string& script = std::string());
 
    void setJumpInstruction(ip_type ip, ip_type jmp_ip = -1);
 
    void setBreakInstruction(ip_type start_ip, ip_type jmp_ip);
 
    void setContinueInstruction(ip_type start_ip, ip_type jmp_ip);
 
    void skipWhite();
 
    void setPosition(pos_type pos);
 
    bool getName(std::string& name);
 
    bool doCompile();
 
    bool compileKeyword(const IdInfo* Info, pos_type pos);
 
    void doStep();
 
    void doExecute();
 
    bool isKeyWord(EKeyWord keyword);
 
    const char* getKeyWordText(EKeyWord keyword);
 
    bool getScript(std::string& script, char ending);
 
    void getVarScript(std::string& script);
 
    std::string getProfilePath();
 
    const EState _currentState{esEmpty};
    EState _prevState{esEmpty};
    Value _accumulator{};
    const char* _command;
    pos_type _codePos{0};
    pos_type _codeLine{0};
    bool _flagSentry{false};
    bool _flagStepMode{false};
    TVector<Instruction> _instructions{};
    ip_type _currentInstructionPtr{-1};
    ip_type _errorInstructionPtr{-1};
    ip_type _mainFunction{-1};
 
    struct _MISC_CLASS StackEntry
    {
        explicit StackEntry(ip_type ip)
        {
          _ip = ip;
        }
 
        ip_type _ip{0};
    };
 
    TVector<StackEntry> _stack;
    TVector<VariableInfo*> _variables;
    TVector<LabelInfo*> _labels;
    ElapseTimer _sleepTimer;
    std::string _scriptName;
    Value::int_type _trace{0};
    static IdInfo _info[];
    static const char* _instructionNames[];
    static const char* _stateNames[];
    static const char* _exitCodeNames[];
 
    ChangeListener::emitter_type _emitterChange;
};
 
}// namespace sf