vt100esc.c

早期freebsd实现

	sp->s_current_stat &= ~ESCAPE;
}

/*
 *  character set to left graphic set
 *  esc_char_setl sets which character set you use in left graphic set.
 *  currently not supported
 */
esc_char_setl(sp, c)
	register SCREEN *sp;
	int c;
{
	sp->s_current_stat &= ~ESCAPE;
}

extern tmode;
extern  unsigned  int	first_jcode;
/*
 *  character set to kanji
 *  esc_kanji_set sets kanji
 */
esc_kanji_set(sp, c)
	register SCREEN *sp;
	int c;
{

#ifdef KM_JIS
	if (tmode == KM_JIS && (c == 'B' || c == '@')) {
		sp->s_current_stat |= JKANJI;
		first_jcode = 0;
	}
#endif
	sp->s_current_stat &= ~ESCAPE;
}

static short parm_buf[PARM_BUF_SIZ];
static short *parm_bp = parm_buf;
static int sensitive = 0;
static int pval = 0;
/*
 *  terminal parameter set command
 *  esc_parm_set(sp, c)  sets terminal parameters such as font-width, 
 *  font-height, character-width, character-height, character-position,
 *  underlind-position, screen-width, screen-height, x-offset, y-offset,
 *  right-mergin, bottom-mergin, dimmer-count, bell-length.
 */
esc_parm_set(sp, c)
	register SCREEN *sp;
	register unsigned int c;
{
	static int bufc = 0;

	if (in_str(c, sp->s_estp->terminators)) {
		if (sensitive) {
			*parm_bp++ = pval;
		} else {
			*parm_bp++ = -1;
		}
		*parm_bp++ = -1;
		parm_set(sp, parm_buf, c);
		sp->s_current_stat &= ~ESCAPE;
		sensitive = pval = 0;
		parm_bp = parm_buf;
		bufc = 0;
		return;
	}
	/*  buffering arguments  */
	if (bufc < PARM_BUF_SIZ) {
		if (c >= '0' && c <= '9') {
			pval = pval *10 + (c - '0');
			sensitive = 1;
		} else if (c == ';') {
			if (sensitive) {
				*parm_bp++ = pval;
			} else {
				*parm_bp++ = -1;
			}
			sensitive = pval = 0;
			bufc++;
		} else {
			sp->s_current_stat &= ~ESCAPE;
			sensitive = pval = 0;
			parm_bp = parm_buf;
			bufc = 0;
		}
	}
}

static	char	an_buf[AN_BUF_SIZ];

