#include <ctype.h>
#include <stdlib.h>

#include <automask.h>
#include <colors.h>
#include <dongle.h>
#include <prefix.h>
#include "ba8303.h"
#include "ba8304.h"

TVariant& TVariant_stack::peek(int depth)
{
  const int sp = _sp-depth-1;
  return sp >= 0 ? (TVariant&)_var[sp] : NULL_VARIANT;
}

bool TVariant_stack::drop()
{
  if (_sp > 0)
  {
    _sp--;
    return true;
  }
  return false;
}

TVariant& TVariant_stack::pop()
{
  TVariant& var = peek(0);
  drop();
  return var;
}

void TVariant_stack::roll(int depth)
{
  const int sp = _sp-depth-1;
  if (sp >= 0)
  {
    TObject* var = _var.remove(sp, true);
    _var.insert(var, _sp-1);
  }
}

bool TVariant_stack::push(const TVariant& var)
{
  if (_var.objptr(_sp) == NULL)
    _var.add(var, _sp);
  else
    (TVariant&)_var[_sp] = var;
  _sp++;
  return _sp < 1024;
}

bool TVariant_stack::push(long n)
{
  const TVariant var(n);
  return push(var);
}

bool TVariant_stack::push(const real& n)
{
  const TVariant var(n);
  return push(var);
}

bool TVariant_stack::push(const TString& str)
{
  const TVariant var(str);
  return push(var);
}


void TVariant_stack::reset()
{
  _sp = 0;
}

///////////////////////////////////////////////////////////
// TAVM_op
///////////////////////////////////////////////////////////

enum AVM_opcode 
{ 
  avm_nop, 
  avm_add, avm_and, 
  avm_begin,
  avm_call_word, avm_cold,
  avm_cmp_eq, avm_cmp_gt, avm_cmp_gteq, avm_cmp_lt, avm_cmp_lteq, avm_cmp_noteq, 
  avm_div, avm_divide, avm_do, avm_dot, avm_drop, avm_dup, 
  avm_else,
  avm_false, avm_fetch, avm_fload,
  avm_i, avm_if, 
  avm_j,
  avm_loop,
  avm_mod, avm_mon, avm_mul,
  avm_negate,
  avm_or, avm_over, 
  avm_perform, avm_pick, avm_plus_loop, avm_push, 
  avm_repeat, avm_rdrop, avm_rpeek, avm_rpush, avm_roll, avm_rot, 
  avm_store, avm_sub, avm_swap, 
  avm_then, avm_true,
  avm_until, avm_usrword, 
  avm_warm, avm_while,
  avm_zzz
};

const char* AVM_TOKENS[avm_zzz+1] = 
{
  "$NOP$",
  "+", "AND",
  "BEGIN",
  "$CALL_WORD$", "COLD",
  "=", ">", ">=", "<", "<=", "<>",
  "DIV", "/", "DO", ".", "DROP", "DUP",
  "ELSE",
  "FALSE", "@", "FLOAD",
  "I", "IF",
  "J",
  "LOOP",
  "MOD", "MON", "*",
  "NEGATE",
  "OR", "OVER",
  "PERFORM", "PICK", "+LOOP", "PUSH",
  "REPEAT", "R>", "R@", ">R", "ROLL", "ROT",
  "!", "-", "SWAP",
  "THEN", "TRUE",
  "UNTIL", "#",
  "WARM", "WHILE"
};

enum TBreakpointType { brk_none = 0x0, brk_user = 0x1, brk_auto = 0x2 };

class TAVM_op : public TObject
{
  AVM_opcode _op;
  TVariant _var;
  int _break_pointer;

public:
  const TVariant& var() const { return _var; }
  TVariant& var() { return _var; }
  AVM_opcode op() const { return _op; }
  bool has_break() const { return _break_pointer != brk_none; }
  bool has_auto_break() const { return (_break_pointer & brk_auto) != 0; }
  void set_user_break(bool on);
  void set_auto_break(bool on);

  TAVM_op(AVM_opcode o, const TString& str);
  TAVM_op(AVM_opcode o, const real& num);
  TAVM_op(AVM_opcode o, const long num);
  TAVM_op(AVM_opcode o);
};

void TAVM_op::set_user_break(bool on)
{
  _break_pointer = on ? brk_user : brk_none;
}

void TAVM_op::set_auto_break(bool on)
{
  if (on)
    _break_pointer |= brk_auto;
  else
    _break_pointer &= ~brk_auto;
}


