head     1.6;
access   ;
symbols  ;
locks    ;
comment  @@;


1.6
date     89.02.23.20.39.31;  author pkern;  state Exp;
branches ;
next     1.5;

1.5
date     89.02.23.20.01.27;  author pkern;  state Exp;
branches ;
next     1.4;

1.4
date     89.02.23.10.27.54;  author pkern;  state Exp;
branches ;
next     1.3;

1.3
date     89.02.15.17.20.10;  author pkern;  state Exp;
branches ;
next     1.2;

1.2
date     89.02.03.16.32.12;  author pkern;  state Exp;
branches ;
next     1.1;

1.1
date     89.01.31.14.05.58;  author pkern;  state Exp;
branches ;
next     ;


desc
@used to be keybrd.c
@


1.6
log
@Ctrl-space remapped
@
text
@/*
 * keybrd.ti:
 *	functions, maps and interrupt handlers for TI Pro keyboards
 *
 * Copyright (c) 1989 University of Toronto. All rights reserved.
 * Anyone may use or copy this software, except that it may not be
 * sold for profit, that this copyright notice remain intact, and that
 * credit is given where it is due. The University of Toronto and the
 * author make no warranty and accept no liability for this software.
 */
static char rcsid[] = "$Header: keybrd.ti,v 1.5 89/02/23 20:01:27 pkern Exp $";

#include <dos.h>
#include "cterm.h"
#include "ti.h"

#define word	unsigned int

uchar kqueued=0, keyboom=0;

static union REGS r;
static uchar f_map=0, f_vec=0, kb_mode=0;

extern int (*xmit)();
extern uchar flowctl, local, xoff;

/* check for queued keys */
kbdhit()
{
#ifdef KBDQUE
	return (kqueued);
#else
	r.h.ah = 1;
	int86(KBD_INT, &r, &r);
	return (!(r.x.flags & Zflag));	/* ie. ! Z-flag */
#endif
}

/* flush keyboard type-ahead queue */
kbflush()
{
	r.h.ah = 3;
	int86(KBD_INT, &r, &r);
	kqueued = 0;
}

/* toggle keyboard autorepeat */
kbautorep(sw)
int sw;	/* switch : 1 = on, 0 = off */
{
	r.h.ah = 4;
	r.h.al = (sw) ? 1 : 2;
	int86(KBD_INT, &r, &r);
}

/* get keyboard word */
word
kbdget()
{
	r.h.ah = 2; int86(KBD_INT, &r, &r);
	kb_mode = r.h.al;
	r.h.ah = 0; int86(KBD_INT, &r, &r);
	kqueued--;
	return((word) r.x.ax);
}

/* return a keypadv[] offset | 8-bit alternative */
kbdfn(kn)
word kn;
{
	word fn;
	extern word keymap[], alt8[];

	kn = kn >> 8;
	fn = alt8[kn] & 0x7f;
	if (fn) {
		if (kb_mode & 0x01)	/* CTRL key */
			fn = (alt8[kn] >> 8) & 0x3f;
		else if (kb_mode & 0x04)	/* SHIFT key */
			fn = alt8[kn] >> 8;
		kb_mode = 0;
		fn |= 0x80;
	}
	return((fn << 8) | keymap[kn]);
}

/*
 *  keypad map (aN = alt N, cN = ctrl N, sN = shift N)
 * +-----+-----+-----+-----+
 * | PF1 | PF2 | PF3 | PF4 |		cursor code offsets:
 * | aF1 | aF2 | aF3 | aF4 |		       UP - 0
 * +-----+-----+-----+-----+		       DOWN - 1
 * |  7  |  8  |  9  |  -  |		       RIGHT - 2
 * | a1  | a2  | a3  | a4  |		       LEFT - 3
 * | F5  | F6  | F7  | F8  |
 * +-----+-----+-----+-----+
 * |  4  |  5  |  6  |  ,  |	keypad code string offsets:
 * | aQ  | aW  | aE  | aR  |	8 - "0"	 10 - "8"	18 - "F3"
 * | cF5 | cF6 | cF7 | cF8 |	9 - "1"  11 - "9"	19 - "F4"
 * +-----+-----+-----+-----+	A - "2"  12 - "-"	1A - "\200"
 * |  1  |  2  |  3  | aF  |	B - "3"  13 - ","	1B - "\b"
 * | aA  | aS  | aD  | aF8 |	C - "4"  14 - "."	1C - "\003"
 * | aF5 | aF6 | aF7 |     |	D - "5"  15 - "ENTER"	1D - "\r\n"
 * +-----+-----+-----+Enter|	E - "6"  16 - "F1"	1E *-> ansback
 * |     0     |  .  |     |	F - "7"  17 - "F2"	1F - ""	 (empty)
 * | aZ    aX  | aC  | aV  |
 * | sF5   sF6 | sF7 | sF8 |
 * +-----------+-----+-----+
 */


