P op_errormessage(void)
{
LBIG e, pid, port;
P nb, tnb;
B *m, *s;
if (o_6 < FLOORopds) goto baderror;
if (CLASS(o_6) != NUM) goto baderror;
if (! VALUE(o_6, &pid)) goto baderror;
if (TAG(o_5) != (ARRAY | BYTETYPE)) goto baderror;
if (CLASS(o_4) != NUM) goto baderror;
if (! VALUE(o_4, &port)) goto baderror;
if (TAG(o_3) != (ARRAY | BYTETYPE)) goto baderror;
if (CLASS(o_2) != NUM) goto baderror;
if (!VALUE(o_2, &e)) goto baderror;
if (TAG(o_1) != (ARRAY | BYTETYPE)) goto baderror;
s = (B *)VALUE_BASE(o_1);
tnb = ARRAY_SIZE(o_1);
nb = dm_snprintf((char*) s, tnb, "On %*s port %llu, pid %llu: ",
(int) ARRAY_SIZE(o_5),
(char*) VALUE_BASE(o_5),
(unsigned long long) port,
(unsigned long long) pid);
s += nb;
tnb -= nb;
if ((P)e < 0) /*Clib error */
nb = dm_snprintf((char*) s, tnb, "errno: %s",
(char*) strerror(-(int)e));
else { /* one of our error codes: decode */
m = geterror((P) e);
nb = strlen((char*) m);
if (nb > tnb) nb = tnb;
moveB(m, s, nb);
}
s += nb;
tnb -= nb;
nb = dm_snprintf((char*)s, tnb, " in %*s\n",
(int) ARRAY_SIZE(o_3),
(char*) VALUE_BASE(o_3));
ARRAY_SIZE(o_1) = (P)(s + nb) - VALUE_BASE(o_1);
moveframe(o_1,o_6);
FREEopds = o_5;
return OK;
baderror:
printf("**Error with corrupted error info on operand stack!\n");
return op_halt();
}
void amis2000_base_device::execute_run()
{
while (m_icount > 0)
{
m_icount--;
// remember previous opcode
m_prev_op = m_op;
debugger_instruction_hook(this, m_pc);
m_op = m_program->read_byte(m_pc);
m_pc = (m_pc + 1) & 0x1fff;
if (m_skip)
{
// always skip over PP prefix
m_skip = ((m_op & 0xf0) == 0x60);
m_op = 0; // nop
}
switch (m_op & 0xf0)
{
case 0x50: op_adis(); break;
case 0x60: op_pp(); break;
case 0x70: op_lai(); break;
case 0x80: case 0x90: case 0xa0: case 0xb0: op_jms(); break;
case 0xc0: case 0xd0: case 0xe0: case 0xf0: op_jmp(); break;
default:
switch (m_op)
{
case 0x00: op_nop(); break;
case 0x01: op_halt(); break;
case 0x02: op_rt(); break;
case 0x03: op_rts(); break;
case 0x04: op_psh(); break;
case 0x05: op_psl(); break;
case 0x06: op_and(); break;
case 0x07: op_sos(); break;
case 0x08: op_sbe(); break;
case 0x09: op_szc(); break;
case 0x0a: op_stc(); break;
case 0x0b: op_rsc(); break;
case 0x0c: op_lae(); break;
case 0x0d: op_xae(); break;
case 0x0e: op_inp(); break;
case 0x0f: op_eur(); break;
case 0x10: op_cma(); break;
case 0x11: op_xabu(); break;
case 0x12: op_lab(); break;
case 0x13: op_xab(); break;
case 0x14: op_adcs(); break;
case 0x15: op_xor(); break;
case 0x16: op_add(); break;
case 0x17: op_sam(); break;
case 0x18: op_disb(); break;
case 0x19: op_mvs(); break;
case 0x1a: op_out(); break;
case 0x1b: op_disn(); break;
case 0x28: op_szk(); break;
case 0x29: op_szi(); break;
case 0x2a: op_rf1(); break;
case 0x2b: op_sf1(); break;
case 0x2c: op_rf2(); break;
case 0x2d: op_sf2(); break;
case 0x2e: op_tf1(); break;
case 0x2f: op_tf2(); break;
default:
switch (m_op & 0xfc)
{
case 0x1c: op_szm(); break;
case 0x20: op_stm(); break;
case 0x24: op_rsm(); break;
case 0x30: op_xci(); break;
case 0x34: op_xcd(); break;
case 0x38: op_xc(); break;
case 0x3c: op_lam(); break;
case 0x40: op_lbz(); break;
case 0x44: op_lbf(); break;
case 0x48: op_lbe(); break;
case 0x4c: op_lbep(); break;
}
break; // 0xfc
}
break; // 0xff
} // big switch
}
}
P op_error(void)
{
LBIG e, pid, port;
P nb, atmost;
B *m, strb[256], *p;
p = strb;
atmost = 255;
if (o_5 < FLOORopds) goto baderror;
if (CLASS(o_5) != NUM) goto baderror;
if (! VALUE(o_5, &pid)) goto baderror;
if (TAG(o_4) != (ARRAY | BYTETYPE)) goto baderror;
if (CLASS(o_3) != NUM) goto baderror;
if (! VALUE(o_3, &port)) goto baderror;
if (TAG(o_2) != (ARRAY | BYTETYPE)) goto baderror;
if (CLASS(o_1) != NUM) goto baderror;
if (! VALUE(o_1, &e)) goto baderror;
nb = dm_snprintf((char*) p, atmost, "\033[31mOn %*s port %llu, pid %llu: ",
(int) ARRAY_SIZE(o_4),
(char*) VALUE_BASE(o_4),
(unsigned long long) port,
(unsigned long long) pid);
p += nb;
atmost -= nb;
if ((P)e < 0) /*Clib error */
nb = dm_snprintf((char*) p, atmost, "errno: %s",
(char*) strerror(-(int)e));
else { /* one of our error codes: decode */
m = geterror((P) e);
nb = dm_snprintf((char*) p, atmost, "%s",
(char*) m);
}
p += nb;
atmost -= nb;
nb = dm_snprintf((char*) p, atmost, " in %*s\033[0m\n",
(int) ARRAY_SIZE(o_2),
(char*) VALUE_BASE(o_2));
nb += (P)(p - strb);
TAG(o_5) = ARRAY | BYTETYPE;
ATTR(o_5) = READONLY;
VALUE_BASE(o_5) = (P) strb;
ARRAY_SIZE(o_5) = nb;
FREEopds = o_4;
op_toconsole();
if (op_halt() == DONE) return DONE;
nb = dm_snprintf((char*) p, atmost, "%s",
"** Error in internal halt!\n");
goto baderror2;
baderror:
nb = dm_snprintf((char*)p, atmost,
"**Error with corrupted error info on operand stack!\n");
baderror2:
op_abort();
nb += (P)(p - strb);
TAG(o1) = ARRAY | BYTETYPE;
ATTR(o1) = READONLY;
VALUE_BASE(o1) = (P) strb;
ARRAY_SIZE(o1) = nb;
FREEopds = o2;
return op_toconsole();
}
void dm_read(mval *v)
{
boolean_t done;
unsigned short iosb[4];
int cl, index;
uint4 max_width, save_modifiers, save_term_msk, status;
read_iosb stat_blk;
io_desc *io_ptr;
t_cap s_mode;
d_tt_struct *tt_ptr;
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
if (tt == io_curr_device.out->type)
iott_flush(io_curr_device.out);
if (!comline_base)
{
comline_base = malloc(MAX_RECALL * SIZEOF(mstr));
memset(comline_base, 0, (MAX_RECALL * SIZEOF(mstr)));
}
io_ptr = io_curr_device.in;
assert(tt == io_ptr->type);
assert(dev_open == io_ptr->state);
if (io_ptr->dollar.zeof)
op_halt();
if (outofband)
{
outofband_action(FALSE);
assert(FALSE);
}
tt_ptr = (d_tt_struct *)io_ptr->dev_sp;
max_width = (io_ptr->width > tt_ptr->in_buf_sz) ? io_ptr->width : tt_ptr->in_buf_sz;
assert(stringpool.free >= stringpool.base);
assert(stringpool.free <= stringpool.top);
ENSURE_STP_FREE_SPACE(max_width);
active_device = io_ptr;
index = 0;
/* the following section of code puts the terminal in "easy of use" mode */
status = sys$qiow(EFN$C_ENF, tt_ptr->channel, IO$_SENSEMODE,
&stat_blk, 0, 0, &s_mode, 12, 0, 0, 0, 0);
if (SS$_NORMAL == status)
status = stat_blk.status;
if (SS$_NORMAL != status)
rts_error(VARLSTCNT(1) status);
if ((s_mode.ext_cap & TT2$M_PASTHRU) ||
!(s_mode.ext_cap & TT2$M_EDITING) ||
!(s_mode.term_char & TT$M_ESCAPE) ||
!(s_mode.term_char & TT$M_TTSYNC))
{
s_mode.ext_cap &= (~TT2$M_PASTHRU);
s_mode.ext_cap |= TT2$M_EDITING;
s_mode.term_char |= (TT$M_ESCAPE | TT$M_TTSYNC);
status = sys$qiow(EFN$C_ENF, tt_ptr->channel,
IO$_SETMODE, &stat_blk, 0, 0, &s_mode, 12, 0, 0, 0, 0);
if (SS$_NORMAL == status)
status = stat_blk.status;
if (SS$_NORMAL != status)
/* The following error is probably going to cause the terminal state to get mucked up */
rts_error(VARLSTCNT(1) status);
/* the following flag is normally used by iott_rdone, iott_readfl and iott_use but dm_read resets it when done */
tt_ptr->term_chars_twisted = TRUE;
}
save_modifiers = (unsigned)tt_ptr->item_list[0].addr;
tt_ptr->item_list[0].addr = (unsigned)tt_ptr->item_list[0].addr | TRM$M_TM_NORECALL & (~TRM$M_TM_NOECHO);
tt_ptr->item_list[1].addr = NO_M_TIMEOUT; /* reset key click timeout */
save_term_msk = ((io_termmask *)tt_ptr->item_list[2].addr)->mask[0];
((io_termmask *)tt_ptr->item_list[2].addr)->mask[0] = TERM_MSK | (SHFT_MSK << CTRL_B) | (SHFT_MSK << CTRL_Z);
tt_ptr->item_list[4].buf_len = (TREF(gtmprompt)).len;
do
{
done = TRUE;
assert(0 <= index && index <= MAX_RECALL + 1);
cl = clmod(comline_index - index);
if ((0 == index) || (MAX_RECALL + 1 == index))
tt_ptr->item_list[5].buf_len = 0;
else
{
tt_ptr->item_list[5].buf_len = comline_base[cl].len;
tt_ptr->item_list[5].addr = comline_base[cl].addr;
}
status = sys$qiow(EFN$C_ENF, tt_ptr->channel, tt_ptr->read_mask, &stat_blk, 0, 0,
stringpool.free, tt_ptr->in_buf_sz, 0, 0, tt_ptr->item_list, 6 * SIZEOF(item_list_struct));
if (outofband)
break;
if (SS$_NORMAL != status)
{
if (io_curr_device.in == io_std_device.in && io_curr_device.out == io_std_device.out)
{
if (prin_in_dev_failure)
sys$exit(status);
else
prin_in_dev_failure = TRUE;
}
break;
}
if (stat_blk.term_length > ESC_LEN - 1)
{
stat_blk.term_length = ESC_LEN - 1;
if (SS$_NORMAL == stat_blk.status)
stat_blk.status = SS$_PARTESCAPE;
}
if (SS$_NORMAL != stat_blk.status)
{
if (ctrlu_occurred)
{
index = 0;
done = FALSE;
ctrlu_occurred = FALSE;
iott_wtctrlu(stat_blk.char_ct + (TREF(gtmprompt)).len, io_ptr);
} else
{
status = stat_blk.status;
break;
}
} else
{
if ((CTRL_B == stat_blk.term_char) ||
(stat_blk.term_length == tt_ptr->key_up_arrow.len &&
!memcmp(tt_ptr->key_up_arrow.addr, stringpool.free + stat_blk.char_ct,
tt_ptr->key_up_arrow.len)))
{
done = FALSE;
if ((MAX_RECALL + 1 != index) && (comline_base[cl].len || !index))
index++;
} else
{
if (stat_blk.term_length == tt_ptr->key_down_arrow.len &&
!memcmp(tt_ptr->key_down_arrow.addr, stringpool.free + stat_blk.char_ct,
tt_ptr->key_down_arrow.len))
{
done = FALSE;
if (index)
--index;
}
}
if (!done)
{
status = sys$qiow(EFN$C_ENF, tt_ptr->channel,
IO$_WRITEVBLK, &iosb, NULL, 0,
tt_ptr->erase_to_end_line.addr, tt_ptr->erase_to_end_line.len,
0, CCRECALL, 0, 0);
} else
{
if (stat_blk.char_ct > 0
&& (('R' == *stringpool.free) || ('r' == *stringpool.free)) &&
(TRUE == m_recall(stat_blk.char_ct, stringpool.free, &index, tt_ptr->channel)))
{
assert(-1 <= index && index <= MAX_RECALL);
done = FALSE;
flush_pio();
status = sys$qiow(EFN$C_ENF, tt_ptr->channel,
IO$_WRITEVBLK, &iosb, NULL, 0,
0, 0, 0, CCPROMPT, 0, 0);
if ((-1 == index) || (CTRL_Z == stat_blk.term_char))
index = 0;
}
}
if (!done)
{
if (SS$_NORMAL == status)
status = iosb[0];
if (SS$_NORMAL != status)
break;
} else
{
if (CTRL_Z == stat_blk.term_char)
io_curr_device.in->dollar.zeof = TRUE;
}
}
} while (!done);
/* put the terminal back the way the user had it set up */
tt_ptr->item_list[0].addr = save_modifiers;
((io_termmask *)tt_ptr->item_list[2].addr)->mask[0] = save_term_msk;
if (tt_ptr->term_chars_twisted)
{
s_mode.ext_cap &= (~TT2$M_PASTHRU & ~TT2$M_EDITING);
s_mode.ext_cap |= (tt_ptr->ext_cap & (TT2$M_PASTHRU | TT2$M_EDITING));
s_mode.term_char &= (~TT$M_ESCAPE);
s_mode.term_char |= (tt_ptr->term_char & TT$M_ESCAPE);
status = sys$qiow(EFN$C_ENF, tt_ptr->channel,
IO$_SETMODE, iosb, 0, 0, &s_mode, 12, 0, 0, 0, 0);
if (SS$_NORMAL == status)
status = iosb[0];
tt_ptr->term_chars_twisted = FALSE;
}
if (SS$_NORMAL != status)
rts_error(VARLSTCNT(1) status);
if (outofband)
{
/* outofband not going to help more than a error so it's checked 2nd */
outofband_action(FALSE);
assert(FALSE);
}
v->mvtype = MV_STR;
v->str.len = stat_blk.char_ct;
v->str.addr = stringpool.free;
if (stat_blk.char_ct)
{
cl = clmod(comline_index - 1);
if (stat_blk.char_ct != comline_base[cl].len || memcmp(comline_base[cl].addr, stringpool.free, stat_blk.char_ct))
{
comline_base[comline_index] = v->str;
comline_index = clmod(comline_index + 1);
}
stringpool.free += stat_blk.char_ct;
}
assert(stringpool.free <= stringpool.top);
if ((io_ptr->dollar.x += stat_blk.char_ct) > io_ptr->width && io_ptr->wrap)
{
/* dm_read doesn't maintain the other io status isv's,
but it does $x and $y so the user can find out where they wound up */
io_ptr->dollar.y += io_ptr->dollar.x / io_ptr->width;
if (io_ptr->length)
io_ptr->dollar.y %= io_ptr->length;
io_ptr->dollar.x %= io_ptr->width;
}
active_device = 0;
}