TAVM_op::TAVM_op(AVM_opcode o, const TString& str)
       : _op(o), _var(str), _break_pointer(false)
{ }

TAVM_op::TAVM_op(AVM_opcode o, const real& num)
       : _op(o), _var(num), _break_pointer(false)
{ }

TAVM_op::TAVM_op(AVM_opcode o, const long num)
       : _op(o), _var(num), _break_pointer(false)
{ }

TAVM_op::TAVM_op(AVM_opcode o)
       : _op(o), _break_pointer(false)
{ }

///////////////////////////////////////////////////////////
// TAVM_monitor
///////////////////////////////////////////////////////////

class TAVM_list_window : public TField_window
{
  TBytecode* _bc;
  int _ip;
  const TString_array* _user_words;

protected:
  virtual void update();
  virtual void handler(WINDOW win, EVENT* ep);

public:
  void set_bytecode(const TBytecode* bc, int ip, const TString_array& uw);
  TAVM_list_window(int x, int y, int dx, int dy, WINDOW parent, TWindowed_field* owner);
};

void TAVM_list_window::handler(WINDOW win, EVENT* ep)
{
  if (ep->type == E_MOUSE_DOWN)
  {
    const TPoint pt = dev2log(ep->v.mouse.where);
    if (pt.x <= 5)
    {
      TAVM_op& op = *(TAVM_op*)_bc->objptr(pt.y-1);
      op.set_user_break(ep->v.mouse.button == 0);
      force_update();
    }
  }
  TField_window::handler(win, ep);
}

void TAVM_list_window::update()
{
  clear(NORMAL_BACK_COLOR);
  if (_bc != NULL)
  {
    autoscroll(false);
    set_brush(DISABLED_BACK_COLOR);
    bar(0, 0, columns()+1, 1); 
    bar(0, 0, 5, rows()+1); 
    set_brush(NORMAL_BACK_COLOR);
    printat(0, 0, _bc->name());
    autoscroll(true);

    TString str;
    int tab = 6;

    const int last = min(_bc->items(), rows());
    for (int i = 0; i < last; i++)
    {

      const int y = i+1;
      if (_ip == i)
      {
        set_brush(FOCUS_BACK_COLOR);
        bar(0, y, 80, y+1); 
        set_brush(NORMAL_BACK_COLOR);
      }
      printat(0, y, "%04d", i);
      const TAVM_op& op = *(const TAVM_op*)_bc->objptr(i);
      const AVM_opcode co = op.op();
      const TVariant& var = op.var();

      if (op.has_break())
        printat(4, y, "<");

      if (co == avm_else || co == avm_then || 
          co == avm_loop || co == avm_plus_loop || 
          co == avm_repeat || co == avm_until)
        tab -= 2;
      if (co == avm_push)
      {
        if (var.is_string() && var.as_string()[0] != '#')   
          str.cut(0) << '"' << var.as_string() << '"';
        else
          str = var.as_string();
      } else
      if (co == avm_call_word)
      {
        str = var.as_string();
      } else
      if (co == avm_usrword)
      {
        str = _user_words->row(var.as_int());
        str << " (#" << var.as_int() << ')';
      }
      else
      {
        str = AVM_TOKENS[co];
        if (!var.is_null())
          str << " (" << var.as_string() << ')';
      }
      printat(tab, y, str);
      if (co == avm_if || co == avm_else || 
        co == avm_do || co == avm_begin || co == avm_while)
        tab += 2;
    }
  }
}

void TAVM_list_window::set_bytecode(const TBytecode* bc, int ip, const TString_array& uw) 
{ 
  _bc = (TBytecode*)bc; 
  _ip = ip;
  _user_words = &uw;
  set_scroll_max(80, _bc->items() - rows());
}

TAVM_list_window::TAVM_list_window(int x, int y, int dx, int dy, WINDOW parent, TWindowed_field* owner)
           : TField_window(x, y, dx, dy, parent, owner), _bc(NULL)
{
  autoscroll(true);
}

class TAVM_stack_window : public TField_window
{
  TVariant_stack* _stack;

protected:
  virtual void update();

public:
  void set_stack(TVariant_stack& s);
  TAVM_stack_window(int x, int y, int dx, int dy, WINDOW parent, TWindowed_field* owner);
};