/*
 * keymap:
 *	keypadv[] offsets for all (ie. 90H) extended function codes
 */
static word keymap[0x90] = {
/* 0x0_ */	0x1f, 0x1f, 0x1f, 0x1a, 0x1f, 0x1f, 0x1f, 0x1f,
		0x03, 0x02, 0x03, 0x02, 0x03, 0x02, 0x1f, 0x1f,
/* 0x1_ */	0x0c, 0x0d, 0x0e, 0x13, 0x1f, 0x1f, 0x1f, 0x1f,
		0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x09, 0x0a,
/* 0x2_ */	0x0b, 0x15, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f,
		0x1f, 0x1f, 0x1f, 0x1f, 0x08, 0x08, 0x14, 0x15,
/* 0x3_ */	0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f,
		0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1b, 0x0f,
/* 0x4_ */	0x10, 0x11, 0x12, 0x00, 0x01, 0x03, 0x02, 0x1f,
		0x00, 0x00, 0x1f, 0x03, 0x03, 0x02, 0x02, 0x1f,
/* 0x5_ */	0x01, 0x01, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f,
		0x08, 0x08, 0x14, 0x15, 0x00, 0x01, 0x1f, 0x1f,
/* 0x6_ */	0x1f, 0x1f, 0x0c, 0x0d, 0x0e, 0x13, 0x00, 0x01,
		0x16, 0x17, 0x18, 0x19, 0x09, 0x0a, 0x0b, 0x15,
/* 0x7_ */	0x00, 0x01, 0x1f, 0x03, 0x02, 0x1f, 0x01, 0x1f,
		0x0f, 0x10, 0x11, 0x12, 0x1f, 0x1f, 0x1f, 0x1f,
/* 0x8_ */	0x1f, 0x1f, 0x1f, 0x1f, 0x00, 0x1f, 0x1f, 0x1f,
		0x00, 0x01, 0x02, 0x03, 0x16, 0x17, 0x18, 0x19
};

/*
 * alt8:
 *	keymap[] ALTernatives with 8th bit set.
 *	(Turbo C direct storage: 'lsb msb')
 */
static word alt8[0x90] = {
/* 0x0_ */	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x1_ */	'qQ', 'wW', 'eE', 'rR',
		'tT', 'yY', 'uU', 'iI',
		'oO', 'pP', 0, 0, 0, 0, 'aA', 'sS',
/* 0x2_ */	'dD', 'fF', 'gG', 'hH',
		'jJ', 'kK', 'lL', 0, 0, 0, 0, 0,
		'zZ', 'xX', 'cC', 'vV',
/* 0x3_ */	'bB', 'nN', 'mM', 
		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x4_ */	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x5_ */	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x6_ */	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x7_ */	0, 0, 0, 0, 0, 0, 0, 0,
		'1!', '2@@', '3#', '4$',
		'5%', '6^', '7&', '8*',
/* 0x8_ */	'9(', '0)', '-_', '=+',
		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};

/* k_brk -- intercept SHIFT BRK/PAUS interrupt */
void interrupt
k_brk(bp,di,si,ds,es,dx,cx,bx,ax,ip,cs,flags)
word bp,di,si,ds,es,dx,cx,bx,ax,ip,cs,flags;
{
	flags |= Cflag;		/* ie. don't queue it */
	keyboom++;
}	

/* k_paus -- intercept PAUS key interrupt */
void interrupt
k_paus(bp,di,si,ds,es,dx,cx,bx,ax,ip,cs,flags)
word bp,di,si,ds,es,dx,cx,bx,ax,ip,cs,flags;
{
	if (flowctl && !local)
		if (xoff)
			{ xmit(XON); xoff = 0; }
		else
			{ xmit(XOFF); xoff++; }
	flags |= Cflag;		/* don't queue it */
}

/* k_que -- take note of new keystroke in buffer */
void interrupt
k_que()
{
	kqueued++;
/*	outport(0,7);	/* simple but pathetic-sounding keyclick */
}

/*
 * remap: table of scan codes for remapping TI Pro keypad
 *	- new scan values for scan codes 27 -> 44
 *	 (first 4 bits = ctrl/alt/shift bit choice
 *	   last 8 bits = the new scan code)
 * 0 = scan code unused (ie. it should never occur)
 */
static unsigned int remap[22] = {
	0x217, 0x218, 0x219, 0x21a,
	0x201, 0, 0x401, 0x204,
	0x101, 0x102, 0x003, 0x004,
	0x202, 0,   0,   0,
	0x001, 0x002, 0x103, 0x104,
	0x203, 0x403
};