parm_set(sp, parm, terminator)
	SCREEN *sp;
	short *parm;
	unsigned int terminator;
{
	register char *bp = an_buf;
	register char *p;

	switch (terminator) {
	case 'f':
		if (parm[0] >= FONT_W_MIN && parm[0] <= consfb->font_w &&
							parm[0] < char_w)
			font_w =  parm[0];

		if (parm[1] >= FONT_H_MIN && parm[1] <= consfb->font_h &&
					parm[1] <= (char_h - ch_pos))
			font_h = parm[1];
		break;
	case 'c':
		if (parm[0] >= CHAR_W_MIN && parm[0] > font_w &&
						parm[0] <= CHAR_W_MAX)
			char_w = parm[0];

		if (parm[1] >= CHAR_H_MIN && parm[1] >= (font_h + ch_pos) &&
				parm[1] > ul_pos && parm[1] <= CHAR_H_MAX)
			char_h = parm[1];

		break;
	case 'p':
		if (parm[0] >= UL_POS_MIN && parm[0] <= UL_POS_MAX &&
						parm[0] < char_h) {
			ul_pos = parm[0];
		}
		if (parm[1] >= CH_POS_MIN && parm[1] <= CH_POS_MAX &&
					parm[1] < (char_h - font_h)) {
			ch_pos = parm[1];
		}
		break;
	case 's':
		if (parm[0] > SCR_W_MIN && parm[0] <= consfb->scr_w)
			scr_w = (parm[0] < char_w) ? char_w: parm[0];
		if (parm[1] > SCR_H_MIN && parm[1] <= consfb->scr_h)
			scr_h = (parm[1] < char_h) ? char_h: parm[1];
		break;
	case 'o':
		if (parm[0] >= X_OFST_MIN && parm[0] <= X_OFST_MAX)
			x_ofst = (parm[0] > scr_w - char_w) ?
				(scr_w - char_w): parm[0];
		if (parm[1] >= Y_OFST_MIN && parm[1] <= Y_OFST_MAX)
			y_ofst = (parm[1] > scr_h - char_h) ?
				(scr_h - char_h): parm[1];
		break;
	case 'm':
		if (parm[0] >= RIT_M_MIN) {
			if (parm[0] > RIT_M_MAX /* consfb->rit_m */) {
				parm[0] = consfb->rit_m;
			}
			rit_m = (parm[0] > (scr_w - x_ofst)/char_w) ?
				(scr_w - x_ofst)/char_w: parm[0];
		}
		if (parm[1] >= BTM_M_MIN) {
			if (parm[1] > BTM_M_MAX /* consfb->btm_m */) {
				parm[1] = consfb->btm_m;
			}
			btm_m = (parm[1] > (scr_h - y_ofst)/char_h) ?
				(scr_h - y_ofst)/char_h: parm[1];
		}
		break;
	case 'd':
		if (parm[0] >= DIM_CNT_MIN /* && parm[0] <= DIM_CNT_MAX */)
			dim_cnt = a_dim_on = parm[0];
		else
			a_dim_on = 0;
		break;
	case 'b':
		if (parm[0] >= BELL_LEN_MIN && parm[0] <= BELL_LEN_MAX)
			bell_len = parm[0];
		break;
	case 'D':
		set_default_param();
		vt100init();
		bitmapinit();
		break;
	case 'i':
		cursor_off();
		csr_pos(sp, LFT_M, TOP_M);
		key_str.key_string = c_pos_mess;
		key_str.key_length = spr(c_pos_mess, "f=(%d,%d), ",
							font_w, font_h);
		kbd_ioctl(SCC_KEYBOARD, KIOCBACK, &key_str);

		key_str.key_length = spr(c_pos_mess, "c=(%d,%d), ",
							char_w, char_h);
		kbd_ioctl(SCC_KEYBOARD, KIOCBACK, &key_str);

		csr_pos(sp, LFT_M, (TOP_M - 1));
		key_str.key_string = c_pos_mess;
		key_str.key_length = spr(c_pos_mess, "p=(%d,%d), ",
							ul_pos, ch_pos);
		kbd_ioctl(SCC_KEYBOARD, KIOCBACK, &key_str);
		key_str.key_length = spr(c_pos_mess, "s=(%d,%d), ",
							scr_w, scr_h);
		kbd_ioctl(SCC_KEYBOARD, KIOCBACK, &key_str);

		csr_pos(sp, LFT_M, (TOP_M - 2));
		key_str.key_string = c_pos_mess;
		key_str.key_length = spr(c_pos_mess, "o=(%d,%d), ",
							x_ofst, y_ofst);
		kbd_ioctl(SCC_KEYBOARD, KIOCBACK, &key_str);
		key_str.key_length = spr(c_pos_mess, "m=(%d,%d)",
							rit_m, btm_m);
		kbd_ioctl(SCC_KEYBOARD, KIOCBACK, &key_str);

		cursor_on(&sp->s_csr.csr_p);
		return;
	case 'G':
		line(parm);
		return;
	case 'C':
		if (parm[0] >= 0) {
			sp->s_plane = fbbm_get_pixel(consfb, parm[0]);
		}
		if (parm[1] >= 0) {
			sp->s_bgcol = fbbm_get_pixel(consfb, parm[1]);
		}
		cursor_off();
		if ((sp->s_csr.csr_attributes & REVERSE) ^
			(sp->s_term_mode & DECSCNM)) {
			fcolor = sp->s_bgcol;
			bcolor = sp->s_plane;
		}
		else {
			fcolor = sp->s_plane;
			bcolor = sp->s_bgcol;
		}
		cursor_on(&sp->s_csr.csr_p);
		return;
	case 'T':
		if (parm[0] < 0 || consfb->Mono)
			return;
		/*
		 *  what value is defined on pallet N?
		 *    put string in an_buf
		 */
		*bp++ = '\033';
		*bp++ = '~';
		bp += itoa(bm_pallet_read(parm[0]), 10, bp);
		*bp++ = 'a';
		key_str.key_length = bp - an_buf;
		key_str.key_string = an_buf;
		kbd_ioctl(SCC_KEYBOARD, KIOCBACK, &key_str);
		return;
	case 't':
		if (parm[0] >= 0 && !consfb->Mono) {
			bm_pallet_write(parm[0],
					(unsigned) parm[1] << 16
					| (unsigned) parm[2] << 8
					| (unsigned) parm[3]
			);
		}
		return;
	default:
		return;
	}
	if (char_w < font_w) char_w = font_w;
	if (char_h < font_h) char_h = font_h;
	if (ch_pos > char_h - font_h) {
		ch_pos = char_h - font_h;
		ul_pos = char_h - 1;
	}
	if (rit_m > (scr_w - x_ofst)/char_w)
		rit_m = (scr_w - x_ofst)/char_w;
	if (btm_m > (scr_h - y_ofst)/char_h)
		btm_m = (scr_h - y_ofst)/char_h;
	sp->s_region.top_margin = TOP_M;
	sp->s_region.btm_margin = btm_m;
	font_r1.extent.x = font_w;
	font_r1.extent.y = font_h;
	font_r2.extent.x = font_w * 2;
	font_r2.extent.y = font_h;
	font_len1 = (font_w + 0x0f)>>4;
	font_len2 = (font_w*2 + 0x0f)>>4;
	cursor_off();
	char_r1.extent.x = char_w;
	char_r1.extent.y = char_h;
	char_r2.extent.x = char_w * 2;
	char_r2.extent.y = char_h;
	csr_pos(sp, sp->s_csr.csr_x, sp->s_csr.csr_y);
	sp->s_csr.csr_p.x = (sp->s_csr.csr_x - 1) * char_w + x_ofst;
	sp->s_csr.csr_p.y = (sp->s_csr.csr_y - 1) * char_h + y_ofst;
	cursor_on(&sp->s_csr.csr_p);
}