void TAVM_stack_window::update()
{
  clear(NORMAL_BACK_COLOR);
  if (_stack != NULL)
  {
    for (int i = 0; i < _stack->items(); i++)
      printat(0, i, _stack->peek(i).as_string());
  }
}

void TAVM_stack_window::set_stack(TVariant_stack& s)
{
  _stack = &s;
  set_scroll_max(80, s.items() - rows());
}

TAVM_stack_window::TAVM_stack_window(int x, int y, int dx, int dy, WINDOW parent, TWindowed_field* owner)
           : TField_window(x, y, dx, dy, parent, owner), _stack(NULL)
{
  autoscroll(true);
}

class TAVM_list_field : public TWindowed_field
{
protected:
  virtual TField_window* create_window(int x, int y, int dx, int dy, WINDOW parent);

public:
  TAVM_list_field(TMask* m) : TWindowed_field(m) { }
  virtual ~TAVM_list_field() { }
};

TField_window* TAVM_list_field::create_window(int x, int y, int dx, int dy, WINDOW parent)
{
  return new TAVM_list_window(x, y, dx, dy, parent, this);
}

class TAVM_stack_field : public TWindowed_field
{
protected:
  virtual TField_window* create_window(int x, int y, int dx, int dy, WINDOW parent);

public:
  TAVM_stack_field(TMask* m) : TWindowed_field(m) { }
  virtual ~TAVM_stack_field() { }
};

TField_window* TAVM_stack_field::create_window(int x, int y, int dx, int dy, WINDOW parent)
{
  return new TAVM_stack_window(x, y, dx, dy, parent, this);
}

class TAVM_monitor : public TAutomask
{
protected:
  TMask_field* parse_field(TScanner& scanner);
  virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);

public:
  TAVM_list_window& monitor() { return (TAVM_list_window&)((TAVM_list_field&)field(101)).win(); }
  TAVM_stack_window& stacker() { return (TAVM_stack_window&)((TAVM_list_field&)field(102)).win(); }
  TAVM_stack_window& rstacker() { return (TAVM_stack_window&)((TAVM_list_field&)field(103)).win(); }
  TAVM_monitor();
};

bool TAVM_monitor::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
  return true;
}

TMask_field* TAVM_monitor::parse_field(TScanner& scanner)
{
  if (scanner.token().starts_with("LI"))
    return new TAVM_list_field(this);
  if (scanner.token().starts_with("ST"))
    return new TAVM_stack_field(this);
  return TAutomask::parse_field(scanner);
}

TAVM_monitor::TAVM_monitor()
{
  read_mask("ba8304", 0, -1); 
  set_handlers();
}


///////////////////////////////////////////////////////////
// TAVM
///////////////////////////////////////////////////////////

class TAVM
{
  TAlex_virtual_machine* _vm;
  TString _last_error;
  TVariant_stack _stack, _rstack;
  const TBytecode* _bc; // Current word (or command line)
  int _ip;              // Current instruction pointer
  ostream* _outstr;

  TAssoc_array _words;
  TString_array _user_words;
  TAVM_monitor _mon;

protected:
  bool get_token(istream& instr, TString& str) const;
  AVM_opcode token2opcode(const TString& str) const;
  void log_error(const char* str);
  int compare_tos_nos();
  int find_matching(const TBytecode& bytecode, AVM_opcode op1, AVM_opcode op2 = avm_nop) const;
  void execute(const TAVM_op& op);
  void do_call(const TString& func);

  const TString_array& get_user_words();
  int compile_user_word(const TString& n);

public:
  const TString& get_last_error() const { return _last_error; }

  bool compile(istream& instr, TBytecode& bc);
  bool execute(const TBytecode& bc, ostream* outstr = NULL);
  void restart(bool cold);
  bool do_fload(const char* fname);

  TAVM(TAlex_virtual_machine* vm);
  virtual ~TAVM();
};

void TAVM::log_error(const char* str)
{
  _last_error = str;
  error_box(str);
}

bool TAVM::get_token(istream& instr, TString& str) const
{
  str.cut(0);
  instr.eatwhite();
  if (instr.eof())
    return false;
  char c;
  instr.get(c);
  str << c;
  if (c == '"')
  {
    char* buf = str.get_buffer()+1;
    const int bufsize = str.size()-1;
    instr.getline(buf, bufsize, '"');
    str << '"';
  }
  else
  {
    instr.get(c);
    while (!isspace(c) && c != EOF)
    {
      str << c;
      instr.get(c);
    }
  }

  return *str > ' ';
}

