开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Modem编程 > 查看源码
vt100.c
资源名称：minicom-1.83.tar.gz　[点击查看]
上传用户：tianjinjs
上传日期：2007-01-05
资源大小：309k
文件大小：23k
源码类别：

Modem编程

开发平台：

Unix_Linux

vt100.c：源码内容
  1. /*
  2.  * vt100.c ANSI/VT102 emulator code.
  3.  * This code was integrated to the Minicom communications
  4.  * package, but has been reworked to allow usage as a separate
  5.  * module.
  6.  *
  7.  * It's not a "real" vt102 emulator - it's more than that:
  8.  * somewhere between vt220 and vt420 in commands.
  9.  *
  10.  * This file is part of the minicom communications package,
  11.  * Copyright 1991-1995 Miquel van Smoorenburg.
  12.  *
  13.  * This program is free software; you can redistribute it and/or
  14.  * modify it under the terms of the GNU General Public License
  15.  * as published by the Free Software Foundation; either version
  16.  * 2 of the License, or (at your option) any later version.
  17.  *
  18.  * // jl 04.09.97 character map conversions in and out
  19.  *    jl 06.07.98 use conversion tables with the capture file
  20.  */
  21. #include "port.h"
  22. #include "window.h"
  23. #include "vt100.h"
  24. #include "config.h"
  25. #include "configsym.h"
  26. #include "patchlevel.h"
  28. #define OLD 0
  30. /*
  31.  * The global variable esc_s holds the escape sequence status:
  32.  * 0 - normal
  33.  * 1 - ESC
  34.  * 2 - ESC [
  35.  * 3 - ESC [ ?
  36.  * 4 - ESC (
  37.  * 5 - ESC )
  38.  * 6 - ESC #
  39.  * 7 - ESC P
  40.  */
  41. static int esc_s = 0;
  43. #define ESC 27
  45. /* Structure to hold escape sequences. */
  46. struct escseq {
  47.   int code;
  48.   char *vt100_st;
  49.   char *vt100_app;
  50.   char *ansi;
  51. };
  53. /* Escape sequences for different terminal types. */
  54. static struct escseq vt_keys[] = {
  55. #ifndef _DGUX_SOURCE
  56.   { K_F1, "OP", "OP", "OP" },
  57.   { K_F2, "OQ", "OQ", "OQ" },
  58.   { K_F3, "OR", "OR", "OR" },
  59.   { K_F4, "OS", "OS", "OS" },
  60.   { K_F5, "[16~", "[16~", "OT" },
  61.   { K_F6, "[17~", "[17~", "OU" },
  62.   { K_F7, "[18~", "[18~", "OV" },
  63.   { K_F8, "[19~", "[19~", "OW" },
  64.   { K_F9, "[20~", "[20~", "OX" },
  65.   { K_F10, "[21~", "[21~", "OY" },
  66.   { K_F11, "[23~", "[23~", "OY" },
  67.   { K_F12, "[24~", "[24~", "OY" },
  68.   { K_HOME, "[1~", "[1~", "[H" },
  69.   { K_PGUP, "[5~", "[5~", "[V" },
  70.   { K_UP, "[A", "OA", "[A" },
  71.   { K_LT, "[D", "OD", "[D" },
  72.   { K_RT, "[C", "OC", "[C" },
  73.   { K_DN, "[B", "OB", "[B" },
  74.   { K_END, "[4~", "[4~", "[Y" },
  75.   { K_PGDN, "[6~", "[6~", "[U" },
  76.   { K_INS, "[2~", "[2~", "[@" },
  77.   { K_DEL, "[3~", "[3~", "177" },
  78.   { 0, NULL, NULL, NULL }
  79. #else
  80.   { K_F1,      "[17~", "[17~", "OP" },
  81.   { K_F2,      "[18~", "[18~", "OQ" },
  82.   { K_F3,      "[19~", "[19~", "OR" },
  83.   { K_F4,      "[20~", "[20~", "OS" },
  84.   { K_F5,      "[21~", "[21~", "OT" },
  85.   { K_F6,      "[23~", "[23~", "OU" },
  86.   { K_F7,      "[24~", "[24~", "OV" },
  87.   { K_F8,      "[25~", "[25~", "OW" },
  88.   { K_F9,      "[26~", "[26~", "OX" },
  89.   { K_F10,     "[28~", "[28~", "OY" },
  90.   { K_F11,     "[29~", "[29~", "OZ" },
  91.   { K_F12,     "[31~", "[31~", "OA" },
  92.   { K_HOME,    "OP",   "OP",   "[H" },
  93.   { K_PGUP,    "OQ",   "OQ",   "[V" },
  94.   { K_UP,      "[A",   "OA",   "[A" },
  95.   { K_LT,      "[D",   "OD",   "[D" },
  96.   { K_RT,      "[C",   "OC",   "[C" },
  97.   { K_DN,      "[B",   "OB",   "[B" },
  98.   { K_END,     "OR",   "OR",   "[Y" },
  99.   { K_PGDN,    "OS",   "OS",   "[U" },
  100.   { K_INS,     "[1~",  "[1~",  "[@"  },
  101.   { K_DEL,     "[3~",  "[3~",  "177" },
  102.   { 0,         NULL,   NULL,   NULL }
  103. #endif
  104. };
  106. /* Two tables for user-defined character map conversions.
  107.  * defmap.h should contain all characters 0-255 in ascending order
  108.  * to default to no conversion.    jl 04.09.1997
  109.  */
  111. unsigned char vt_inmap[256] = {
  112. #include "defmap.h"
  113. };
  114. unsigned char vt_outmap[256] = {
  115. #include "defmap.h"
  116. };
  118. #if TRANSLATE
  119. /* Taken from the Linux kernel source: linux/drivers/char/console.c */
  120. static unsigned char * vt_map[] = {
  121. /* 8-bit Latin-1 mapped to the PC character set: '.' means non-printable */
  122. (unsigned char *)
  123. "................"
  124. "................"
  125. " !"#$%&'()*+,-./0123456789:;<=>?"
  126. "@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_"
  127. "`abcdefghijklmnopqrstuvwxyz{|}~."
  128. "................"
  129. "................"
  130. "3772552332343762351742537637624625625255376376"
  131. "37036137537637634624371376376247257254253376250"
  132. "376376376376216217222200376220376376376376376376"
  133. "376245376376376376231376350376376376232376376341"
  134. "205240203376204206221207212202210211215241214213"
  135. "376244225242223376224366355227243226201376376230",
  136. /* vt100 graphics */
  137. (unsigned char *)
  138. "................"
  139. "376"
  140. " !"#$%&'()*+,-./0123456789:;<=>?"
  141. "@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^ "
  142. "04261070707073703610707331277332300305304"
  143. "30430413713730326430130226336336234333023407"
  144. "................"
  145. "................"
  146. "3772552332343762351742537637624625625255376376"
  147. "37036137537637634624371376376247257254253376250"
  148. "376376376376216217222200376220376376376376376376"
  149. "376245376376376376231376376376376376232376376341"
  150. "205240203376204206221207212202210211215241214213"
  151. "376244225242223376224366376227243226201376376230"
  152. };
  153. static char *vt_trans[2];
  154. static int vt_charset = 0; /* Character set. */
  155. #endif
  157. #ifdef _SELECT
  158. static int vt_echo; /* Local echo on/off. */
  159. #endif
  160. int vt_nl_delay; /* Delay after CR key */
  161. static int vt_type   = ANSI; /* Terminal type. */
  162. static int vt_wrap   = 0; /* Line wrap on/off */
  163. static int vt_addlf  = 0; /* Add linefeed on/off */
  164. static int vt_fg; /* Standard foreground color. */
  165. static int vt_bg; /* Standard background color. */
  166. static int vt_keypad; /* Keypad mode. */
  167. static int vt_cursor; /* cursor key mode. */
  168. static int vt_asis = 0; /* 8bit clean mode. */
  169. static int vt_bs = 8; /* Code that backspace key sends. */
  170. static int vt_insert = 0; /* Insert mode */
  171. static int vt_crlf = 0; /* Return sends CR/LF */
  172. static int vt_om; /* Origin mode. */
  173. WIN *vt_win          = NIL_WIN; /* Output window. */
  174. static int vt_docap; /* Capture on/off. */
  175. static FILE *vt_capfp; /* Capture file. */
  176. static void (*vt_keyb)(); /* Gets called for NORMAL/APPL switch. */
  177. static void (*termout)(); /* Gets called to output a string. */
  179. static int escparms[8]; /* Cumulated escape sequence. */
  180. #if OLD
  181. static int ptr = -2; /* Index into escparms array. */
  182. #else
  183. static int ptr = 0; /* Index into escparms array. */
  184. #endif
  185. static long vt_tabs[5]; /* Tab stops for max. 32*5 = 160 columns. */
  187. short newy1 = 0; /* Current size of scrolling region. */
  188. short newy2 = 23;
  190. /* Saved color and posistions */
  191. static short savex = 0, savey = 0, saveattr = XA_NORMAL, savecol = 112;
  193. #if TRANSLATE
  194. static short savecharset;
  195. static char *savetrans[2];
  196. #endif
  198. /*
  199.  * Initialize the emulator once.
  200.  */
  201. void vt_install(fun1, fun2, win)
  202. void (*fun1)();
  203. void (*fun2)();
  204. WIN *win;
  205. {
  206.   termout = fun1;
  207.   vt_keyb = fun2;
  208.   vt_win = win;
  209. }
  211. /* Partial init (after screen resize) */
  212. void vt_pinit(win, fg, bg)
  213. WIN *win;
  214. int fg, bg;
  215. {
  216.   vt_win = win;
  217.   newy1 = 0;
  218.   newy2 = vt_win->ys - 1;
  219.   wresetregion(vt_win);
  220.   if (fg > 0) vt_fg = fg;
  221.   if (bg > 0) vt_bg = bg;
  222.   wsetfgcol(vt_win, vt_fg);
  223.   wsetbgcol(vt_win, vt_bg);
  224. }
  226. /* Set characteristics of emulator. */
  227. void vt_init(type, fg, bg, wrap, add)
  228. int type;
  229. int fg;
  230. int bg;
  231. int wrap;
  232. int add;
  233. {
  234.   vt_type = type;
  235.   if (vt_type == ANSI) {
  236. vt_fg = WHITE;
  237. vt_bg = BLACK;
  238.   } else {
  239. vt_fg = fg;
  240. vt_bg = bg;
  241.   }
  242.   if (wrap >= 0) vt_win->wrap = vt_wrap = wrap;
  243.   vt_addlf = add;
  244.   vt_insert = 0;
  245.   vt_crlf = 0;
  246.   vt_om = 0;
  248.   newy1 = 0;
  249.   newy2 = vt_win->ys - 1;
  250.   wresetregion(vt_win);
  251.   vt_keypad = NORMAL;
  252.   vt_cursor = NORMAL;
  253. #ifdef _SELECT
  254.   vt_echo = 0;
  255. #endif
  256.   vt_tabs[0] = 0x01010100;
  257.   vt_tabs[1] =
  258.   vt_tabs[2] =
  259.   vt_tabs[3] =
  260.   vt_tabs[4] = 0x01010101;
  261. #if TRANSLATE
  262.   vt_charset = 0;
  263.   vt_trans[0] = vt_map[0];
  264.   vt_trans[1] = vt_map[1];
  265. #endif
  266. #if OLD
  267.   ptr = -2;
  268. #else
  269.   ptr = 0;
  270.   memset(escparms, 0, sizeof(escparms));
  271. #endif
  272.   esc_s = 0;
  274.   if (vt_keyb) (*vt_keyb)(vt_keypad, vt_cursor);
  275.   wsetfgcol(vt_win, vt_fg);
  276.   wsetbgcol(vt_win, vt_bg);
  277. }
  279. /* Change some things on the fly. */
  280. void vt_set(addlf, wrap, capfp, docap, bscode, echo, cursor, asis)
  281. int addlf;
  282. int wrap;
  283. FILE *capfp;
  284. int docap;
  285. int bscode;
  286. int echo;
  287. int cursor;
  288. int asis;
  289. {
  290.   if (addlf >= 0) vt_addlf = addlf;
  291.   if (wrap >= 0)  vt_win->wrap = vt_wrap = wrap;
  292.   if (capfp != (FILE *)0) vt_capfp = capfp;
  293.   if (docap >= 0) vt_docap = docap;
  294.   if (bscode >= 0) vt_bs = bscode;
  295. #ifdef _SELECT
  296.   if (echo >= 0) vt_echo = echo;
  297. #endif
  298.   if (cursor >= 0) vt_cursor = cursor;
  299.   if (asis >=0) vt_asis = asis;
  300. }
  302. /* Output a string to the modem. */
  303. static void v_termout(s, len)
  304. char *s;
  305. int len;
  306. {
  307. #ifdef _SELECT
  308.   char *p;
  310.   if (vt_echo) {
  311. for(p = s; *p; p++) {
  312. vt_out(*p);
  313. if (!vt_addlf && *p == 'r') vt_out('n');
  314. }
  315. wflush();
  316.   }
  317. #endif
  318.   (*termout)(s, len);
  319. }
  321. /*
  322.  * Escape code handling.
  323.  */
  325. /*
  326.  * ESC was seen the last time. Process the next character.
  327.  */
  328. static void state1(c)
  329. int c;
  330. {
  331.   short x, y, f;
  333.   switch(c) {
  334. case '[': /* ESC [ */
  335. esc_s = 2;
  336. return;
  337. case '(': /* ESC ( */
  338. esc_s = 4;
  339. return;
  340. case ')': /* ESC ) */
  341. esc_s = 5;
  342. return;
  343. case '#': /* ESC # */
  344. esc_s = 6;
  345. return;
  346. case 'P': /* ESC P (DCS, Device Control String) */
  347. esc_s = 7;
  348. return;
  349. case 'D': /* Cursor down */
  350. case 'M': /* Cursor up */
  351. x = vt_win->curx;
  352. if (c == 'D')  { /* Down. */
  353. y = vt_win->cury + 1;
  354. if (y == newy2 + 1)
  355. wscroll(vt_win, S_UP);
  356. else if (vt_win->cury < vt_win->ys)
  357. wlocate(vt_win, x, y);
  358. }
  359. if (c == 'M')  { /* Up. */
  360. y = vt_win->cury - 1;
  361. if (y == newy1 - 1)
  362. wscroll(vt_win, S_DOWN);
  363. else if (y >= 0)
  364. wlocate(vt_win, x, y);
  365. }
  366. break;
  367. case 'E': /* CR + NL */
  368.   wputs(vt_win, "rn");
  369.   break;
  370.   case '7': /* Save attributes and cursor position */
  371.   case 's':
  372.   savex = vt_win->curx;
  373.   savey = vt_win->cury;
  374.   saveattr = vt_win->attr;
  375.   savecol = vt_win->color;
  376. #if TRANSLATE
  377. savecharset = vt_charset;
  378. savetrans[0] = vt_trans[0];
  379. savetrans[1] = vt_trans[1];
  380. #endif
  381.   break;
  382.   case '8': /* Restore them */
  383.   case 'u':
  384. #if TRANSLATE
  385. vt_charset = savecharset;
  386. vt_trans[0] = savetrans[0];
  387. vt_trans[1] = savetrans[1];
  388. #endif
  389.   vt_win->color = savecol; /* HACK should use wsetfgcol etc */
  390.   wsetattr(vt_win, saveattr);
  391.   wlocate(vt_win, savex, savey);
  392.   break;
  393.   case '=': /* Keypad into applications mode */
  394. vt_keypad = APPL;
  395. if (vt_keyb) (*vt_keyb)(vt_keypad, vt_cursor);
  396.   break;
  397.   case '>': /* Keypad into numeric mode */
  398.   vt_keypad = NORMAL;
  399. if (vt_keyb) (*vt_keyb)(vt_keypad, vt_cursor);
  400.   break;
  401.   case 'Z': /* Report terminal type */
  402. if (vt_type == VT100)
  403. v_termout("33[?1;0c", 0);
  404.   else
  405.   v_termout("33[?c", 0);
  406.   break;
  407.   case 'c': /* Reset to initial state */
  408.   f = XA_NORMAL;
  409.   wsetattr(vt_win, f);
  410. vt_win->wrap = (vt_type != VT100);
  411. if (vt_wrap != -1) vt_win->wrap = vt_wrap;
  412. vt_crlf = vt_insert = 0;
  413. vt_init(vt_type, vt_fg, vt_bg, vt_win->wrap, 0);
  414.   wlocate(vt_win, 0, 0);
  415.   break;
  416.   case 'H': /* Set tab in current position */
  417. x = vt_win->curx;
  418. if (x > 159) x = 159;
  419. vt_tabs[x / 32] |= 1 << (x % 32);
  420. break;
  421.   case 'N': /* G2 character set for next character only*/
  422.   case 'O': /* G3 " "    */
  423.   case '<': /* Exit vt52 mode */
  424.   default:
  425.   /* ALL IGNORED */
  426.   break;
  427.   }
  428.   esc_s = 0;
  429.   return;
  430. }
  432. /* ESC [ ... [hl] seen. */
  433. static void ansi_mode(on_off)
  434. int on_off;
  435. {
  436.   int i;
  438.   for(i = 0; i <= ptr; i++) {
  439. switch(escparms[i]) {
  440. case 4: /* Insert mode  */
  441. vt_insert = on_off;
  442. break;
  443. case 20: /* Return key mode */
  444. vt_crlf = on_off;
  445. break;
  446. }
  447.   }
  448. }
  450. /*
  451.  * ESC [ ... was seen the last time. Process next character.
  452.  */
  453. static void state2(c)
  454. int c;
  455. {
  456.   short x, y, attr, f;
  457.   char temp[32];
  459.   /* See if a number follows */
  460.   if (c >= '0' && c <= '9') {
  461. #if OLD
  462. if (ptr < 0) ptr = 0;
  463. #endif
  464. escparms[ptr] = 10*(escparms[ptr]) + c - '0';
  465. return;
  466.   }
  467.   /* Separation between numbers ? */
  468.   if (c == ';') {
  469. #if OLD
  470. if (ptr < 0) ptr = 0; /* keithr@primenet.com */
  471. if (ptr >= 0 && ptr < 15) ptr++;
  472. #else
  473. if (ptr < 15) ptr++;
  474. #endif
  475. return;
  476.   }
  477.   /* ESC [ ? sequence */
  478. #if OLD
  479.   if (ptr < 0 && c == '?') {
  480. #else
  481.   if (escparms[0] == 0 && ptr == 0 && c == '?') {
  482. #endif
  483. esc_s = 3;
  484. return;
  485.   }
  487.   /* Process functions with zero, one, two or more arguments */
  488.   switch(c) {
  489. case 'A':
  490. case 'B':
  491. case 'C':
  492. case 'D': /* Cursor motion */
  493. if ((f = escparms[0]) == 0) f = 1;
  494. x = vt_win->curx;
  495. y = vt_win->cury;
  496. x += f * ((c == 'C') - (c == 'D'));
  497. if (x < 0) x = 0;
  498. if (x >= vt_win->xs) x = vt_win->xs - 1;
  499. if (c == 'B') { /* Down. */
  500. y += f;
  501. if (y >= vt_win->ys) y = vt_win->ys - 1;
  502. if (y >= newy2 + 1) y = newy2;
  503. }
  504. if (c == 'A') { /* Up. */
  505. y -= f;
  506.   if (y < 0) y = 0;
  507. if (y <= newy1 - 1) y = newy1;
  508. }
  509. wlocate(vt_win, x, y);
  510. break;
  511. case 'K': /* Line erasing */
  512. switch(escparms[0]) {
  513. case 0:
  514. wclreol(vt_win);
  515. break;
  516. case 1:
  517. wclrbol(vt_win);
  518. break;
  519. case 2:
  520. wclrel(vt_win);
  521. break;
  522. }
  523. break;
  524. case 'J': /* Screen erasing */
  525. x = vt_win->color;
  526. y = vt_win->attr;
  527. if (vt_type == ANSI) {
  528. wsetattr(vt_win, XA_NORMAL);
  529. wsetfgcol(vt_win, WHITE);
  530. wsetbgcol(vt_win, BLACK);
  531. }
  532. switch(escparms[0]) {
  533. case 0:
  534. wclreos(vt_win);
  535. break;
  536. case 1:
  537. wclrbos(vt_win);
  538. break;
  539. case 2:
  540. winclr(vt_win);
  541. break;
  542. }
  543. if (vt_type == ANSI) {
  544. vt_win->color = x;
  545. vt_win->attr = y;
  546. }
  547. break;
  548. case 'n': /* Requests / Reports */
  549. switch(escparms[0]) {
  550. case 5: /* Status */
  551. v_termout("33[0n", 0);
  552. break;
  553. case 6: /* Cursor Position */
  554. sprintf(temp, "33[%d;%dR", 
  555. vt_win->cury + 1, vt_win->curx + 1);
  556. v_termout(temp, 0);
  557. break;
  558. }
  559. break;
  560. case 'c': /* Identify Terminal Type */
  561. if (vt_type == VT100) {
  562. v_termout("33[?1;2c", 0);
  563. break;
  564. }
  565. v_termout("33[?c", 0);
  566. break;
  567. case 'x': /* Request terminal parameters. */
  568.   /* Always answers 19200-8N1 no options. */
  569. sprintf(temp, "33[%c;1;1;120;120;1;0x",
  570. escparms[0] == 1 ? '3' : '2');
  571. v_termout(temp, 0);
  572. break;
  573.   case 's': /* Save attributes and cursor position */
  574.   savex = vt_win->curx;
  575.   savey = vt_win->cury;
  576.   saveattr = vt_win->attr;
  577.   savecol = vt_win->color;
  578. #if TRANSLATE
  579. savecharset = vt_charset;
  580. savetrans[0] = vt_trans[0];
  581. savetrans[1] = vt_trans[1];
  582. #endif
  583.   break;
  584.   case 'u': /* Restore them */
  585. #if TRANSLATE
  586. vt_charset = savecharset;
  587. vt_trans[0] = savetrans[0];
  588. vt_trans[1] = savetrans[1];
  589. #endif
  590.   break;
  591.   vt_win->color = savecol; /* HACK should use wsetfgcol etc */
  592.   wsetattr(vt_win, saveattr);
  593.   wlocate(vt_win, savex, savey);
  594.   break;
  595. case 'h':
  596. ansi_mode(1);
  597. break;
  598. case 'l':
  599. ansi_mode(0);
  600. break;
  601. case 'H':
  602. case 'f': /* Set cursor position */
  603. if ((y = escparms[0]) == 0) y = 1;
  604. if ((x = escparms[1]) == 0) x = 1;
  605. if (vt_om) y += newy1;
  606. wlocate(vt_win, x - 1, y - 1);
  607. break;
  608. case 'g': /* Clear tab stop(s) */
  609. if (escparms[0] == 0) {
  610. x = vt_win->curx;
  611. if (x > 159) x = 159;
  612. vt_tabs[x / 32] &= ~ (1 << x % 32);
  613. }
  614. if (escparms[0] == 3)
  615. for(x = 0; x < 5; x++) vt_tabs[x] = 0;
  616. break;
  617. case 'm': /* Set attributes */
  618. #if OLD
  619.   /* Without argument, esc-parms[0] is 0 */
  620. if (ptr < 0) ptr = 0;  
  621. #endif
  622. attr = wgetattr((vt_win));
  623. for (f = 0; f <= ptr; f++) {
  624.     if (escparms[f] >= 30 && escparms[f] <= 37)
  625. wsetfgcol(vt_win, escparms[f] - 30);
  626.     if (escparms[f] >= 40 && escparms[f] <= 47)
  627. wsetbgcol(vt_win, escparms[f] - 40);
  628.     switch(escparms[f]) {
  629. case 0:
  630. attr = XA_NORMAL;
  631. wsetfgcol(vt_win, vt_fg);
  632. wsetbgcol(vt_win, vt_bg);
  633. break;
  634. case 4:
  635. attr |= XA_UNDERLINE;
  636. break;
  637. case 7:
  638. attr |= XA_REVERSE;
  639. break;
  640. case 1:
  641. attr |= XA_BOLD;
  642. break;
  643. case 5:
  644. attr |= XA_BLINK;
  645. break;
  646. case 22: /* Bold off */
  647. attr &= ~XA_BOLD;
  648. break;
  649. case 24: /* Not underlined */
  650. attr &=~XA_UNDERLINE;
  651. break;
  652. case 25: /* Not blinking */
  653. attr &= ~XA_BLINK;
  654. break;
  655. case 27: /* Not reverse */
  656. attr &= ~XA_REVERSE;
  657. break;
  658. case 39: /* Default fg color */
  659. wsetfgcol(vt_win, vt_fg);
  660. break;
  661. case 49: /* Default bg color */
  662. wsetbgcol(vt_win, vt_bg);
  663. break;
  665.     }
  666. }
  667. wsetattr(vt_win, attr);
  668. break;
  669. case 'L': /* Insert lines */
  670. if ((x = escparms[0]) == 0) x = 1;
  671. for(f = 0; f < x; f++)
  672. winsline(vt_win);
  673. break;
  674. case 'M': /* Delete lines */
  675. if ((x = escparms[0]) == 0) x = 1;
  676. for(f = 0; f < x; f++)
  677. wdelline(vt_win);
  678. break;
  679. case 'P': /* Delete Characters */
  680. if ((x = escparms[0]) == 0) x = 1;
  681. for(f = 0; f < x; f++)
  682. wdelchar(vt_win);
  683. break;
  684. case '@': /* Insert Characters */
  685. if ((x = escparms[0]) == 0) x = 1;
  686. for(f = 0; f < x; f++)
  687. winschar(vt_win);
  688. break;
  689. case 'r': /* Set scroll region */
  690. if ((newy1 = escparms[0]) == 0) newy1 = 1;
  691. if ((newy2 = escparms[1]) == 0) newy2 = vt_win->ys;
  692. newy1-- ; newy2--;
  693. if (newy1 < 0) newy1 = 0;
  694. if (newy2 < 0) newy2 = 0;
  695. if (newy1 >= vt_win->ys) newy1 = vt_win->ys - 1;
  696. if (newy2 >= vt_win->ys) newy2 = vt_win->ys - 1;
  697. if (newy1 >= newy2) {
  698. newy1 = 0;
  699. newy2 = vt_win->ys - 1;
  700. }
  701. wsetregion(vt_win, newy1, newy2);
  702. wlocate(vt_win, 0, newy1);
  703. break;
  704. case 'i': /* Printing */
  705. case 'y': /* Self test modes */
  706. default:
  707. /* IGNORED */
  708. break;
  709.   }
  710.   /* Ok, our escape sequence is all done */
  711.   esc_s = 0;
  712. #if OLD
  713.   ptr = -2;
  714. #else
  715.   ptr = 0;
  716.   memset(escparms, 0, sizeof(escparms));
  717. #endif
  718.   return;
  719. }
  720.   
  721. /* ESC [? ... [hl] seen. */
  722. static void dec_mode(on_off)
  723. int on_off;
  724. {
  725.   int i;
  727.   for(i = 0; i <= ptr; i++) {
  728. switch(escparms[i]) {
  729. case 1: /* Cursor keys in cursor/appl mode */
  730. vt_cursor = on_off ? APPL : NORMAL;
  731. if (vt_keyb) (*vt_keyb)(vt_keypad, vt_cursor);
  732. break;
  733. case 6: /* Origin mode. */
  734. vt_om = on_off;
  735. wlocate(vt_win, 0, newy1);
  736. break;
  737. case 7: /* Auto wrap */
  738. vt_win->wrap = on_off;
  739. break;
  740. case 25: /* Cursor on/off */
  741. wcursor(vt_win, on_off ? CNORMAL : CNONE);
  742. break;
  743. case 67: /* Backspace key sends. (FIXME: vt420) */
  744. /* setbackspace(on_off ? 8 : 127); */
  745. break;
  746. default: /* Mostly set up functions */
  747. /* IGNORED */
  748. break;
  749. }
  750.   }
  751. }
  753. /*
  754.  * ESC [ ? ... seen.
  755.  */
  756. static void state3(c)
  757. int c;
  758. {
  759.   /* See if a number follows */
  760.   if (c >= '0' && c <= '9') {
  761. #if OLD
  762. if (ptr < 0) ptr = 0;
  763. #endif
  764. escparms[ptr] = 10*(escparms[ptr]) + c - '0';
  765. return;
  766.   }
  767. #if OLD
  768.   /* ESC [ ? number seen */
  769.   if (ptr < 0) {
  770. esc_s = 0;
  771. return;
  772.   }
  773. #endif
  774.   switch(c) {
  775. case 'h':
  776. dec_mode(1);
  777. break;
  778. case 'l':
  779. dec_mode(0);
  780. break;
  781. case 'i': /* Printing */
  782. case 'n': /* Request printer status */
  783. default:
  784. /* IGNORED */
  785. break;
  786.   }
  787.   esc_s = 0;
  788. #if OLD
  789.   ptr = -2;
  790. #else
  791.   ptr = 0;
  792.   memset(escparms, 0, sizeof(escparms));
  793. #endif
  794.   return;
  795. }
  797. /*
  798.  * ESC ( Seen.
  799.  */
  800. /*ARGSUSED*/
  801. static void state4(c)
  802. int c;
  803. {
  804.   /* Switch Character Sets. */
  805. #if !TRANSLATE
  806.   /* IGNORED */
  807.   (void)c;
  808. #else
  809.   switch(c) {
  810. case 'A':
  811. case 'B':
  812. vt_trans[0] = vt_map[0];
  813. break;
  814. case '0':
  815. case 'O':
  816. vt_trans[0] = vt_map[1];
  817. break;
  818.   }
  819. #endif
  820.   esc_s = 0;
  821. }
  823. /*
  824.  * ESC ) Seen.
  825.  */
  826. /*ARGSUSED*/
  827. static void state5(c)
  828. int c;
  829. {
  830.   /* Switch Character Sets. */
  831. #if !TRANSLATE
  832.   /* IGNORED */
  833.   (void)c;
  834. #else
  835.   switch(c) {
  836. case 'A':
  837. case 'B':
  838. vt_trans[1] = vt_map[0];
  839. break;
  840. case 'O':
  841. case '0':
  842. vt_trans[1] = vt_map[1];
  843. break;
  844.   }
  845. #endif
  846.   esc_s = 0;
  847. }
  849. /*
  850.  * ESC # Seen.
  851.  */
  852. /*ARGSUSED*/
  853. static void state6(c)
  854. int c;
  855. {
  856.   int x, y;
  858.   /* Double height, double width and selftests. */
  859.   switch(c) {
  860. case '8':
  861. /* Selftest: fill screen with E's */
  862. vt_win->doscroll = 0;
  863. vt_win->direct = 0;
  864. wlocate(vt_win, 0, 0);
  865. for(y = 0; y < vt_win->ys; y++) {
  866. wlocate(vt_win, 0, y);
  867. for(x = 0; x < vt_win->xs; x++)
  868. wputc(vt_win, 'E');
  869. }
  870. wlocate(vt_win, 0, 0);
  871. vt_win->doscroll = 1;
  872. wredraw(vt_win, 1);
  873. break;
  874. default:
  875. /* IGNORED */
  876. break;
  877.   }
  878.   esc_s = 0;
  879. }
  881. /*
  882.  * ESC P Seen.
  883.  */
  884. static void state7(c)
  885. int c;
  886. {
  887.   /*
  888.    * Device dependant control strings. The Minix virtual console package
  889.    * uses these sequences. We can only turn cursor on or off, because
  890.    * that's the only one supported in termcap. The rest is ignored.
  891.    */
  892.   static char buf[17];
  893.   static int pos = 0;
  894.   static int state = 0;
  896.   if (c == ESC) {
  897.    state = 1;
  898.    return;
  899.   }
  900.   if (state == 1) {
  901.    buf[pos] = 0;
  902.    pos = 0;
  903.    state = 0;
  904.    esc_s = 0;
  905.    if (c != '\') return;
  906.    /* Process string here! */
  907.    if (!strcmp(buf, "cursor.on")) wcursor(vt_win, CNORMAL);
  908.    if (!strcmp(buf, "cursor.off")) wcursor(vt_win, CNONE);
  909.    if (!strcmp(buf, "linewrap.on")) {
  910.    vt_wrap = -1;
  911.    vt_win->wrap = 1;
  912.    }
  913.    if (!strcmp(buf, "linewrap.off")) {
  914.    vt_wrap = -1;
  915.    vt_win->wrap = 0;
  916.    }
  917.    return;
  918.   }
  919.   if (pos > 15) return;
  920.   buf[pos++] = c;
  921. }
  923. void vt_out(ch)
  924. int ch;
  925. {
  926.   int f;
  927.   unsigned char c;
  928.   int go_on = 0;
  930.   if (!ch) return;
  932. #if OLD
  933.   if (ptr == -2) { /* Initialize */
  934. ptr = -1;
  935. for(f = 0; f < 8; f++) escparms[f] = 0;
  936.   }
  937. #endif
  939.   c = (unsigned char)ch;
  940.   
  941.   if (vt_docap == 2) /* Literal. */
  942. fputc(c, vt_capfp);
  944.   /* Process <31 chars first, even in an escape sequence. */
  945.   switch(c) {
  946. case 5: /* AnswerBack for vt100's */
  947. if (vt_type != VT100) {
  948. go_on = 1;
  949. break;
  950. }
  951. v_termout(SCCS_ID, 0);
  952. break;
  953. case 'r': /* Carriage return */
  954. wputc(vt_win, c);
  955. if (vt_addlf) {
  956. wputc(vt_win, 'n');
  957. if (vt_docap == 1)
  958. fputc('n', vt_capfp);
  959. }
  960. break;
  961. case 't': /* Non - destructive TAB */
  962. /* Find next tab stop. */
  963. for(f = vt_win->curx + 1; f < 160; f++)
  964. if (vt_tabs[f / 32] & (1 << f % 32)) break;
  965. if (f >= vt_win->xs) f = vt_win->xs - 1;
  966. wlocate(vt_win, f, vt_win->cury);
  967. if (vt_docap == 1) fputc(c, vt_capfp);
  968. break;
  969. case 013: /* Old Minix: CTRL-K = up */
  970. wlocate(vt_win, vt_win->curx, vt_win->cury - 1);
  971. break;
  972. case 'f': /* Form feed: clear screen. */
  973. winclr(vt_win);
  974. wlocate(vt_win, 0, 0);
  975. break;
  976. #if !TRANSLATE
  977. case 14:
  978. case 15:  /* Change character set. Not supported. */
  979. break;
  980. #else
  981. case 14:
  982. vt_charset = 1;
  983. break;
  984. case 15:
  985. vt_charset = 0;
  986. break;
  987. #endif
  988. case 24:
  989. case 26:  /* Cancel escape sequence. */
  990. esc_s = 0;
  991. break;
  992. case ESC: /* Begin escape sequence */
  993. esc_s = 1;
  994. break;
  995. case 128+ESC: /* Begin ESC [ sequence. */
  996. esc_s = 2;
  997. break;
  998. case 'n':
  999. case 'b':
  1000. case 7: /* Bell */
  1001. wputc(vt_win, c);
  1002. if (vt_docap == 1)
  1003. fputc(c, vt_capfp);
  1004. break;
  1005. default:
  1006. go_on = 1;
  1007. break;
  1008.   }
  1009.   if (!go_on) return;
  1011.   /* Now see which state we are in. */
  1012.   switch(esc_s) {
  1013. case 0: /* Normal character */
  1014. if (vt_docap == 1)
  1015. fputc(P_CONVCAP[0]=='Y'? vt_inmap[c]: c, vt_capfp);
  1016.         c = vt_inmap[c];    /* conversion 04.09.97 / jl */
  1017. #if TRANSLATE
  1018. if (vt_type == VT100 && vt_asis == 0) {
  1019. if (vt_insert)
  1020. winschar2(vt_win, vt_trans[vt_charset][c], 1);
  1021. else
  1022. wputc(vt_win, vt_trans[vt_charset][c]);
  1023. } else {
  1024. #endif
  1025. if (vt_insert)
  1026. winschar2(vt_win, c, 1);
  1027. else
  1028. wputc(vt_win, c);
  1029. #if TRANSLATE
  1030. }
  1031. #endif
  1032. break;
  1033. case 1: /* ESC seen */
  1034. state1(c);
  1035. break;
  1036. case 2: /* ESC [ ... seen */
  1037. state2(c);
  1038. break;
  1039. case 3:
  1040. state3(c);
  1041. break;
  1042. case 4:
  1043. state4(c);
  1044. break;
  1045. case 5:
  1046. state5(c);
  1047. break;
  1048. case 6:
  1049. state6(c);
  1050. break;
  1051. case 7:
  1052. state7(c);
  1053. break;
  1054.   }
  1055. }
  1057. /* Translate keycode to escape sequence. */
  1058. void vt_send(c)
  1059. int c;
  1060. {
  1061.   char s[3];
  1062.   int f;
  1063.   int len = 1;
  1065.   /* Special key? */
  1066.   if (c < 256) {
  1067. /* Translate backspace key? */
  1068. if (c == K_ERA) c = vt_bs;
  1069. s[0] = vt_outmap[(unsigned char) c];  /* conversion 04.09.97 / jl */
  1070. s[1] = 0;
  1071. /* CR/LF mode? */
  1072. if (c == 'r' && vt_crlf) {
  1073. s[1] = 'n';
  1074. s[2] = 0;
  1075. len = 2;
  1076. }
  1077. v_termout(s, len);
  1078. if (vt_nl_delay > 0 && c == 'r')
  1079. usleep(1000 * vt_nl_delay);
  1080. return;
  1081.   }
  1083.   /* Look up code in translation table. */
  1084.   for(f = 0; vt_keys[f].code; f++)
  1085. if (vt_keys[f].code == c) break;
  1086.   if (vt_keys[f].code == 0) return;
  1088.   /* Now send appropriate escape code. */
  1089.   v_termout("33", 0);
  1090.   if (vt_type == VT100) {
  1091. if (vt_cursor == NORMAL)
  1092. v_termout(vt_keys[f].vt100_st, 0);
  1093. else
  1094. v_termout(vt_keys[f].vt100_app, 0);
  1095.   } else
  1096. v_termout(vt_keys[f].ansi, 0);
  1097. }