/* from retro forth
http://forthworks.com/retro/
*/
package  forth;

public class STACK {

public int [] stack = null;  //

public int sp;

public void push(int v) {stack[sp++] = v; }

public int pop()        {return stack[--sp];} // --sp
   
public int peek() { return stack[sp - 1];}  // неразрушающее чтение стэка
   
public int peek2() {   return stack[sp - 2];   }
   
public void drop(int i) {sp -= i;   }

public int getDepth() {   return sp; }
}   

/* Part of the project take  from retro forth
http://forthworks.com/retro/
*/

package forth;   

public class FVM {

        public  int IMAGE_SIZE=1024;  // Размер памяти по умолчанию

   private int sp = 0, rsp = 0, ip = 0; // указатели стека, стека возвратов и адрес команды
   
        public STACK stack,adrStack;    //стеки 

        public short  [] image;  // 16 битная память

        public int [] ports;  // порты ввода вывода
   

   public static final int
    VM_NOP = 0 ,
    VM_LIT = 1 ,  // положить 16 битное значение на стек
    VM_DUP = 2 ,     VM_DROP = 3 ,   VM_SWAP = 4 ,
    VM_PUSH = 5 ,    VM_POP = 6 , 
    VM_CALL = 7 ,    VM_JUMP = 8 ,    VM_RETURN = 9 ,   
    VM_GT_JUMP = 10 ,VM_LT_JUMP = 11 , VM_NE_JUMP = 12 ,   VM_EQ_JUMP = 13 ,  //  >  <  !=  =
    VM_FETCH = 14 ,  VM_STORE = 15 ,  // @  !
    VM_ADD = 16 ,    VM_SUB = 17 ,    VM_MUL = 18 ,   VM_DIVMOD = 19 , // + - *  /   
    VM_AND = 20 , VM_OR = 21 , VM_XOR = 22 ,

    VM_SHL = 23 ,    VM_SHR = 24 ,    VM_ZERO_EXIT = 25 ,
     VM_INC = 26 ,   VM_DEC = 27 , 
     VM_IN = 28 ,   VM_OUT = 29 ,  VM_WAIT = 30, // записсь чтение портов , ожидание
     
     VM_LIT32 = 31. // положить 32 битное значение на стек
     ;

   private void handleDevices() {  // от ретро, // вызывается командой wait
        //зависит от реализации
   }

        private void callService(int x, int y) { вызывается во время записи в порт (out)
        // зависит от реализации
        }


   /**     * Process a single opcode*/   
   private void process() {

  int x, y, z,tmp,  op;
  op = image[ip]; 
        switch(op) {

    case VM_NOP:
      break;
    case VM_LIT:    ip++;stack.push(image[ip]); // положить 16 битное значение на стек
      break;
    case VM_DUP:    tmp=stack.pop(); stack.push(tmp);stack.push(tmp);
      break;
    case VM_DROP:   stack.drop(1);
      break;
    case VM_SWAP:   x = stack.pop(); y= stack.pop(); stack.push(x);stack.push(y);
      break;
    case VM_PUSH:   x = stack.pop();  adrStack.push(x); // со стека данных на адресный стек
      break;
    case VM_POP:    x = adrStack.pop(); stack.push(x); // обратно
      break;


    case VM_CALL:   ip++; adrStack.push(ip); ip=image[ip]-1;
      break;
    case VM_JUMP:   ip++;    ip = image[ip]-1; 
      break;
    case VM_RETURN:
      ip = adrStack.pop();
      break;
    case VM_GT_JUMP:  ip++;    // 
      x = stack.pop(); y= stack.pop(); if (y>x) ip = image[ip] - 1;
      break;
    case VM_LT_JUMP:   ip++;
       x = stack.pop(); y= stack.pop(); if (y<x) ip = image[ip] - 1;
      break;
    case VM_NE_JUMP:  ip++;
      x = stack.pop(); y= stack.pop(); if (y!=x) ip = image[ip] - 1;  // переход если не равно
      break;
    case VM_EQ_JUMP:   ip++;
       x = stack.pop(); y= stack.pop(); if (y==x) ip = image[ip] - 1; // переход если  равно
      break;
     
     
    case VM_FETCH: /// @
      tmp=stack.pop();                        // со стека снимается адрес
      x=image[tmp]; tmp++; y=image[tmp];      // с этого адреса снимаются две соседние
      stack.push(x << 16  | y & 0xffff  );   // 16битные ячейки и с помощью сдвига и AND
      break;               // объединяются в 32 битное значение и кладутся на стек


    case VM_STORE:  //     //  обратная операция 32 битное знач. разлагается
     x = stack.pop(); y= stack.pop(); // на два 16 битных с помощью сдвигов   
     short a=(short)y ,  b = (short) (y >> 16);
     image[x]=b; x++ ;  image[x]=a;
      break;

    case VM_ADD:    x = stack.pop(); y= stack.pop();stack.push(y+x);
      break;
    case VM_SUB:    x = stack.pop(); y= stack.pop();stack.push(y-x);
      break;
    case VM_MUL:    x = stack.pop(); y= stack.pop();stack.push(y*x);/
      break;
    case VM_DIVMOD:    //my relize div 0
      x = stack.pop(); y= stack.pop();     
       stack.push(y % x);  stack.push(y/x); // на стеке остаток и целое
      break;     // иожно добавить проверку /0 если не отлавливаются исключения
    case VM_AND:     x = stack.pop(); y= stack.pop();stack.push(x & y);
      break;
    case VM_OR:      x = stack.pop(); y= stack.pop();stack.push(x | y);
      break;
    case VM_XOR:   x = stack.pop(); y= stack.pop();stack.push(x ^ y);
      break;
    case VM_SHL:    x = stack.pop(); y= stack.pop();stack.push(  y << x );  // сдвиг битов влево
      break;   
    case VM_SHR:   x = stack.pop(); y= stack.pop();stack.push( y >>= x );   //  вправо 
      break;
    case VM_ZERO_EXIT:    // выход из подпрограммы, если на стеке 0
      if (stack.peek() == 0)
      {
        stack.drop(1);
        ip = adrStack.pop();
      }
      break;
    case VM_INC:   x = stack.pop(); x++; stack.push(x); 
     break;
    case VM_DEC:   x = stack.pop(); x--; stack.push(x);
     break;

   case VM_IN:          // чтение порта
      x = stack.pop();
      y = ports[x];
      stack.push(y);
      ports[x] = 0;
      break;
    case VM_OUT:   // вершина номер порта
      x=stack.pop();
      y=stack.pop();
      ports[x]=y;//
      callService(x,y);  //вызов внешней функции
      break;
    case VM_WAIT:   handleDevices(); // наследство от  ретро
      break;

    case VM_LIT32:  // положить 32 битное значение
      ip++; x=image[ip]; ip++; y=image[ip];  stack.push( x << 16  | y & 0xffff );
      break; //2 16 битные ячейки объединяются в 32 битную с помощью сдвигов

  }
}


  boolean _HALT =  false;   //Переменной Halt присваиваются значение во время выполнения
                                //callService, при исполнении инструкции out

  public void processImage( int startIP ) {
  ip=startIP;
  boolean _HALT=false;
  while  (ip<IMAGE_SIZE  && ! _HALT) {
       process();   
       ip++;} 
  } //void


}