#define ALEX_TOKENS 24


AVM_opcode TAVM::token2opcode(const TString& str) const
{
  for (int i = 0; AVM_TOKENS[i] != NULL; i++)
  {
    if (str == AVM_TOKENS[i])
      return AVM_opcode(i);
  }

  const TBytecode* bc =(const TBytecode*)_words.objptr(str);
  if (bc != NULL)
    return avm_call_word;

  return avm_nop;
}

int TAVM::find_matching(const TBytecode& bytecode, AVM_opcode op1, AVM_opcode op2) const
{
  int i;
  for (i = bytecode.last(); i >= 0; i--)
  {
    TAVM_op& theop = (TAVM_op&)bytecode[i];
    if ((theop.op() == op1 || theop.op() == op2) && theop.var().is_null())
    {
      theop.var() = bytecode.items();
      break;
    }
  }
  return i;
}

const TString_array& TAVM::get_user_words()
{
  if (_user_words.items() == 0)
  {
    _user_words.add("***");
    _vm->get_usr_words(_user_words);
  }
  return _user_words;
}

int TAVM::compile_user_word(const TString& w)
{
  const TString_array& uw = get_user_words();
  const int i = uw.find(w);
  return i > 0 ? i : 0;
}

bool TAVM::compile(istream& instr, TBytecode& bytecode)
{
  TString str(256);
  bytecode.destroy();
  while (get_token(instr, str))
  {
    TAVM_op* op = NULL;
    if (str[0] == '"')
    {
      str.rtrim(1); str.ltrim(1); 
      op = new TAVM_op(avm_push, str);
    } else
    if ((isdigit(str[0]) || (str[0]=='-')) && isdigit(str[str.len()-1]))
    {
      const real r(str);
      op = new TAVM_op(avm_push, r);
    } else
    if (str[0] == '#') // User variable
    {
      op = new TAVM_op(avm_push, str);
    } else
    if (str == ":") // User word
    {
      if (get_token(instr, str))
      {
        TBytecode* bc = new TBytecode;
        bc->set_name(str);
        _words.add(str, bc);
        compile(instr, *bc);
        op = new TAVM_op(avm_nop);
      }
      else
      {
        _last_error = "Missing word after :";
        log_error(_last_error);
        return false;
      }
    } else
    if (str == ";")
    {
      return true;
    } else
    if (str == "(")
    {
      TString256 str;
      instr.getline(str.get_buffer(), str.size(), ')');
      op = new TAVM_op(avm_nop);
    } else
    if (str == "\\")
    {
      TString256 str;
      instr.getline(str.get_buffer(), str.size());
      op = new TAVM_op(avm_nop);
    }
    else
    {
      const AVM_opcode oc = token2opcode(str);
      if (oc != avm_nop)
      {
        switch (oc)
        {
        case avm_else:
          if (find_matching(bytecode, avm_if) < 0)
          {
            _last_error = "ELSE without matching IF";
            log_error(_last_error);
            return false;
          }
          op = new TAVM_op(oc);
          break;
        case avm_then:
          if (find_matching(bytecode, avm_if, avm_else) < 0)
          {
            _last_error = "THEN without matching IF";
            log_error(_last_error);
            return false;
          }
          op = new TAVM_op(oc);
          break;
        case avm_loop:
        case avm_plus_loop:
          {
            const do_pos = find_matching(bytecode, avm_do);
            if (do_pos < 0)
            {
              _last_error.cut(0) << str << " without matching DO";
              log_error(_last_error);
              return false;
            }
            op = new TAVM_op(oc, do_pos);
          }
          break;
        case avm_repeat:
        case avm_until:
          {
            const int begin_pos = find_matching(bytecode, avm_begin);
            if (begin_pos < 0)
            {
              _last_error.cut(0) << str << " without matching BEGIN";
              log_error(_last_error);
              return false;
            }
            find_matching(bytecode, avm_while);
            op = new TAVM_op(oc, begin_pos);
          }
          break;
        case avm_call_word:
          op = new TAVM_op(oc, str);
          break;
        default:
          op = new TAVM_op(oc);
          break;
        }
      }
      else
      {
        const int oc = compile_user_word(str);
        if (oc > 0)
          op = new TAVM_op(avm_usrword, oc);
      }
    }
    if (op != NULL)
    {
      if (op->op() != avm_nop)
        bytecode.add(op);
      else
        delete op;
    }
    else
    {
      _last_error.cut(0) << "Unknown WORD: " << str;
      log_error(_last_error);
      return false;
    }
  }
  return true;
}