/* VARARGS */
spr(s, fmt, ad, dummy)
	register char *s, *fmt;
	u_int ad;
{
	register int b, c;
	register u_int *adx = &ad;
	char *base = s;

	for (;;) {
		while ((c = *fmt++) != '%') {
			*s++ = c;
			if (c == '\0')
				return (s - base - 1);
		}

		c = *fmt++;
		switch (c) {

		case 'x': case 'X':
			b = 16;
			goto number;
		case 'd': case 'D':
			b = 10;
			goto number;
		case 'o': case 'O':
			b = 8;
number:
			s += itoa(*adx, b, s);
			break;

		case 'c':
			*s++ = *adx;
			break;

		case '%':
			*s++ = c;
			break;
		}
		adx++;
	}
}

static int pfn = -1;
static int active_buf = 0;
/*
 *  define the programable function keys and answer back message.
 *  the vt100 facilities do not contain this command!
 *  command sequence is as follows:
 *       "^[Pn|n1;n2;...;nmp"		(normal mode)
 *  or
 *       "^[Pn|n1;n2;...;nmP"		(shift mode)
 *  or
 *       "^[Pn|n1;n2;...;nmZ"		(answer backe message)
 *  where, `n' denotes the decimal number asigned to function key,
 *          from `n1' to `nm' denote hexa number, finally,
 *	    `p' , `E' or `Z' tells that the sequence has terminated.
 *  remark:
 *	  when the terminator is `Z', the function number `n' can be omitted,
 *	  and even though the number is specified, there is no affection to 
 *	  the result.
 *
 *
 *  ADDITION:
 *	  there is a question: what strings are defined in programable function
 *	  key of key-number n?
 *	  in order to anwer this question, another escape sequence has appended.
 *	  command sequence is as follows:
 *
 *	   "^[Pn|i"			(normal mode)
 *  or
 *	   "^[Pn|I"			(shift	mode)
 *
 *	  then the answer is 
 *
 *	   "^[Pn|n1;n2;...;nmr"		(normal	mode)
 *  or
 *	   "^[Pn|n1;n2;...;nmR"		(shift	mode)
 *
 */
esc_pf_define(sp, c)
	SCREEN *sp;
	unsigned int c;
{
	static bufc = 0;

	if (in_str(c, sp->s_estp->terminators)) {
		pf_define(pfn, esc_bp - esc_buf + active_buf, c);
		sp->s_current_stat &= ~ESCAPE;
		active_buf = 0;
		pfn = -1;
		bufc = 0;
		return;
	}
	/*  buffering arguments  */
	if (bufc < ESC_BUF_SIZ) {
		if (pfn < 0) {
			if (c >= '0' && c <= '9') {
				*esc_bp = *esc_bp *10 + (c - '0');
			} else if (c == '|') {
				pfn = *esc_bp;
				*esc_bp = 0;
			} else {
				sp->s_current_stat &= ~ESCAPE;
				active_buf = 0;
				pfn = -1;
			}
		} else {
			active_buf = 1;
			if (c >= '0' && c <= '9') {
				*esc_bp = *esc_bp * 16 + (c - '0');
			} else if (c >= 'a' && c <= 'f') {
				*esc_bp = *esc_bp * 16 + (c - 'a' + 10);
			} else if (c >= 'A' && c <= 'F') {
				*esc_bp = *esc_bp * 16 + (c - 'A' + 10);
			} else if (c == ';') {
				esc_bp++;
				bufc++;
			} else {
				sp->s_current_stat &= ~ESCAPE;
				pfn = -1;
				active_buf = 0;
				bufc = 0;
			}
		}
	} else {
		active_buf = 0;
	}
}

