Ejemplo n.º 1
0
void rom(int n)
{
  switch(n)
    {
    case 0:
      fetch();
      break;
    case 1:
      iopr('+');               // Immediate operation iopr
      break;		
    case 2:
      iopr('-');
      break;
    case 3:
      iopr('^');
      break;
    case 4:
      iopr('&');
      break;
    case 5:
      iopr('|');
      break;
    case 6:
      iopr('~');
      break;
    case 7:                                                       // STOP function
      CP++;                                                       // To be finished later  
      return;			
    case 8:
      // ret();                                                        return flag function
      break;	
    case 9:
      nopr('+');
      break;
    case 10:
      nopr('-');
      break;
    case 11:
      nopr('^');
      break;
    case 12:
      nopr('&');
      break;
    case 13:
      nopr('|');
      break;
    case 14:
      nopr('~');
      break;
    case 15:
      movs();
      break;
    case 16:
      movd();
      break;
    }
}
Ejemplo n.º 2
0
Archivo: string.c Proyecto: kkaneda/vm
void movsw_xv_yv ( struct mon_t *mon, struct instruction_t *instr ) { movs ( mon, instr, ((instr->opsize_override) ? 2 : 4) ); }
Ejemplo n.º 3
0
Archivo: string.c Proyecto: kkaneda/vm
void movsb_xb_yb ( struct mon_t *mon, struct instruction_t *instr ) { movs ( mon, instr, 1 ); }
Ejemplo n.º 4
0
CompileOutput *Compiler::Compile(AMXRef amx) {
  Prepare(amx);

  Disassembler disasm(amx);
  Instruction instr;
  bool error = false;

  while (!error && disasm.Decode(instr, error)) {
    if (!Process(instr)) {
      error = true;
      break;
    }

    switch (instr.opcode().GetId()) {
      case OP_LOAD_PRI:
        load_pri(instr.operand());
        break;
      case OP_LOAD_ALT:
        load_alt(instr.operand());
        break;
      case OP_LOAD_S_PRI:
        load_s_pri(instr.operand());
        break;
      case OP_LOAD_S_ALT:
        load_s_alt(instr.operand());
        break;
      case OP_LREF_PRI:
        lref_pri(instr.operand());
        break;
      case OP_LREF_ALT:
        lref_alt(instr.operand());
        break;
      case OP_LREF_S_PRI:
        lref_s_pri(instr.operand());
        break;
      case OP_LREF_S_ALT:
        lref_s_alt(instr.operand());
        break;
      case OP_LOAD_I:
        load_i();
        break;
      case OP_LODB_I:
        lodb_i(instr.operand());
        break;
      case OP_CONST_PRI:
        const_pri(instr.operand());
        break;
      case OP_CONST_ALT:
        const_alt(instr.operand());
        break;
      case OP_ADDR_PRI:
        addr_pri(instr.operand());
        break;
      case OP_ADDR_ALT:
        addr_alt(instr.operand());
        break;
      case OP_STOR_PRI:
        stor_pri(instr.operand());
        break;
      case OP_STOR_ALT:
        stor_alt(instr.operand());
        break;
      case OP_STOR_S_PRI:
        stor_s_pri(instr.operand());
        break;
      case OP_STOR_S_ALT:
        stor_s_alt(instr.operand());
        break;
      case OP_SREF_PRI:
        sref_pri(instr.operand());
        break;
      case OP_SREF_ALT:
        sref_alt(instr.operand());
        break;
      case OP_SREF_S_PRI:
        sref_s_pri(instr.operand());
        break;
      case OP_SREF_S_ALT:
        sref_s_alt(instr.operand());
        break;
      case OP_STOR_I:
        stor_i();
        break;
      case OP_STRB_I:
        strb_i(instr.operand());
        break;
      case OP_LIDX:
        lidx();
        break;
      case OP_LIDX_B:
        lidx_b(instr.operand());
        break;
      case OP_IDXADDR:
        idxaddr();
        break;
      case OP_IDXADDR_B:
        idxaddr_b(instr.operand());
        break;
      case OP_ALIGN_PRI:
        align_pri(instr.operand());
        break;
      case OP_ALIGN_ALT:
        align_alt(instr.operand());
        break;
      case OP_LCTRL:
        lctrl(instr.operand(), instr.address() + instr.size());
        break;
      case OP_SCTRL:
        sctrl(instr.operand());
        break;
      case OP_MOVE_PRI:
        move_pri();
        break;
      case OP_MOVE_ALT:
        move_alt();
        break;
      case OP_XCHG:
        xchg();
        break;
      case OP_PUSH_PRI:
        push_pri();
        break;
      case OP_PUSH_ALT:
        push_alt();
        break;
      case OP_PUSH_C:
        push_c(instr.operand());
        break;
      case OP_PUSH:
        push(instr.operand());
        break;
      case OP_PUSH_S:
        push_s(instr.operand());
        break;
      case OP_POP_PRI:
        pop_pri();
        break;
      case OP_POP_ALT:
        pop_alt();
        break;
      case OP_STACK: // value
        stack(instr.operand());
        break;
      case OP_HEAP:
        heap(instr.operand());
        break;
      case OP_PROC:
        proc();
        break;
      case OP_RET:
        ret();
        break;
      case OP_RETN:
        retn();
        break;
      case OP_JUMP_PRI:
        jump_pri();
        break;
      case OP_CALL:
      case OP_JUMP:
      case OP_JZER:
      case OP_JNZ:
      case OP_JEQ:
      case OP_JNEQ:
      case OP_JLESS:
      case OP_JLEQ:
      case OP_JGRTR:
      case OP_JGEQ:
      case OP_JSLESS:
      case OP_JSLEQ:
      case OP_JSGRTR:
      case OP_JSGEQ: {
        cell dest = instr.operand() - reinterpret_cast<cell>(amx.code());
        switch (instr.opcode().GetId()) {
          case OP_CALL:
            call(dest);
            break;
          case OP_JUMP:
            jump(dest);
            break;
          case OP_JZER:
            jzer(dest);
            break;
          case OP_JNZ:
            jnz(dest);
            break;
          case OP_JEQ:
            jeq(dest);
            break;
          case OP_JNEQ:
            jneq(dest);
            break;
          case OP_JLESS:
            jless(dest);
            break;
          case OP_JLEQ:
            jleq(dest);
            break;
          case OP_JGRTR:
            jgrtr(dest);
            break;
          case OP_JGEQ:
            jgeq(dest);
            break;
          case OP_JSLESS:
            jsless(dest);
            break;
          case OP_JSLEQ:
            jsleq(dest);
            break;
          case OP_JSGRTR:
            jsgrtr(dest);
            break;
          case OP_JSGEQ:
            jsgeq(dest);
            break;
        }
        break;
      }
      case OP_SHL:
        shl();
        break;
      case OP_SHR:
        shr();
        break;
      case OP_SSHR:
        sshr();
        break;
      case OP_SHL_C_PRI:
        shl_c_pri(instr.operand());
        break;
      case OP_SHL_C_ALT:
        shl_c_alt(instr.operand());
        break;
      case OP_SHR_C_PRI:
        shr_c_pri(instr.operand());
        break;
      case OP_SHR_C_ALT:
        shr_c_alt(instr.operand());
        break;
      case OP_SMUL:
        smul();
        break;
      case OP_SDIV:
        sdiv();
        break;
      case OP_SDIV_ALT:
        sdiv_alt();
        break;
      case OP_UMUL:
        umul();
        break;
      case OP_UDIV:
        udiv();
        break;
      case OP_UDIV_ALT:
        udiv_alt();
        break;
      case OP_ADD:
        add();
        break;
      case OP_SUB:
        sub();
        break;
      case OP_SUB_ALT:
        sub_alt();
        break;
      case OP_AND:
        and_();
        break;
      case OP_OR:
        or_();
        break;
      case OP_XOR:
        xor_();
        break;
      case OP_NOT:
        not_();
        break;
      case OP_NEG:
        neg();
        break;
      case OP_INVERT:
        invert();
        break;
      case OP_ADD_C:
        add_c(instr.operand());
        break;
      case OP_SMUL_C:
        smul_c(instr.operand());
        break;
      case OP_ZERO_PRI:
        zero_pri();
        break;
      case OP_ZERO_ALT:
        zero_alt();
        break;
      case OP_ZERO:
        zero(instr.operand());
        break;
      case OP_ZERO_S:
        zero_s(instr.operand());
        break;
      case OP_SIGN_PRI:
        sign_pri();
        break;
      case OP_SIGN_ALT:
        sign_alt();
        break;
      case OP_EQ:
        eq();
        break;
      case OP_NEQ:
        neq();
        break;
      case OP_LESS:
        less();
        break;
      case OP_LEQ:
        leq();
        break;
      case OP_GRTR:
        grtr();
        break;
      case OP_GEQ:
        geq();
        break;
      case OP_SLESS:
        sless();
        break;
      case OP_SLEQ:
        sleq();
        break;
      case OP_SGRTR:
        sgrtr();
        break;
      case OP_SGEQ:
        sgeq();
        break;
      case OP_EQ_C_PRI:
        eq_c_pri(instr.operand());
        break;
      case OP_EQ_C_ALT:
        eq_c_alt(instr.operand());
        break;
      case OP_INC_PRI:
        inc_pri();
        break;
      case OP_INC_ALT:
        inc_alt();
        break;
      case OP_INC:
        inc(instr.operand());
        break;
      case OP_INC_S:
        inc_s(instr.operand());
        break;
      case OP_INC_I:
        inc_i();
        break;
      case OP_DEC_PRI:
        dec_pri();
        break;
      case OP_DEC_ALT:
        dec_alt();
        break;
      case OP_DEC:
        dec(instr.operand());
        break;
      case OP_DEC_S:
        dec_s(instr.operand());
        break;
      case OP_DEC_I:
        dec_i();
        break;
      case OP_MOVS:
        movs(instr.operand());
        break;
      case OP_CMPS:
        cmps(instr.operand());
        break;
      case OP_FILL:
        fill(instr.operand());
        break;
      case OP_HALT:
        halt(instr.operand());
        break;
      case OP_BOUNDS:
        bounds(instr.operand());
        break;
      case OP_SYSREQ_PRI:
        sysreq_pri();
        break;
      case OP_SYSREQ_C: {
        const char *name = amx.GetNativeName(instr.operand());
        if (name == 0) {
          error = true;
        } else {
          sysreq_c(instr.operand(), name);
        }
        break;
      }
      case OP_SYSREQ_D: {
        const char *name = amx.GetNativeName(amx.FindNative(instr.operand()));
        if (name == 0) {
          error = true;
        } else {
          sysreq_d(instr.operand(), name);
        }
        break;
      }
      case OP_SWITCH:
        switch_(CaseTable(amx, instr.operand()));
        break;
      case OP_CASETBL:
        casetbl();
        break;
      case OP_SWAP_PRI:
        swap_pri();
        break;
      case OP_SWAP_ALT:
        swap_alt();
        break;
      case OP_PUSH_ADR:
        push_adr(instr.operand());
        break;
      case OP_NOP:
        nop();
        break;
      case OP_BREAK:
        break_();
        break;
    default:
      error = true;
    }
  }

  if (error && error_handler_ != 0) {
    error_handler_->Execute(instr);
  }

  return Finish(error);
}
Ejemplo n.º 5
0
/*
*       Start the window manager up by initializing internal variables.
*/
void wm_start()
{
        register WORD   i;
        register ORECT  *po;
        register OBJECT *tree;
        PD              *ppd;

#if 0
                                                /* init default owner   */
                                                /*  to be screen mgr.   */
        ppd = fpdnm(NULLPTR, SCR_MGR);
#else
                                                /* init default owner   */
                                                /* to be current process*/
        ppd = rlr;
#endif
                                                /* init owner rects.    */
        or_start();
                                                /* init window extent   */
                                                /*   objects            */
        memset(&W_TREE[ROOT], 0, NUM_MWIN * sizeof(OBJECT));
        w_nilit(NUM_MWIN, &W_TREE[ROOT]);
        for(i=0; i<NUM_MWIN; i++)
        {
          D.w_win[i].w_flags = 0x0;
          D.w_win[i].w_rlist = (ORECT *) 0x0;
          W_TREE[i].ob_type = G_IBOX;
        }
        W_TREE[ROOT].ob_type = G_BOX;
        tree = (OBJECT *)ad_stdesk;
        W_TREE[ROOT].ob_spec = tree->ob_spec;
                                                /* init window element  */
                                                /*   objects            */
        memset(&W_ACTIVE[ROOT], 0, NUM_ELEM * sizeof(OBJECT));
        w_nilit(NUM_ELEM, &W_ACTIVE[0]);
        for(i=0; i<NUM_ELEM; i++)
        {
          W_ACTIVE[i].ob_type = gl_watype[i];
          W_ACTIVE[i].ob_spec = gl_waspec[i];
        }
        W_ACTIVE[ROOT].ob_state = SHADOWED;
                                                /* init rect. list      */
        D.w_win[0].w_rlist = po = get_orect();
        po->o_link = (ORECT *) 0x0;
        po->o_x = XFULL;
        po->o_y = YFULL;
        po->o_w = WFULL;
        po->o_h = HFULL;
        w_setup(ppd, DESKWH, NONE);
        w_setsize(WS_CURR, DESKWH, &gl_rscreen);
        w_setsize(WS_PREV, DESKWH, &gl_rscreen);
        w_setsize(WS_FULL, DESKWH, &gl_rfull);
        w_setsize(WS_WORK, DESKWH, &gl_rfull);
                                                /* init global vars     */
        gl_wtop = NIL;
        gl_wtree = ADDR(&W_TREE[ROOT]);
        gl_awind = ADDR(&W_ACTIVE[0]);
        gl_newdesk = 0x0L;
                                                /* init tedinfo parts   */
                                                /*   of title and info  */
                                                /*   lines              */
        movs(sizeof(TEDINFO), &gl_asamp, &gl_aname);
        movs(sizeof(TEDINFO), &gl_asamp, &gl_ainfo);
        gl_aname.te_just = TE_CNTR;
        W_ACTIVE[W_NAME].ob_spec = ADDR(&gl_aname);
        W_ACTIVE[W_INFO].ob_spec = ADDR(&gl_ainfo);
}