int TAVM::compare_tos_nos()
{
  const TVariant& tos = _stack.pop();
  const TVariant& nos = _stack.pop();
  return nos.compare(tos);
}

void TAVM::do_call(const TString& func)
{
  _rstack.push(_bc->name());
  _rstack.push(_ip+1);
  _ip = -1; // will be incremented!
  _bc = (TBytecode*)_words.objptr(func);
}

bool TAVM::do_fload(const char* fname)
{
  TFilename name = fname;
  bool ok = name.custom_path();
  if (ok)
  {
    TBytecode bc;
    ifstream inf(name); 
    if (compile(inf, bc))
      execute(bc);
  }
  return ok;
}

void TAVM::execute(const TAVM_op& op)
{
  switch(op.op())
  {
  case avm_add : 
    {
      const TVariant& v1 = _stack.pop();
      TVariant& v0 = (TVariant&)_stack.peek();
      v0.add(v1);
    }
    break;
  case avm_and : 
    {
      const TVariant& v1 = _stack.pop();
      TVariant& v0 = (TVariant&)_stack.peek();
      const long r = v0.as_int() & v1.as_int();
      v0.set(r);
    }
    break;
  case avm_begin: break;
  case avm_call_word: do_call(op.var().as_string()); break;
  case avm_cold: restart(true); _bc = NULL; break;
  case avm_cmp_eq   : _stack.push(compare_tos_nos() == 0); break;
  case avm_cmp_gt   : _stack.push(compare_tos_nos() > 0);  break;
  case avm_cmp_gteq : _stack.push(compare_tos_nos() >= 0); break;
  case avm_cmp_lt   : _stack.push(compare_tos_nos() < 0);  break;
  case avm_cmp_lteq : _stack.push(compare_tos_nos() <= 0); break;
  case avm_cmp_noteq: _stack.push(compare_tos_nos() != 0); break;
  case avm_div:
    {
      const long r0 = _stack.pop().as_int();
      const long r1 = _stack.pop().as_int();
      if (r0 != 0)
      {
        const long n = r1 / r0;
        _stack.push(n);
      }
      else
        _stack.push(NULL_VARIANT);
    }

    break;
  case avm_divide: 
    {
      const real& r0 = _stack.pop().as_real();
      const real& r1 = _stack.pop().as_real();
      if (!r0.is_zero())
      {
        const real n = r1 / r0;
        _stack.push(n);
      }
      else
        _stack.push(NULL_VARIANT);
    }
    break;
  case avm_do: 
    {
      const TVariant& start = _stack.pop();
      const TVariant& limit = _stack.pop();
      if (start.compare(limit) < 0)
      {
        _rstack.push(limit);
        _rstack.push(start);
      }
      else
        _ip = op.var().as_int();
    }
    break;
  case avm_dot: 
    if (_outstr != NULL)
      *_outstr << _stack.pop().as_string(); 
    break;
  case avm_drop: _stack.drop(); break;
  case avm_dup: _stack.push(_stack.peek()); break;
  case avm_else:
    _ip = op.var().as_int();
    break;
  case avm_false: _stack.push(0L); break;
  case avm_fetch:
    {
      const TString& name = _stack.pop().as_string();
      TVariant var;
      if (name[0] == '#')
        _vm->get_usr_val(name, var);
      else
      {
        // TBI: Get global var
      }
      _stack.push(var);
    }
    break;
  case avm_fload: do_fload(_stack.pop().as_string()); break;
    break;
  case avm_i: _stack.push(_rstack.peek()); break;
  case avm_if:
    if (_stack.pop().is_zero())
      _ip = op.var().as_int();
    break;
  case avm_j: _stack.push(_rstack.peek(2)); break;
  case avm_loop: 
    {
      TVariant& start = _rstack.pop();
      const TVariant& limit = _rstack.pop();
      start.add(TVariant(UNO));
      _stack.push(limit);
      _stack.push(start);
      _ip = op.var().as_int()-1;
    }
    break;
  case avm_mod: 
    {
      const long i0 = _stack.pop().as_int();
      const long i1 = _stack.pop().as_int();
      _stack.push(i1 % i0);
    }
    break;
  case avm_mon: 
    if (!_mon.is_open())
      _mon.open_modal();
    break;
  case avm_mul: 
    {
      const TVariant& v1 = _stack.pop();
      TVariant& v0 = (TVariant&)_stack.peek();
      const real m = v0.as_real() * v1.as_real();
      v0.set(m);
    }
    break;
  case avm_negate:
    {
      TVariant& tos = _stack.peek();
      tos.set(~tos.as_int());
    }
    break;
  case avm_or:
    {
      const TVariant& tos = _stack.pop();
      TVariant& nos = (TVariant&)_stack.peek();
      const long r = nos.as_int() | tos.as_int();
      nos.set(r);
    }
    break;
  case avm_over: _stack.push(_stack.peek(1)); break;
  case avm_perform: 
    {
      const TString& cmd = _stack.pop().as_string();
      istrstream instr((char*)(const char*)cmd, cmd.len());
      TBytecode bc; 
      if (compile(instr, bc))
        execute(bc);
    }
    break;
  case avm_pick: _stack.push(_stack.peek(_stack.pop().as_int())); break;
  case avm_plus_loop: 
    {
      TVariant& start = _rstack.pop();
      const TVariant& limit = _rstack.pop();
      start.add(_stack.pop());
      _stack.push(limit);
      _stack.push(start);
      _ip = op.var().as_int()-1;
    }
    break;
  case avm_push: _stack.push(op.var()); break;
  case avm_repeat: _ip = op.var().as_int(); break;
  case avm_rdrop: _stack.push(_rstack.pop()); break;
  case avm_rpeek: _stack.push(_rstack.peek()); break;
  case avm_rpush: _rstack.push(_stack.pop()); break;
  case avm_roll: _stack.roll(_stack.pop().as_int()); break;
  case avm_rot: _stack.roll(2); break;
  case avm_store:
    {
      const TString& name = _stack.pop().as_string();
      const TVariant& var = _stack.pop();
      if (name[0] == '#')
        _vm->set_usr_val(name, var);
      else
      {
        // TBI: Set global var
      }
    }
    break;
  case avm_sub : 
    {
      const TVariant& v1 = _stack.pop();
      TVariant& v0 = (TVariant&)_stack.peek();
      v0.sub(v1);
    }
    break;
  case avm_swap: _stack.roll(1); break;
  case avm_then: break;
  case avm_true: _stack.push(1L); break;
  case avm_until: 
    if (_stack.pop().is_zero())
      _ip = op.var().as_int(); 
    break;
  case avm_usrword: 
    {
      const long usrword = op.var().as_int();
      _vm->execute_usr_word(usrword, _stack); 
    }
    break;
  case avm_warm: restart(false); _bc = NULL; break;
  case avm_while: _ip = op.var().as_int(); break; // Jump to BEGIN
  default:
    _last_error << "Unimplemented op code: " << op.op() << '\n';
    log_error(_last_error);
    _bc = NULL; // force exit
    break;
  }
}

