blob: fbd9fa10813ab8a25ebbea3597b8a52b6539db6b [file] [log] [blame] [raw]
/* i1620_tty.c: IBM 1620 typewriter
Copyright (c) 2002-2017, Robert M. Supnik
Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the "Software"),
to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
ROBERT M SUPNIK BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Except as contained in this notice, the name of Robert M Supnik shall not be
used in advertising or otherwise to promote the sale, use or other dealings
in this Software without prior written authorization from Robert M Supnik.
tty console typewriter
26-May-17 RMS Added deferred IO
18-May-17 RMS Fixed keyboard interrupt problem for Linux
Added input backspace for Model II
04-May-17 DW Revised tab calculation algorithm
13-Mar-17 RMS Fixed tab stop array overrun at right margin (COVERITY)
21-Feb-15 TFM Option to provide single digit numeric output
05-Feb-15 TFM Changes to translate tables and valid input char.
02-Jan-14 RMS Added variable tab stops
10-Dec-13 RMS Fixed DN wraparound (Bob Armstrong)
21-Sep-05 RMS Revised translation tables for 7094/1401 compatibility
22-Dec-02 RMS Added break test
*/
#include "i1620_defs.h"
#define NUM_1_DIGIT TRUE /* indicate numeric output will use single digit format (tfm) */
/* Maximum number of characters per line, or one-based column number of last char cell */
#define TTO_COLMAX 80
#define UF_V_1DIG (UNIT_V_UF)
#define UF_1DIG (1 << UF_V_1DIG)
#define UTTI 1
#define UTTO 0
uint32 tti_unlock = 0; /* expecting input */
uint32 tti_flag = 0; /* flag typed */
int32 tto_col = 1; /* one-based, char loc to print next */
uint8 tto_tabs[TTO_COLMAX + 1] = { /* Zero-based access, one-based UI */
0,0,0,0,0,0,0,0,
1,0,0,0,0,0,0,0,
1,0,0,0,0,0,0,0,
1,0,0,0,0,0,0,0,
1,0,0,0,0,0,0,0,
1,0,0,0,0,0,0,0,
1,0,0,0,0,0,0,0,
1,0,0,0,0,0,0,0,
1,0,0,0,0,0,0,0,
1,0,0,0,0,0,0,0,
1
};
extern uint8 M[MAXMEMSIZE];
extern uint8 ind[NUM_IND];
extern UNIT cpu_unit;
extern uint32 io_stop;
extern uint32 cpuio_inp, cpuio_opc, cpuio_cnt, PAR;
t_stat tto_num (void);
t_stat tto_write (uint32 c);
t_stat tti_svc (UNIT *uptr);
t_stat tto_svc (UNIT *uptr);
t_stat tty_reset (DEVICE *dptr);
t_stat tty_set_fixtabs (UNIT *uptr, int32 val, CONST char *cptr, void *desc);
t_stat tty_set_12digit (UNIT *uptr, int32 val, CONST char *cptr, void *desc);
/* TTY data structures
tty_dev TTY device descriptor
tty_unit TTY unit descriptor
tty_reg TTY register list
*/
UNIT tty_unit[] = {
{ UDATA (&tto_svc, 0, 0), SERIAL_OUT_WAIT },
{ UDATA (&tti_svc, 0, 0), KBD_POLL_WAIT }
};
REG tty_reg[] = {
{ FLDATAD (UNLOCK, tti_unlock, 0, "keyboard unlocked flag") },
{ FLDATAD (FLAG, tti_flag, 0, "set flag on next input digit"), REG_HRO },
{ DRDATAD (COL, tto_col, 7, "current column") },
{ DRDATAD (KTIME, tty_unit[UTTI].wait, 24, "keyboard polling interval"), REG_NZ + PV_LEFT },
{ DRDATAD (TTIME, tty_unit[UTTO].wait, 24, "typewriter character delay"), REG_NZ + PV_LEFT },
{ DRDATAD (CPS, tty_unit[UTTO].DEFIO_CPS, 24, "Character Output Rate"), PV_LEFT },
{ DRDATAD (ICPS, tty_unit[UTTI].DEFIO_CPS, 24, "Character Input Rate"), PV_LEFT },
{ NULL }
};
MTAB tty_mod[] = {
{ MTAB_XTD|MTAB_VDV, TTO_COLMAX, NULL, "TABS=col;col;col...",
&sim_tt_settabs, NULL, (void *) tto_tabs, "set tab stops at the specified columns" },
{ MTAB_XTD|MTAB_VDV|MTAB_NMO, TTO_COLMAX, "TABS", NULL,
NULL, &sim_tt_showtabs, (void *) tto_tabs, "display current tab stops" },
{ MTAB_XTD|MTAB_VDV, 0, NULL, "NOTABS",
&tty_set_fixtabs, NULL, NULL, "remove all tab stops" },
{ MTAB_XTD|MTAB_VDV, 8, NULL, "DEFAULTTABS",
&tty_set_fixtabs, NULL, NULL, "set tab stops every eight columns" },
{ UF_1DIG, UF_1DIG, "combined digits and flags", "1DIGIT",
&tty_set_12digit, NULL, NULL, "type flagged digits as letters" },
{ UF_1DIG, 0 , "separate digits and flags", "2DIGIT",
&tty_set_12digit, NULL, NULL, "type flagged digits as ~digit" },
{ 0 }
};
DEVICE tty_dev = {
"TTY", tty_unit, tty_reg, tty_mod,
2, 10, 31, 1, 8, 7,
NULL, NULL, &tty_reset,
NULL, NULL, NULL,
NULL, DEV_DEFIO
};
/* Data tables */
/* Keyboard to numeric */
/* The following constant is a list of valid 1620 numeric characters
that can be entered from the keyboard. They are the digits 0-9,
record mark(|), numeric blank(@) and group mark(}). All others
are cosidered invalid. When entering data, these characters may
all be preceeded by tilde(~) or accent(`) to indicate that the
following character should be entered into storage with a flag.
Alternatively, ] can be entered for flagged 0,
J-R or j-r can be entered for flagged 1-9,
! for flagged RM, * for flagged numeric blank,
" for flagged GM.
These different methods of entering numeric data represent
compromises since there is no practical way to exactly emulate
the 1620 typewriter capability of entering a flag but not
spacing the carriage. Entering a flag symbol in front of a
character is easier and sometimes more readable; using the
letters j-r is useful if column alignment is important on
the screen or when copying data that has printed letters in
place of flagged digits. This also matches the output of WN
or DN to the line printer.
*tti_to_num is the string of valid characters
tti_position_to_internal[] are the matching internal codes
(Tom McBride)*/
const char *tti_to_num = "0123456789|@}]jklmnopqr!*\"JKLMNOPQR";
const char tti_position_to_internal[35] = {
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, REC_MARK, NUM_BLANK, GRP_MARK,
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19,
FLG_REC_MARK, FLG_NUM_BLANK, FLG_GRP_MARK,
0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19
};
/* Keyboard to alphameric (digit pair) - translates LC to UC */
const int8 tti_to_alp[128] = {
-1, -1, -1, -1, -1, -1, -1, -1, /* 00 */
-1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, /* 10 */
-1, -1, -1, -1, -1, -1, -1, -1,
0x00, 0x5A, 0x5F, -1, 0x13, -1, -1, -1, /* !"#$%&' */
0x24, 0x04, 0x14, 0x10, 0x23, 0x20, 0x03, 0x21, /* ()*+,-./ */
0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, /* 01234567 */
0x78, 0x79, -1, -1, -1, 0x33, -1, -1, /* 89:;<=>? */
0x34, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, /* @ABCDEFG */
0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, /* HIJKLMNO */
0x57, 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, /* PQRSTUVW */
0x67, 0x68, 0x69, -1, -1, 0x50, -1, -1, /* XYZ[\]^_ */
-1, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, /* `abcdefg */
0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, /* hijklmno */
0x57, 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, /* pqrstuvw */
0x67, 0x68, 0x69, -1, 0x0A, 0x0F, -1, -1 /* xyz{|}~ */
};
/* Numeric (digit) to typewriter */
/* Digits with values of 11, 13 and 14 should never occur and will be typed as :'s
if they ever do. These are really errors. (Tom McBride) */
/* If flagged digits are being printed with preceeding ` characters only the first
half of this table is actually used. If digits are being printed one char per
digit the whole table is used. (Tom McBride) */
const char num_to_tto[32] = {
'0', '1', '2', '3', '4', '5', '6', '7',
'8', '9', '|', ':', '@', ':', ':', '}',
']', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
'Q', 'R', '!', ':', '*', ':', ':', '"'
};
/* Alphameric (digit pair) to typewriter */
/* Characters not in 1620 set have been removed from table (tfm) */
const char alp_to_tto[256] = {
' ', -1, -1, '.', ')', -1, -1, -1, /* 00 */
-1, -1, -1, -1, -1, -1, -1, -1,
'+', -1, -1, '$', '*', -1, -1, -1, /* 10 */
-1, -1, -1, -1, -1, -1, -1, -1,
'-', '/', -1, ',', '(', -1, -1, -1, /* 20 */
-1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, '=', '@', -1, -1, -1, /* 30 */
-1, -1, -1, -1, -1, -1, -1, -1,
-1, 'A', 'B', 'C', 'D', 'E', 'F', 'G', /* 40 */
'H', 'I', -1, -1, -1, -1, -1, -1,
'-', 'J', 'K', 'L', 'M', 'N', 'O', 'P', /* 50 */
'Q', 'R', -1, -1, -1, -1, -1, -1,
-1, -1, 'S', 'T', 'U', 'V', 'W', 'X', /* 60 */
'Y', 'Z', -1, -1, -1, -1, -1, -1,
'0', '1', '2', '3', '4', '5', '6', '7', /* 70 */
'8', '9', -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, /* 80 */
-1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, /* 90 */
-1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, /* A0 */
-1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, /* B0 */
-1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, /* C0 */
-1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, /* D0 */
-1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, /* E0 */
-1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, /* F0 */
-1, -1, -1, -1, -1, -1, -1, -1
};
/* Terminal IO
- On input, parity errors cannot occur.
- On input, release-start does NOT cause a record mark to be stored.
- On output, invalid characters type an invalid character and set WRCHK.
If IO stop is set, the system halts at the end of the operation.
*/
t_stat tty (uint32 op, uint32 pa, uint32 f0, uint32 f1)
{
switch (op) { /* case on op */
case OP_K: /* control */
switch (f1) { /* case on control */
case 1: /* space */
tto_write (' ');
break;
case 2: /* return */
tto_write ('\r');
break;
case 3: /* backspace */
if ((cpu_unit.flags & IF_MII) == 0)
return STOP_INVFNC;
tto_write ('\b');
break;
case 4: /* index */
if ((cpu_unit.flags & IF_MII) == 0)
return STOP_INVFNC;
tto_write ('\n');
break;
case 8: /* tab */
tto_write ('\t');
break;
default:
return STOP_INVFNC;
}
break;
case OP_WN:
case OP_DN:
case OP_WA:
cpuio_set_inp (op, &tty_unit[UTTO]); /* set IO in progress */
break;
case OP_RN:
case OP_RA:
tti_unlock = 1; /* unlock keyboard */
tti_flag = 0; /* init flag */
tto_write ('>'); /* prompt user */
cpuio_set_inp (op, NULL); /* set IO in progress */
break;
default: /* invalid function */
return STOP_INVFNC;
}
return SCPE_OK;
}
/* Input unit service - OP can be RA or RN */
t_stat tti_svc (UNIT *uptr)
{
int32 temp;
int8 raw, c;
const char *cp;
DEFIO_ACTIVATE (uptr); /* continue poll */
if ((temp = sim_poll_kbd ()) < SCPE_KFLAG) /* no char or error? */
return temp;
if (tti_unlock == 0) /* expecting input? */
return SCPE_OK; /* no, ignore */
raw = (int8) temp;
if (raw == '\r') { /* return? */
tto_write (raw); /* echo */
tti_unlock = 0; /* no more input */
cpuio_clr_inp (NULL);
return SCPE_OK;
}
if (cpuio_opc == OP_RN) { /* RN? */
if (((raw == '\b') || (raw == 0x7F)) && /* backspace or del? */
((cpu_unit.flags & IF_MII) != 0)) { /* on model 2? */
tto_write ('-'); /* print minus */
MM (PAR); /* decr mem addr */
return SCPE_OK;
}
else if ((raw == '~') || (raw == '`')) { /* flag? mark */
tto_write (raw);
tti_flag = FLAG;
return SCPE_OK;
}
else if ((cp = strchr (tti_to_num, raw)) == 0) { /* invalid? */
tto_write ('\a'); /* beep! */
return SCPE_OK;
}
tto_write (raw); /* echo */
if (cpuio_cnt >= MEMSIZE) { /* wrap around? */
tti_unlock = 0; /* no more input */
cpuio_clr_inp (NULL);
return STOP_RWRAP;
}
c = tti_position_to_internal[(cp - tti_to_num)] | tti_flag; /* assemble char */
M[PAR] = c & (FLAG | DIGIT); /* store char */
tti_flag = 0; /* re-init flag */
PP (PAR); /* incr mem addr */
cpuio_cnt++;
}
else { /* RA */
if (((raw == '\b') || (raw == 0x7F)) && /* backspace or del? */
((cpu_unit.flags & IF_MII) != 0)) { /* on model 2? */
tto_write ('-'); /* print minus */
PAR = ADDR_A (PAR, -2); /* decr mem addr*/
return SCPE_OK;
}
else if ((raw >= sizeof(tti_to_alp)) || /* illegal char? */
(tti_to_alp[raw] < 0)) {
tto_write ('\a'); /* beep! */
return SCPE_OK;
}
tto_write (raw); /* echo */
if (cpuio_cnt >= MEMSIZE) { /* wrap around? */
tti_unlock = 0; /* no more input */
cpuio_clr_inp (NULL);
return STOP_RWRAP;
}
c = tti_to_alp[raw]; /* xlate */
M[PAR] = (M[PAR] & FLAG) | (c & DIGIT); /* store 2 digits */
M[PAR - 1] = (M[PAR - 1] & FLAG) | ((c >> 4) & DIGIT);
PAR = ADDR_A (PAR, 2); /* incr mem addr */
cpuio_cnt = cpuio_cnt + 2;
}
return SCPE_OK;
}
/* Output unit service */
t_stat tto_svc (UNIT *uptr) {
uint8 d;
int8 ttc;
t_stat sta = SCPE_OK;
if ((cpuio_opc != OP_DN) && (cpuio_cnt >= MEMSIZE)) { /* wrap, ~dump? */
cpuio_clr_inp (uptr); /* done */
return STOP_RWRAP;
}
DEFIO_ACTIVATE (uptr); /* sched another xfer */
switch (cpuio_opc) { /* decode op */
case OP_DN:
if ((cpuio_cnt != 0) && ((PAR % 20000) == 0)) /* done? */
break;
return tto_num (); /* write numeric */
case OP_WN:
if ((M[PAR] & REC_MARK) == REC_MARK) /* end record? */
break;
return tto_num (); /* write numeric */
case OP_WA:
d = M[PAR] & DIGIT; /* get digit */
if ((d & REC_MARK) == REC_MARK) /* 8-2 char? done */
break;
d = ((M[PAR - 1] & DIGIT) << 4) | d; /* get digit pair */
ttc = alp_to_tto[d]; /* translate */
if (ttc < 0) { /* bad char? */
ind[IN_WRCHK] = 1; /* set write check */
if (io_stop) /* set return status */
sta = STOP_INVCHR;
break;
}
tto_write (ttc & 0x7F); /* write */
PAR = ADDR_A (PAR, 2); /* incr mem addr */
cpuio_cnt = cpuio_cnt + 2;
return SCPE_OK;
default:
return SCPE_IERR;
}
cpuio_clr_inp (uptr); /* clear IO in progress */
return sta;
}
/* Write numerically - cannot generate parity errors */
t_stat tto_num (void)
{
t_stat r;
uint8 d;
d = M[PAR]; /* get char */
if (tty_unit[UTTO].flags & UF_1DIG) /* how display flagged digits? */
r = tto_write (num_to_tto[d & (DIGIT|FLAG)]); /* single digit display */
else {
if (d & FLAG) /* flag? */
tto_write ('`'); /* write flag indicator */
r = tto_write (num_to_tto[d & DIGIT]); /* write the digit */
}
if (r != SCPE_OK) /* write error? */
return r;
PP (PAR); /* incr mem addr */
cpuio_cnt++;
return SCPE_OK;
}
/* Wrap line, if needed, prior to character output */
void tto_wrap(void)
{
if (tto_col > TTO_COLMAX) { /* line wrap? */
sim_putchar('\r');
sim_putchar('\n');
tto_col = 1;
}
}
/* Write, maintaining position */
t_stat tto_write (uint32 c)
{
if (c == '\t') { /* tab? */
tto_wrap();
do {
sim_putchar(' '); /* use spaces */
tto_col++;
} while (!(tto_col > TTO_COLMAX || tto_tabs[tto_col-1] == 1));
}
else if (c == '\r') { /* return? */
sim_putchar ('\r'); /* crlf */
sim_putchar ('\n');
tto_col = 1; /* back to LMargin */
}
else if ((c == '\n') || (c == '\a')) { /* non-spacing? */
sim_putchar (c);
}
else if (c == '\b') { /* backspace? */
if (tto_col > 1) {
sim_putchar(c);
tto_col--;
}
}
else { /* normal */
tto_wrap();
sim_putchar(c);
tto_col++;
}
return SCPE_OK;
}
/* Reset routine */
t_stat tty_reset (DEVICE *dptr)
{
sim_activate (&tty_unit[UTTI], tty_unit[UTTI].wait); /* activate poll */
sim_cancel (&tty_unit[UTTO]); /* cancel output */
tti_unlock = tti_flag = 0; /* tty locked */
tto_col = 1;
return SCPE_OK;
}
/* Set tab stops at fixed modulus */
t_stat tty_set_fixtabs (UNIT *uptr, int32 val, CONST char *cptr, void *desc)
{
int32 i;
for (i = 0; i < TTO_COLMAX; i++) {
if ((val != 0) && (i != 0) && ((i % val) == 0))
tto_tabs[i] = 1;
else tto_tabs[i] = 0;
}
return SCPE_OK;
}
/* Assure consistency of 1DIG/2DIG setting */
t_stat tty_set_12digit (UNIT *uptr, int32 val, CONST char *cptr, void *desc)
{
tty_unit[UTTI].flags = (tty_unit[UTTI].flags & ~UF_1DIG) | val;
tty_unit[UTTO].flags = (tty_unit[UTTO].flags & ~UF_1DIG) | val;
return SCPE_OK;
}