/* k_map -- remap keypad scan codes */
void interrupt
k_map(bp,di,si,ds,es,dx,cx,bx,ax,ip,cs,flags)
word bp,di,si,ds,es,dx,cx,bx,ax,ip,cs,flags;
{
	uchar al, ah;

	al = ax & 0xff; ah = (ax >> 11);
	if (al < 45 && al > 22)
		ax = (ah << 11) + remap[al-23];
	else if ((ax & 0x100) && al == 81)	/* CTRL-SPACE */
		ax = (ax & 0xff00) | 10;	/* CTRL-2@@ */
}

/*
 * o_brk, o_paus, o_que, o_map:
 *	temp storage for old interrupt vectors
 */
void interrupt (*o_brk)();
void interrupt (*o_paus)();
void interrupt (*o_que)();
void interrupt (*o_map)();

init_kbd()
{
	if (f_vec) return(0);

	kbflush();

	/* remember old intr vector(s) */
	o_brk = getvect(KEYBRK);
	o_paus = getvect(KEYPAUS);
	o_que = getvect(KBDQUE);
	o_map = getvect(KBDMAP);
	/* install new one(s) */
	disable();
	setvect(KEYBRK, k_brk);
	setvect(KEYPAUS, k_paus);
	setvect(KBDQUE, k_que);
	setvect(KBDMAP, k_map);
	enable();

	f_vec = 1;	/* vector(s) installed */

	/* some important key mappings */
	keymap[K_SETUP >> 8] = 0x80;	/* flag the SETUP key */
	keymap[(K_SETUP >> 8)+1] = 0x80;	/* ditto on F2 */
	keymap[K_shBRK >> 8] = 0x40;	/* shiftBrk - send BRK */
	keymap[K_NUL >> 8] = 0x41;	/* ctrl-2@@  - send NUL */
	keymap[K_BKSP >> 8] = 0x1b;	/* backsp keypadv[] position */
	keymap[K_BREAK >> 8] = 0x1c;	/* break keypadv[] position */
	keymap[K_cBRK >> 8] = 0x1e;	/* ctrlBrk keypadv[] position */
	keyboom = 0;
}

reset_kbd()
{
	if (!f_vec) return;	/* no vectors to reset, yet */

	kbflush();

	/* restore old intr vector(s) */
	disable();
	setvect(KEYBRK, o_brk);
	setvect(KEYPAUS, o_paus);
	setvect(KBDQUE, o_que);
	setvect(KBDMAP, o_map);
	enable();

	f_vec = 0;	/* vector(s) reset */
}

/* switch newline mode */
nlmod(sw)
uchar sw;
{
	/* shift ENTER offset, if needed */
	keymap[0x21] = keymap[0x2f] = ((sw) ? 0x1d : 0x15);
}
@


1.5
log
@alt8 usage fleshed out.
@
text
@d11 1
a11 1
static char rcsid[] = "$Header: keybrd.ti,v 1.4 89/02/23 10:27:54 pkern Exp $";
d140 1
a140 1
 *	(8088 direct storage: 'lsb msb')
d218 2
@