bool TAVM::execute(const TBytecode& cmdline, ostream* outstr)
{
  const TBytecode* old_bc = _bc;
  const int old_ip = _ip;

  _bc = &cmdline;
  _ip = 0;
  if (outstr != NULL)
    _outstr = outstr;
  while (_bc != NULL)
  {
    while (_ip >= _bc->items()) // Fine funzione
    {
      if (_rstack.items() >= 2) // Controllo il return stack
      {
        _ip = _rstack.pop().as_int();
        const TString& str = _rstack.pop().as_string();
        if (str == cmdline.name())
          _bc = &cmdline;
        else
          _bc = (const TBytecode*)_words.objptr(str);
      }
      else
      {
        _bc = NULL;
        break; // Fine esecuzione
      }
    }
    if (_bc == NULL || _ip > _bc->items())
      break;

    TAVM_op& op = *(TAVM_op*)_bc->objptr(_ip);
    if (op.has_break() && !_mon.is_open())
    {
      if (op.has_auto_break())
        op.set_auto_break(false);
      _mon.open_modal();
    }

    if (_mon.is_open())  // Gestione debugger
    {
      lock_preview_update(true);
      TAVM_list_window& monitor = _mon.monitor();
      monitor.set_bytecode(_bc, _ip, _user_words);
      TAVM_stack_window& stacker = _mon.stacker();
      stacker.set_stack(_stack);
      TAVM_stack_window& rstacker = _mon.rstacker();
      rstacker.set_stack(_rstack);
      const KEY k = _mon.run();
      switch (k)
      {
      case K_F11: monitor.force_update(); stacker.force_update(); rstacker.force_update(); break;
      case K_F10: 
        if (_ip < _bc->items()-1)
        {
          _mon.close_modal(); 
          TAVM_op& op = *(TAVM_op*)_bc->objptr(_ip+1);
          op.set_auto_break(true);
        }
        break;
      case K_QUIT: abort_printing();
      case K_F5  : _mon.close_modal(); lock_preview_update(false); break;
      default: break;
      }  
    }

    execute(op);

    _ip++;
  }

  if (_mon.is_open()) // Chiudi debugger
  {
    _mon.close_modal();
    lock_preview_update(false);
  }

  //const bool ok = _bc != NULL;  // Not aborted
  _bc = old_bc;
  _ip = old_ip;
  
  return true;
}