pf_define(pfn, length, terminator)
	int pfn;
	int length;
	unsigned int terminator;
{
	register Pfk_string *pfk = &pfk_str;
	register Key_string *kys = &pfk_str.pfk_string;

	if (terminator == 'Z')
		return;

	if (pfn < 0 || pfn > N_PFK)
		return;
	if (terminator == 'i' || terminator == 'I') {
		pf_answer(pfn, terminator);
		return;
	}
	pfk->pfk_num = pfn ? pfn: 1;
	pfk->pfk_shift = (terminator == 'p') ? PF_NORMAL: PF_SHIFT;
	kys->key_length = length;
	kys->key_string = esc_buf;
 	kbd_ioctl(SCC_KEYBOARD, KIOCSETS, pfk); 
}

/*
 *  pf_answer(pfn, terminator)
 *  this routine answers what strings defined on pfn.
 */

char def_seq[ESC_BUF_SIZ];

pf_answer(pfn, terminator)
	int pfn;
	unsigned int terminator;
{
	register Pfk_string *pfk = &pfk_str;
	register Key_string *kys = &pfk_str.pfk_string;
	register char *bp = an_buf;
	register char *p = def_seq;
	register int length;
	register int j;
	
	/*
	 *  function key inquiry
	 *    get string in def_seq
	 */
	pfk->pfk_num = pfn ? pfn: 1;
	pfk->pfk_shift = (terminator == 'i') ? PF_NORMAL: PF_SHIFT;
	kys->key_length = ESC_BUF_SIZ;
	kys->key_string = def_seq;
	kbd_ioctl(SCC_KEYBOARD, KIOCGETS, pfk);
	length = kys->key_length;

	/*
	 *  function key answer
	 *    put string in an_buf
	 */
	*bp++ = '\033';
	*bp++ = 'P';
	bp += itoa(pfn, 10, bp);
	*bp++ = '|';
	key_str.key_length = bp - an_buf;
	key_str.key_string = an_buf;
	kbd_ioctl(SCC_KEYBOARD, KIOCBACK, &key_str);

	bp = an_buf;
	if (length--) {
		bp += itoa(*p++ & 0xff, 16, bp);
	}
	while (length > 0) {
		for (j = 0; (j < 10) && (length-- > 0); j++) {
			*bp++ = ';';
			bp += itoa(*p++ & 0xff, 16, bp);
		}
		key_str.key_length = bp - an_buf;
		kbd_ioctl(SCC_KEYBOARD, KIOCBACK, (int *)&key_str);
		bp = an_buf;
	}
	*bp++ = (terminator == 'i') ? 'r': 'R';
	key_str.key_length = bp - an_buf;
	kbd_ioctl(SCC_KEYBOARD, KIOCBACK, (int *)&key_str);
}

/*
 *  ignore
 *  esc_ignore(sp) is not called ordinally work.
 */
esc_ignore(sp)
	register SCREEN *sp;
{
	sp->s_current_stat &= ~ESCAPE;
}

static  char	*nmr = "0123456789abcdef";
/*
 *  itoa
 *  this routine converts binary to ascii decimal or hexa number
 *  according to mod.
 */
static
itoa(n, mod, buf)
	register int n;
	register int mod;
	register char *buf;
{
	register  int	i = 0;
	register  int	cnt;
	int	first = 1;
	int	k;

	n &= 0xffff;
	for (cnt = mod*mod*mod*mod*mod*mod*mod; cnt > 0; cnt /= mod) {
		k = n / cnt;
		n -= k * cnt;
		if (k == 0) {
			if (first == 0) {
				*buf++ = nmr[k];
				i++;
			}
		} else {
			*buf++ = nmr[k];
			i++;
			first = 0;
		}
	}
	if (first == 1) {
		*buf++ = '0';
		i++;
	}
	return(i);
}