1.4
log
@keypad num keys, '-', ',', now mapped to F5-F8 (with alt, ctrl and shift)
to fix mapping problem with altkey choice.
@
text
@d11 1
a11 1
static char rcsid[] = "$Header: keybrd.ti,v 1.3 89/02/15 17:20:10 pkern Exp $";
d75 2
a76 2
	fn = alt8[kn];
	if (fn && kn < 0x40 && kb_mode) {
d78 1
a78 1
			fn &= 0x9f;
d80 1
a80 1
			fn &= 0xdf;
d82 1
d140 1
d144 7
a150 7
/* 0x1_ */	'q'|0x80, 'w'|0x80, 'e'|0x80, 'r'|0x80,
		't'|0x80, 'y'|0x80, 'u'|0x80, 'i'|0x80,
		'o'|0x80, 'p'|0x80, 0, 0, 0, 0, 'a'|0x80, 's'|0x80,
/* 0x2_ */	'd'|0x80, 'f'|0x80, 'g'|0x80, 'h'|0x80,
		'j'|0x80, 'k'|0x80, 'l'|0x80, 0, 0, 0, 0, 0,
		'z'|0x80, 'x'|0x80, 'c'|0x80, 'v'|0x80,
/* 0x3_ */	'b'|0x80, 'n'|0x80, 'm'|0x80, 
d156 3
a158 3
		'1'|0x80, '2'|0x80, '3'|0x80, '4'|0x80,
		'5'|0x80, '6'|0x80, '7'|0x80, '8'|0x80,
/* 0x8_ */	'9'|0x80, '0'|0x80, '-'|0x80, '='|0x80,
@


1.3
log
@code added to set 8th bit via ALT key
@
text
@d5 5
a9 1
 * copyright (c) University of Toronto, 1989.
d11 1
a11 1
static char rcsid[] = "$Header: keybrd.ti,v 1.2 89/02/03 16:32:12 pkern Exp $";
d87 1
a87 1
 *  keypad map (aN == alt N)
d90 5
a94 4
 * | aF1 | aF2 | aF3 | aF4 |			UP - 0
 * +-----+-----+-----+-----+		      DOWN - 1
 * |  7  |  8  |  9  |  -  |		     RIGHT - 2
 * | a1  | a2  | a3  | a4  |		      LEFT - 3
d98 10
a107 7
 * +-----+-----+-----+-----+	9 - "1"  11 - "9"	19 - "F4"
 * |  1  |  2  |  3  |     |	A - "2"  12 - "-"	1A - "\200"
 * | aA  | aS  | aD  |Enter|	B - "3"  13 - ","	1B - "\b"
 * +-----+-----+-----+     |	C - "4"  14 - "."	1C - "\003"
 * |     0     |  .  | aF  |	D - "5"  15 - "ENTER"	1D - "\r\n"
 * | aZ    aX  | aC  | aV  |	E - "6"  16 - "F1"	1E *-> ansback
 * +-----------+-----+-----+	F - "7"  17 - "F2"	1F - ""	 (empty)
d123 2
a124 2
		0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1b, 0x1f,
/* 0x4_ */	0x1f, 0x1f, 0x1f, 0x00, 0x01, 0x03, 0x02, 0x1f,
d127 3
a129 3
		0x1f, 0x1f, 0x1f, 0x1f, 0x00, 0x01, 0x1f, 0x1f,
/* 0x6_ */	0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x00, 0x01,
		0x16, 0x17, 0x18, 0x19, 0x1f, 0x1f, 0x1f, 0x1f,
d192 3
a194 1
 *	- new scan values for scan codes 23 -> 44
d197 7
a203 7
static uchar remap[22] = {
	 23,  24,  25,  26,
	 66,   0,  82,  69,
	 50,  51,  11,  12,
	 67,   0,   0,   0,
	  9,  10,  52,  53,
	 68,  84
d213 1
a213 1
	al = ax & 0xff;	ah = (ax >> 8) | 0x02;
d215 1
a215 2
		/* force ALT-key bit & remap key code */
		ax = (ah << 8) + remap[al-23];
@


1.2
log
@*** empty log message ***
@
text
@d7 1
a7 1
static char rcsid[] = "$Header: keybrd.ti,v 1.1 89/01/31 14:05:58 pkern Exp $";
d13 2
d18 1
a18 1
static uchar f_map=0, f_vec=0;
d53 1
a53 1
unsigned int
d56 3
a58 2
	r.h.ah = 0;
	int86(KBD_INT, &r, &r);
d60 1
a60 1
	return((unsigned int) r.x.ax);
d63 1
a63 1
/* return a keypadv[] offset */
d65 1
a65 1
unsigned int kn;
d67 2
a68 1
	extern keymap[];
d70 10
a79 1
	return(keymap[kn>>8]);
d105 1
a105 2
 *	keypadv[] offsets for all possible
 *	(ie. 90H) extended function-key codes
d107 1
a107 1
int keymap[0x90] = {
d128 24
d155 1
a155 1
unsigned int bp,di,si,ds,es,dx,cx,bx,ax,ip,cs,flags;
d164 1
a164 1
unsigned int bp,di,si,ds,es,dx,cx,bx,ax,ip,cs,flags;
d199 1
a199 1
unsigned int bp,di,si,ds,es,dx,cx,bx,ax,ip,cs,flags;
@


1.1
log
@Initial revision
@
text
@d3 1
a3 2
 *	functions, maps and interrupt routines for TI Pro keyboards
 *	(see TI Technical Manual for nitty gritty details)
d5 1
a5 1
 * copyright (c) University of Toronto, 1988.
d7 1
a7 1
static char rcsid[] = "$Header$";
d85 1
a85 1
 * | aZ    aX  | aC  | aV  |	E - "6"  16 - "F1"	1E --> ansback
d188 1
a188 1
	/* remember old intr vectors */
d193 1
a193 1
	/* install new ones */
d201 1
a201 1
	f_vec = 1;	/* vectors installed */
d220 1
a220 1
	/* restore old intr vectors */
d228 1
a228 1
	f_vec = 0;	/* vectors reset */
d231 2
a232 1
nlmod(sw)	/* switch newline mode */
@