void TAVM::restart(bool cold)
{
  _stack.reset();
  _rstack.reset();
  if (cold)
  {
    _words.destroy();
    do_fload("alex.alx");
  }
}

TAVM::TAVM(TAlex_virtual_machine* vm) 
    : _vm(vm), _outstr(NULL)
{ 
  restart(true);
}

TAVM::~TAVM()
{
}

///////////////////////////////////////////////////////////
// TAlex_virtual_machine
///////////////////////////////////////////////////////////

TAVM& TAlex_virtual_machine::avm()
{
  if (_avm == NULL)
    _avm = new TAVM(this);
  return *_avm;
}

const TString& TAlex_virtual_machine::get_last_error() const
{
  if (_avm != NULL)
    return _avm->get_last_error();
 return EMPTY_STRING;
}

bool TAlex_virtual_machine::compile(istream& instr, TBytecode& bc)
{
  return avm().compile(instr, bc);
}

bool TAlex_virtual_machine::execute(const TBytecode& bc, ostream& outstr)
{
  return avm().execute(bc, &outstr);
}

bool TAlex_virtual_machine::compile(const char* cmd, TBytecode& bc)
{
  istrstream instr((char*)cmd, strlen(cmd));
  return compile(instr, bc);
}

bool TAlex_virtual_machine::execute(const TBytecode& bc, TString& outs)
{
  char* buf = outs.get_buffer();
  memset(buf, 0, outs.size());
  ostrstream outstr(buf, outs.size());
  return execute(bc, outstr);
}

void TAlex_virtual_machine::warm_restart() // Ripartenza a caldo
{
  avm().restart(false);
}

void TAlex_virtual_machine::cold_restart() // Ripartenza a freddo
{
  avm().restart(true);
}

bool TAlex_virtual_machine::get_usr_val(const TString& name, TVariant& var) const
{
  if (name.starts_with("#SYSTEM."))
  {
    const TFixed_string n((const char*)name+8);
    if (n == "ADMINISTATOR")
    {
      var.set(dongle().administrator());
      return true;
    }
    if (n == "CLOCK")
    {
      const long msec = clock() / (CLOCKS_PER_SEC / 1000);
      var.set(msec);
      return true;
    }
    if (n == "FIRM")
    {
      var.set(prefix().get_codditta());
      return true;
    }
    if (n == "STUDY")
    {
      var.set(firm2dir(-1));
      return true;
    }
    if (n == "DATE")
    {
      const TDate oggi(TODAY);
      var.set(oggi);
      return true;
    }
    if (n == "USER")
    {
      var.set(user());
      return true;
    }
  }
  return false;
}

bool TAlex_virtual_machine::set_usr_val(const TString& name, const TVariant& var)
{
  if (name.starts_with("#SYSTEM."))
  {
    const TFixed_string n((const char*)name+8);
    if (n == "FIRM")
    {
      return prefix().set_codditta(var.as_int());
    }
  }
  return false;
}

unsigned int TAlex_virtual_machine::get_usr_words(TString_array&) const
{
  return 0;
}

bool TAlex_virtual_machine::execute_usr_word(unsigned int opcode, TVariant_stack& stack)
{
  return false;
}

bool TAlex_virtual_machine::fload(const char* fname)
{
  return avm().do_fload(fname);
}

TAlex_virtual_machine::TAlex_virtual_machine() : _avm(NULL)
{
}

TAlex_virtual_machine::~TAlex_virtual_machine()
{
  if (_avm != NULL)
    delete _avm;
}