Menu
▾
▴
linuxconsole-dev
|
From: James S. <jsi...@in...> - 2002-10-09 19:21:30
|
This patch moves the terminal emulation code out of vt.c. Not in use yet but I wanted to make the patch as small as possible. MS: (n) 1. A debilitating and surprisingly widespread affliction that renders the sufferer barely able to perform the simplest task. 2. A disease. James Simmons [jsi...@us...] ____/| fbdev/console/gfx developer \ o.O| http://www.linux-fbdev.org =(_)= http://linuxgfx.sourceforge.net U http://linuxconsole.sourceforge.net You can import this changeset into BK by piping this whole message to: '| bk receive [path to repository]' or apply the patch as usual. =================================================================== ChangeSet@1.719, 2002-10-09 12:02:12-07:00, jsi...@ma... This file contains the terminal emulation code. The idea was to allow a lightweight vt console system for printk that didn't have the heavyness of terminal emulation. decvte.c | 2054 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 files changed, 2054 insertions(+) diff -Nru a/drivers/char/decvte.c b/drivers/char/decvte.c --- /dev/null Wed Dec 31 16:00:00 1969 +++ b/drivers/char/decvte.c Wed Oct 9 12:03:14 2002 @@ -0,0 +1,2054 @@ +/* + * decvte.c - DEC VT terminal emulation code. + * Copyright (C) 2000 James Simmons + * + * I moved all the VT emulation code out of console.c to here. It makes life + * much easier and the code smaller. It also allows other devices to emulate + * a TTY besides the video system. People can also change the makefile to + * support a different emulation if they wanted. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * + */ + +#include <linux/module.h> +#include <linux/sched.h> +#include <linux/tty.h> +#include <linux/tty_flip.h> +#include <linux/kernel.h> +#include <linux/string.h> +#include <linux/errno.h> +#include <linux/kd.h> +#include <linux/slab.h> +#include <linux/major.h> +#include <linux/mm.h> +#include <linux/init.h> +#include <linux/devfs_fs_kernel.h> +#include <linux/vt_kern.h> +#include <linux/vt_buffer.h> +#include <linux/selection.h> +#include <linux/consolemap.h> +#include <linux/config.h> +#include <linux/version.h> + +#include <asm/io.h> +#include <asm/system.h> +#include <asm/uaccess.h> +#include <asm/bitops.h> + +#include <asm/linux_logo.h> + +#include "console_macros.h" + +/* + * DEC VT emulator + */ + +/* Different states of the emulator */ +enum { ESinit, + /* ESC substates */ + ESesc, ESacs, ESscf, ESgzd4, ESg1d4, ESg2d4, + ESg3d4, ESg1d6, ESg2d6, ESg3d6, ESdocs, + /* CSI substates */ + EScsi, EScsi_getpars, EScsi_gotpars, EScsi_space, + EScsi_exclam, EScsi_dquote, EScsi_dollar, EScsi_and, + EScsi_squote, EScsi_star, EScsi_plus, + /* OSC substates */ + ESosc, ESpalette, + /* Misc. states */ + ESfunckey, ESignore, +}; + +#define __VTE_CSI (c8bit == 0 ? "\033[" : "\233") +#define __VTE_DCS (c8bit == 0 ? "\033P" : "\220") +#define __VTE_ST (c8bit == 0 ? "\033\\" : "\234") +#define __VTE_APC (c8bit == 0 ? "\033_" : "\237") + +/* + * this is what the terminal answers to a ESC-Z or csi0c query. + */ +#define VT100ID "\033[?1;2c" +#define VT102ID "\033[?6c" + +/* + * Here is the default bell parameters: 750HZ, 1/8th of a second + */ +#define DEFAULT_BELL_PITCH 750 +#define DEFAULT_BELL_DURATION (HZ/8) + +/* + * LINE FEED (LF) + */ +void vte_lf(struct vc_data *vc) +{ + /* don't scroll if above bottom of scrolling region, or + * if below scrolling region + */ + if (y + 1 == bottom) + scroll_region_up(vc, top, bottom, 1); + else if (y < video_num_lines - 1) { + y++; + pos += video_size_row; + } + need_wrap = 0; +} + +/* + * REVERSE LINE FEED (RI) + */ +static void vte_ri(struct vc_data *vc) +{ + /* don't scroll if below top of scrolling region, or + * if above scrolling region + */ + if (y == top) + scroll_region_down(vc, top, bottom, 1); + else if (y > 0) { + y--; + pos -= video_size_row; + } + need_wrap = 0; +} + +/* + * CARRIAGE RETURN (CR) + */ +inline void vte_cr(struct vc_data *vc) +{ + pos -= x << 1; + need_wrap = x = 0; +} + +/* + * BACK SPACE (BS) + */ +inline void vte_bs(struct vc_data *vc) +{ + if (x) { + pos -= 2; + x--; + need_wrap = 0; + } +} + +/* + * CURSOR LINE TABULATION (CVT) + * + * NOTE: + * In accordance with our interpretation of VT as LF we will treat CVT as + * (par[0] * LF). Not very creative, but at least consequent. + */ +static void vte_cvt(struct vc_data *vc, int vpar) +{ + int i; + + for (i = 0; i < vpar; i++) { + vte_lf(vc); + } +} + +/* + * CURSOR BACKWARD TABULATION (CBT) + */ +static void vte_cbt(struct vc_data *vc, int vpar) +{ + int i; + + for (i = 0; i < vpar; i++) { + pos -= (x << 1); + while (x > 0) { + x--; + if (tab_stop[x >> 5] & (1 << (x & 31))) + break; + } + pos += (x << 1); + } +} + +/* + * CURSOR FORWARD TABULATION (CHT) + */ +static void vte_cht(struct vc_data *vc, int vpar) +{ + int i; + + for (i = 0; i < vpar; i++) { + pos -= (x << 1); + while (x < video_num_columns - 1) { + x++; + if (tab_stop[x >> 5] & (1 << (x & 31))) + break; + } + pos += (x << 1); + } +} + +/* + * ERASE IN PAGE (ED) + */ +void vte_ed(struct vc_data *vc, int vpar) +{ + unsigned short *start; + unsigned int count; + + switch (vpar) { + case 0: /* erase from cursor to end of display */ + count = (scr_end - pos) >> 1; + start = (unsigned short *) pos; + /* do in two stages */ + clear_region(vc, x, y, video_num_columns - x, 1); + clear_region(vc, 0, y + 1, video_num_columns, + video_num_lines - y - 1); + break; + case 1: /* erase from start to cursor */ + count = ((pos - origin) >> 1) + 1; + start = (unsigned short *) origin; + /* do in two stages */ + clear_region(vc, 0, 0, video_num_columns, y); + clear_region(vc, 0, y, x + 1, 1); + break; + case 2: /* erase whole display */ + count = video_num_columns * video_num_lines; + start = (unsigned short *) origin; + clear_region(vc, 0, 0, video_num_columns, video_num_lines); + break; + default: + return; + } + scr_memsetw(start, video_erase_char, 2 * count); + need_wrap = 0; +} + +/* + * ERASE IN LINE (EL) + */ +static void vte_el(struct vc_data *vc, int vpar) +{ + unsigned int count; + unsigned short *start; + + switch (vpar) { + case 0: /* erase from cursor to end of line */ + count = video_num_columns - x; + start = (unsigned short *) pos; + clear_region(vc, x, y, video_num_columns - x, 1); + break; + case 1: /* erase from start of line to cursor */ + start = (unsigned short *) (pos - (x << 1)); + count = x + 1; + clear_region(vc, 0, y, x + 1, 1); + break; + case 2: /* erase whole line */ + start = (unsigned short *) (pos - (x << 1)); + count = video_num_columns; + clear_region(vc, 0, y, video_num_columns, 1); + break; + default: + return; + } + scr_memsetw(start, video_erase_char, 2 * count); + need_wrap = 0; +} + +/* + * Erase character (ECH) + * + * NOTE: This function is not available in DEC VT1xx terminals. + */ +static void vte_ech(struct vc_data *vc, int vpar) +{ + int count; + + if (!vpar) + vpar++; + count = + (vpar > + video_num_columns - x) ? (video_num_columns - x) : vpar; + + scr_memsetw((unsigned short *) pos, video_erase_char, 2 * count); + clear_region(vc, x, y, count, 1); + need_wrap = 0; +} + +/* + * SELECT GRAPHIC RENDITION (SGR) + * + * NOTE: The DEC vt1xx series only implements attribute values 0,1,4,5 and 7. + */ +static void vte_sgr(struct vc_data *vc) +{ + int i; + + for (i = 0; i <= npar; i++) + switch (par[i]) { + case 0: /* all attributes off */ + default_attr(vc); + break; + case 1: /* bold or increased intensity */ + intensity = 2; + break; + case 2: /* faint or decreased intensity */ + intensity = 0; + break; + case 4: /* singly underlined. */ + underline = 1; + break; + case 5: /* slowly blinking (< 2.5 Hz) */ + case 6: /* rapidly blinking (>= 2.5 Hz) */ + blink = 1; + break; + case 7: /* negative image */ + reverse = 1; + break; + case 10: /* primary (default) font + * ANSI X3.64-1979 (SCO-ish?) + * Select primary font, don't display + * control chars if defined, don't set + * bit 8 on output. + */ + set_translate(vc, charset == 0 ? + G0_charset : G1_charset); + disp_ctrl = 0; + toggle_meta = 0; + break; + case 11: /* first alternative font + * ANSI X3.64-1979 (SCO-ish?) + * Select first alternate font, lets + * chars < 32 be displayed as ROM chars. + */ + set_translate(vc, IBMPC_MAP); + disp_ctrl = 1; + toggle_meta = 0; + break; + case 12: /* second alternative font + * Select second alternate font, toggle + * high bit before displaying as ROM char. + */ + set_translate(vc, IBMPC_MAP); + disp_ctrl = 1; + toggle_meta = 1; + break; + case 21: /* normal intensity */ + case 22: /* normal intensity */ + intensity = 1; + break; + case 24: /* not underlined (neither singly nor doubly) */ + underline = 0; + break; + case 25: /* steady (not blinking) */ + blink = 0; + break; + case 27: /* positive image */ + reverse = 0; + break; + case 38: /* foreground color (ISO 8613-6/ITU T.416) + * Enables underscore, white foreground + * with white underscore (Linux - use + * default foreground). + */ + color = (def_color & 0x0f) | background; + underline = 1; + break; + case 39: /* default display color */ + color = (def_color & 0x0f) | background; + underline = 0; + break; + case 49: /* default background color */ + color = (def_color & 0xf0) | foreground; + break; + default: + if (par[i] >= 30 && par[i] <= 37) + color = color_table[par[i] - 30] + | background; + else if (par[i] >= 40 && par[i] <= 47) + color = (color_table[par[i] - 40] << 4) + | foreground; + break; + } + update_attr(vc); +} + +/* + * Fake a DEC DSR for non-implemented features + */ +static void vte_fake_dec_dsr(struct tty_struct *tty, char *reply) +{ + struct vc_data *vc = (struct vc_data *) tty->driver_data; + char buf[40]; + + sprintf(buf, "%s?%sn", __VTE_CSI, reply); + respond_string(buf, tty); +} + +/* + * CURSOR POSITION REPORT (CPR) + * DEC EXTENDED CURSOR POSITION REPORT (DECXCPR) + */ +static void vte_cpr(struct tty_struct *tty, int ext) +{ + struct vc_data *vc = (struct vc_data *) tty->driver_data; + char buf[40]; + + if (ext) { + /* + * NOTE: Since we do not (yet?) implement any form of page + * memory, we will always return the cursor position in page 1. + */ + sprintf(buf, "%s?%d;%d;1R", __VTE_CSI, + y + (decom ? top + 1 : 1), x + 1); + } else { + sprintf(buf, "%s%d;%dR", __VTE_CSI, + y + (decom ? top + 1 : 1), x + 1); + } + respond_string(buf, tty); +} + +/* + * DEVICE STATUS REPORT (DSR) + */ +static inline void vte_dsr(struct tty_struct *tty) +{ + struct vc_data *vc = (struct vc_data *) tty->driver_data; + char buf[40]; + + sprintf(buf, "%s0n", __VTE_CSI); + respond_string(buf, tty); +} + +/* + * ANSWERBACK MESSAGE + */ +static inline void vte_answerback(struct tty_struct *tty) +{ + respond_string("l i n u x", tty); +} + +/* + * DA - DEVICE ATTRIBUTE + */ +static inline void vte_da(struct tty_struct *tty) +{ + struct vc_data *vc = (struct vc_data *) tty->driver_data; + char buf[40]; + + /* We claim VT220 compatibility... */ + sprintf(buf, "%s?62;1;2;6;7;8;9c", __VTE_CSI); + respond_string(buf, tty); +} + +#define VTE_VERSION 211 +/* + * DA - SECONDARY DEVICE ATTRIBUTE [VT220 and up] + * + * Reply parameters: + * 1 = Model (1=vt220, 18=vt330, 19=vt340, 41=vt420) + * 2 = Firmware version (nn = n.n) + * 3 = Installed options (0 = none) + */ +static void vte_dec_da2(struct tty_struct *tty) +{ + struct vc_data *vc = (struct vc_data *) tty->driver_data; + char buf[40]; + + sprintf(buf, "%s>%d;%d;0c", __VTE_CSI, 1, VTE_VERSION / 10); + respond_string(buf, tty); +} + +/* + * DA - TERTIARY DEVICE ATTRIBUTE [VT220 and up] + * + * Reply: unit ID (we report "0") + */ +static void vte_dec_da3(struct tty_struct *tty) +{ + struct vc_data *vc = (struct vc_data *) tty->driver_data; + char buf[40]; + + sprintf(buf, "%s!|%s%s", __VTE_DCS, "0", __VTE_ST); + respond_string(buf, tty); +} + +/* + * DECREPTPARM - DEC REPORT TERMINAL PARAMETERS [VT1xx/VT2xx/VT320] + */ +static void vte_decreptparm(struct tty_struct *tty) +{ + struct vc_data *vc = (struct vc_data *) tty->driver_data; + char buf[40]; + + sprintf(buf, "\033[%d;1;1;120;120;1;0x", par[0] + 2); + respond_string(buf, tty); +} + +/* + * SM - SET MODE / + * RM - RESET MODE + */ +static void set_mode(struct vc_data *vc, int on_off) +{ + int i; + + for (i = 0; i <= npar; i++) + /* DEC private modes set/reset */ + if (priv4) + switch (par[i]) { + case 1: /* DECCKM - Cursor keys mode */ + if (on_off) + set_kbd_mode(&vc->kbd_table, + VC_CKMODE); + else + clr_kbd_mode(&vc->kbd_table, + VC_CKMODE); + break; + case 2: /* DECANM - ANSI mode */ + break; + case 3: /* DECCOLM - Column mode */ +#if 0 + deccolm = on_off; + (void) vc_resize(video_num_lines, + deccolm ? 132 : 80); + /* this alone does not suffice; some user mode + utility has to change the hardware regs */ +#endif + break; + case 4: /* DECSCLM - Scrolling mode */ + break; + case 5: /* DECSCNM - Screen mode */ + if (decscnm != on_off) { + decscnm = on_off; + invert_screen(vc, 0, + screenbuf_size, 0); + update_attr(vc); + } + break; + case 6: /* DECOM - Origin mode */ + decom = on_off; + gotoxay(vc, 0, 0); + break; + case 7: /* DECAWM - Autowrap mode */ + decawm = on_off; + break; + case 8: /* DECARM - Autorepeat mode */ + decarm = on_off; + if (on_off) + set_kbd_mode(&vc->kbd_table, + VC_REPEAT); + else + clr_kbd_mode(&vc->kbd_table, + VC_REPEAT); + break; + case 9: + report_mouse = on_off ? 1 : 0; + break; + case 25: /* DECTCEM - Text cursor enable mode */ + dectcem = on_off; + break; + case 42: /* DECNCRS - National character set replacement mode */ + break; + case 60: /* DECHCCM - Horizontal cursor coupling mode */ + break; + case 61: /* DECVCCM - Vertical cursor coupling mode */ + break; + case 64: /* DECPCCM - Page cursor coupling mode */ + break; + case 66: /* DECNKM - Numeric keybad mode */ + decnkm = on_off; + if (on_off) + set_kbd_mode(&vc->kbd_table, + VC_APPLIC); + else + clr_kbd_mode(&vc->kbd_table, + VC_APPLIC); + break; + case 67: /* DECBKM - Backarrow key mode */ + break; + case 68: /* DECKBUM - Keyboard usage mode */ + break; + case 69: /* DECVSSM - Vertical split screen mode + */ + break; + case 73: /* DECXRLM - Transfer rate limiting mode */ + break; + case 81: /* DECKPM - Keyboard position mode */ + break; + case 1000: + report_mouse = on_off ? 2 : 0; + break; + } else + switch (par[i]) { /* ANSI modes set/reset */ + case 3: /* Monitor (display ctrls) */ + disp_ctrl = on_off; + break; + case 4: /* Insert Mode on/off */ + irm = on_off; + break; + case 20: /* Lf, Enter == CrLf/Lf */ + if (on_off) + set_kbd_mode(&vc->kbd_table, + VC_CRLF); + else + clr_kbd_mode(&vc->kbd_table, + VC_CRLF); + break; + } +} + +/* + * DECCIR - Cursor information report + */ +static void vte_deccir(struct tty_struct *tty) +{ + /* not yet implemented */ +} + +/* + * DECMSR - Macro space report + */ +static void vte_decmsr(struct tty_struct *tty) +{ + struct vc_data *vc = (struct vc_data *) tty->driver_data; + char buf[40]; + + sprintf(buf, "%s%d*{", __VTE_CSI, 0); /* No space left */ + respond_string(buf, tty); +} + +/* + * DECRPM - Report mode + */ +static void vte_decrpm(struct tty_struct *tty, int priv, int mode, + int status) +{ + struct vc_data *vc = (struct vc_data *) tty->driver_data; + char buf[40]; + + if (status == 0) { + status = 2; + } else { + if (status == 2) { + status = 0; + } + } + + if (priv) + sprintf(buf, "%s?%d;%d$y", __VTE_CSI, mode, status); + else + sprintf(buf, "%s%d;%d$y", __VTE_CSI, mode, status); + respond_string(buf, tty); +} + +/* + * DECRQM - Request mode + * + * Reply codes: + * 0 = reset + * 1 = set + * 2 = unknown + * 3 = premanently set + * 4 = permanently reset + */ +static void vte_decrqm(struct tty_struct *tty, int priv) +{ + struct vc_data *vc = (struct vc_data *) tty->driver_data; + + if (priv) { + switch (par[0]) { + case 1: /* DECCKM - Cursor keys mode */ + vte_decrpm(tty, priv, par[0], decckm); + break; + case 2: /* DECANM */ + case 3: /* DECCOLM */ + case 4: /* DECSCLM */ + vte_decrpm(tty, priv, par[0], 4); + break; + case 5: /* DECSCNM */ + vte_decrpm(tty, priv, par[0], decscnm); + break; + case 6: /* DECOM */ + vte_decrpm(tty, priv, par[0], decom); + break; + case 7: /* DECAWM */ + vte_decrpm(tty, priv, par[0], decawm); + break; + case 8: /* DECARM */ + vte_decrpm(tty, priv, par[0], decarm); + break; + case 25: /* DECTCEM */ + vte_decrpm(tty, priv, par[0], dectcem); + break; + case 42: /* DECNCRM */ + case 60: /* DECHCCM */ + case 61: /* DECVCCM */ + case 64: /* DECPCCM */ + vte_decrpm(tty, priv, par[0], 4); + break; + case 66: /* DECNKM */ + vte_decrpm(tty, priv, par[0], decnkm); + break; + case 67: /* DECBKM */ + case 68: /* DECKBUM */ + case 69: /* DECVSSM */ + case 73: /* DECXRLM */ + case 81: /* DECKPM */ + vte_decrpm(tty, priv, par[0], 4); + break; + default: + vte_decrpm(tty, priv, par[0], 2); + } + } else { + switch (par[0]) { + case 1: /* GATM */ + vte_decrpm(tty, priv, par[0], 4); + break; + case 2: /* KAM */ + vte_decrpm(tty, priv, par[0], kam); + break; + case 3: /* CRM */ + vte_decrpm(tty, priv, par[0], 4); + break; + case 4: /* IRM */ + vte_decrpm(tty, priv, par[0], irm); + break; + case 5: /* SRTM */ + case 6: /* ERM */ + case 7: /* VEM */ + case 8: /* BDSM */ + case 9: /* DCSM */ + case 10: /* HEM */ + case 11: /* PUM */ + case 12: /* SRM */ + case 13: /* FEAM */ + case 14: /* FETM */ + case 15: /* MATM */ + case 16: /* TTM */ + case 17: /* SATM */ + case 18: /* TSM */ + case 19: /* EBM */ + vte_decrpm(tty, priv, par[0], 4); + break; + case 20: /* LNM */ + vte_decrpm(tty, priv, par[0], lnm); + break; + case 21: /* GRCM */ + case 22: /* ZDM */ + vte_decrpm(tty, priv, par[0], 4); + break; + default: + vte_decrpm(tty, priv, par[0], 2); + } + } +} + +/* + * DECSCL - Set operating level + */ +static void vte_decscl(struct vc_data *vc) +{ + switch (par[0]) { + case 61: /* VT100 mode */ + if (npar == 1) { + decscl = 1; + c8bit = 0; + } + break; + case 62: /* VT200 mode */ + case 63: /* VT300 mode */ + case 64: /* VT400 mode */ + if (npar <= 2) { + decscl = 4; + if (par[1] == 1) + c8bit = 0; + else + c8bit = 1; + } + break; + } + return; +} + +/* + * DECTABSR - Tabulation stop report + */ +void vte_dectabsr(struct tty_struct *tty) +{ + /* not yet implemented */ +} + +/* + * DECTSR - Terminal state report + */ +void vte_dectsr(struct tty_struct *tty) +{ + /* not yet implemented */ +} + +static void setterm_command(struct vc_data *vc) +{ + switch (par[0]) { + case 1: /* set color for underline mode */ + if (can_do_color && par[1] < 16) { + ulcolor = color_table[par[1]]; + if (underline) + update_attr(vc); + } + break; + case 2: /* set color for half intensity mode */ + if (can_do_color && par[1] < 16) { + halfcolor = color_table[par[1]]; + if (intensity == 0) + update_attr(vc); + } + break; + case 8: /* store colors as defaults */ + def_color = attr; + if (hi_font_mask == 0x100) + def_color >>= 1; + default_attr(vc); + update_attr(vc); + break; + case 9: /* set blanking interval */ + vc->display_fg->blank_interval = + ((par[1] < 60) ? par[1] : 60) * 60 * HZ; + poke_blanked_console(vc->display_fg); + break; + case 10: /* set bell frequency in Hz */ + if (npar >= 1) + bell_pitch = par[1]; + else + bell_pitch = DEFAULT_BELL_PITCH; + break; + case 11: /* set bell duration in msec */ + if (npar >= 1) + bell_duration = (par[1] < 2000) ? + par[1] * HZ / 1000 : 0; + else + bell_duration = DEFAULT_BELL_DURATION; + break; + case 12: /* bring specified console to the front */ + if (par[1] >= 1 && vc_cons_allocated(par[1] - 1)) + set_console(par[1] - 1); + break; + case 13: /* unblank the screen */ + poke_blanked_console(vc->display_fg); + break; + case 14: /* set vesa powerdown interval */ + vc->display_fg->off_interval = + ((par[1] < 60) ? par[1] : 60) * 60 * HZ; + break; + } +} + +/* + * ICH - INSERT CHARACTER [VT220] + */ +static void vte_ich(struct vc_data *vc, unsigned int nr) +{ + if (nr > video_num_columns - x) + nr = video_num_columns - x; + else if (!nr) + nr = 1; + insert_char(vc, nr); +} + +/* + * IL - INSERT LINE + */ +static void vte_il(struct vc_data *vc, unsigned int nr) +{ + if (nr > video_num_lines - y) + nr = video_num_lines - y; + else if (!nr) + nr = 1; + insert_line(vc, nr); +} + +/* + * DCH - DELETE CHARACTER + */ +static void vte_dch(struct vc_data *vc, unsigned int nr) +{ + if (nr > video_num_columns - x) + nr = video_num_columns - x; + else if (!nr) + nr = 1; + delete_char(vc, nr); +} + +/* + * DL - DELETE LINE + */ +static void vte_dl(struct vc_data *vc, unsigned int nr) +{ + if (nr > video_num_lines - y) + nr = video_num_lines - y; + else if (!nr) + nr = 1; + delete_line(vc, nr); +} + +/* + * DECSC - SAVE CURSOR + * + * This saves the following states: + * - cursor position + * - graphic rendition + * - character set shift state + * - state of wrap flag + * - state of origin mode + * - state of selective erase (not implemented) + */ +void vte_decsc(struct vc_data *vc) +{ + saved_x = x; + saved_y = y; + s_intensity = intensity; + s_underline = underline; + s_blink = blink; + s_reverse = reverse; + s_charset = charset; + s_color = color; + saved_G0 = G0_charset; + saved_G1 = G1_charset; + saved_G2 = G2_charset; + saved_G3 = G3_charset; +} + +/* + * DECRC - RESTORE CURSOR + */ +static void vte_decrc(struct vc_data *vc) +{ + gotoxy(vc, saved_x, saved_y); + intensity = s_intensity; + underline = s_underline; + blink = s_blink; + reverse = s_reverse; + charset = s_charset; + color = s_color; + G0_charset = saved_G0; + G1_charset = saved_G1; + G2_charset = saved_G2; + G3_charset = saved_G3; + set_translate(vc, charset ? G1_charset : G0_charset); + update_attr(vc); + need_wrap = 0; +} + +/* + * RIS - RESET TO INITIAL STATE + * + * On DEC terminals this causes the following: + * - all set-up parameters are replaced by power-up defaults + * - all communications lines are disconnected (should we send SIGHUP to + * controlling process?) + * - all user-defined keys are cleared (not implemented) + * - the screen is cleared + * - cursor is place to upper-left corner + * - SGR state is set to normal + * - selective erase attribute write state is set to "non-selective erase" + * (not implemented) + * - all character sets are set to default (not implemented) + */ +void vte_ris(struct vc_data *vc, int do_clear) +{ + top = 0; + bottom = video_num_lines; + vc_state = ESinit; + priv1 = 0; + priv2 = 0; + priv3 = 0; + priv4 = 0; + set_translate(vc, LAT1_MAP); + G0_charset = LAT1_MAP; + G1_charset = GRAF_MAP; + charset = 0; + need_wrap = 0; + report_mouse = 0; + utf = 0; + utf_count = 0; + + disp_ctrl = 0; + toggle_meta = 0; + + c8bit = 0; /* disable 8-bit controls */ + decckm = 0; /* cursor key sequences */ + decsclm = 0; /* jump scroll */ + decscnm = 0; /* normal screen */ + decom = 0; /* absolute adressing */ + decawm = 1; /* autowrap disabled */ + decarm = 1; /* autorepeat enabled */ + dectcem = 1; /* text cursor enabled */ + + kam = 0; /* keyboard enabled */ + crm = 0; /* execute control functions */ + irm = 0; /* replace */ + lnm = 0; /* line feed */ + + set_kbd_mode(&vc->kbd_table, VC_REPEAT); + clr_kbd_mode(&vc->kbd_table, VC_CKMODE); + clr_kbd_mode(&vc->kbd_table, VC_APPLIC); + clr_kbd_mode(&vc->kbd_table, VC_CRLF); + vc->kbd_table.lockstate = KBD_DEFLOCK; + vc->kbd_table.slockstate = 0; + vc->kbd_table.ledmode = LED_SHOW_FLAGS; + vc->kbd_table.ledflagstate = + vc->kbd_table.default_ledflagstate = KBD_DEFLEDS; + vc->kbd_table.modeflags = KBD_DEFMODE; + vc->kbd_table.kbdmode = VC_XLATE; + set_leds(); + + cursor_type = CUR_DEFAULT; + complement_mask = s_complement_mask; + + default_attr(vc); + update_attr(vc); + + tab_stop[0] = 0x01010100; + tab_stop[1] = tab_stop[2] = tab_stop[3] = tab_stop[4] = 0x01010101; + + bell_pitch = DEFAULT_BELL_PITCH; + bell_duration = DEFAULT_BELL_DURATION; + + gotoxy(vc, 0, 0); + vte_decsc(vc); + if (do_clear) + vte_ed(vc, 2); +} + +/* + * TABULATION CLEAR (TBC) + * + * NOTE: + * In case of parameters 0 and 2 the number of lines affected depends on the + * setting of the Tabulation Stop Mode (TSM). Since we don't implement TSM, + * this is silently ignored. + * + * Parameters 1 and 4 are similiar to 0 and 3, but affect only line tabulation + * stops, which are not implemented. + * + * Parameter 2 may only be interpreted, when we implement a tabulation stop map + * per display line. + */ +static void vte_tbc(struct vc_data *vc, int vpar) +{ + switch (vpar) { + case 0: + /* + * The character tabulation stop at the active + * presentation position is cleared. + */ + tab_stop[x >> 5] &= ~(1 << (x & 31)); + return; + case 2: + /* + * All character tabulation stops in the active + * line are cleared. + */ + case 3: + /* + * All character tabulation stops are cleared. + */ + case 5: + /* + * All tabulation stops are cleared. + */ + tab_stop[0] = tab_stop[1] = tab_stop[2] = tab_stop[3] = + tab_stop[4] = 0; + } +} + +void terminal_emulation(struct tty_struct *tty, int c) +{ + /* + * C0 CONTROL CHARACTERS + * + * NOTE: Control characters can be used in the _middle_ + * of an escape sequence. (XXX: Really? Test!) + */ + struct vc_data *vc = (struct vc_data *) tty->driver_data; + + switch (c) { + case 0x00: /* NUL - Null */ + case 0x01: /* SOH - Start of header */ + case 0x02: /* STX - */ + case 0x03: /* ETX - */ + case 0x04: /* EOT - End of transmission */ + return; + case 0x05: /* ENQ - Enquiry */ + vte_answerback(tty); + return; + case 0x06: /* ACK - Acknowledge */ + return; + case 0x07: /* BEL - Bell */ + if (bell_duration) + kd_mksound(bell_pitch, bell_duration); + return; + case 0x08: /* BS - Back space */ + vte_bs(vc); + return; + case 0x09: /* HT - Character tabulation */ + pos -= (x << 1); + while (x < video_num_columns - 1) { + x++; + if (tab_stop[x >> 5] & (1 << (x & 31))) + break; + } + pos += (x << 1); + return; + case 0x0a: /* LF - Line feed */ + case 0x0b: /* VT - Line tabulation */ + /* + * Since line tabulation is not implemented in the DEC VT + * series (except VT131 ?), the DEC VT series treats any + * VT as LF. + */ + case 0x0c: /* FF - Form feed */ + /* + * DEC VT series processes FF as LF. + */ + vte_lf(vc); + if (!get_kbd_mode(&vc->kbd_table, VC_CRLF)) + return; + case 0x0d: /* CR - Carriage return */ + vte_cr(vc); + return; + case 0x0e: /* SO - Shift out / LS1 - Locking shift 1 */ + charset = 1; + set_translate(vc, G1_charset); + disp_ctrl = 1; + return; + case 0x0f: /* SI - Shift in / LS0 - Locking shift 0 */ + charset = 0; + set_translate(vc, G0_charset); + disp_ctrl = 0; + return; + case 0x10: /* DLE - */ + case 0x11: /* DC1 - Device control 1 */ + case 0x12: /* DC2 - Device control 1 */ + case 0x13: /* DC3 - Device control 1 */ + case 0x14: /* DC4 - Device control 1 */ + case 0x15: /* NAK - Negative acknowledge */ + case 0x16: /* SYN - Synchronize */ + case 0x17: /* ETB - */ + return; + case 0x18: /* CAN - Cancel */ + vc_state = ESinit; + return; + case 0x19: /* EM - */ + return; + case 0x1a: /* SUB - Substitute */ + vc_state = ESinit; + return; + case 0x1b: /* ESC - Escape */ + vc_state = ESesc; + return; + case 0x1c: /* IS4 - */ + case 0x1d: /* IS3 - */ + case 0x1e: /* IS2 - */ + case 0x1f: /* IS1 - */ + return; + case 0x7f: /* DEL - Delete */ + /* + * This character is ignored, unless a 96-set has been mapped, + * but this is not supported at the moment. + */ + return; + } + + if (c8bit == 1) + /* + * C1 control functions (8-bit mode). + */ + switch (c) { + case 0x80: /* unused */ + case 0x81: /* unused */ + case 0x82: /* BPH - Break permitted here */ + case 0x83: /* NBH - No break here */ + return; + case 0x84: /* IND - Line feed (DEC only) */ +#ifndef VTE_STRICT_ISO + vte_lf(vc); +#endif /* ndef VTE_STRICT_ISO */ + return; + case 0x85: /* NEL - Next line */ + vte_lf(vc); + vte_cr(vc); + return; + case 0x86: /* SSA - Start of selected area */ + case 0x87: /* ESA - End of selected area */ + return; + case 0x88: /* HTS - Character tabulation set */ + tab_stop[x >> 5] |= (1 << (x & 31)); + return; + case 0x89: /* HTJ - Character tabulation with justify */ + case 0x8a: /* VTS - Line tabulation set */ + case 0x8b: /* PLD - Partial line down */ + case 0x8c: /* PLU - Partial line up */ + return; + case 0x8d: /* RI - Reverse line feed */ + vte_ri(vc); + return; +#if 0 + case 0x8e: /* SS2 - Single shift 2 */ + need_shift = 1; + GS_charset = G2_charset; /* G2 -> GS */ + return; + case 0x8f: /* SS3 - Single shift 3 */ + need_shift = 1; + GS_charset = G3_charset; /* G3 -> GS */ + return; +#endif + case 0x90: /* DCS - Device control string */ + return; + case 0x91: /* PU1 - Private use 1 */ + case 0x92: /* PU2 - Private use 2 */ + case 0x93: /* STS - Set transmit state */ + case 0x94: /* CCH - Cancel character */ + case 0x95: /* MW - Message waiting */ + case 0x96: /* SPA - Start of guarded area */ + case 0x97: /* EPA - End of guarded area */ + case 0x98: /* SOS - Start of string */ + case 0x99: /* unused */ + return; + case 0x9a: /* SCI - Single character introducer */ +#ifndef VTE_STRICT_ISO + vte_da(tty); +#endif /* ndef VTE_STRICT_ISO */ + return; + case 0x9b: /* CSI - Control sequence introducer */ + vc_state = EScsi; + return; + case 0x9c: /* ST - String Terminator */ + case 0x9d: /* OSC - Operating system command */ + case 0x9e: /* PM - Privacy message */ + case 0x9f: /* APC - Application program command */ + return; + } + + switch (vc_state) { + case ESesc: + vc_state = ESinit; + switch (c) { + + case ' ': /* ACS - Announce code structure */ + vc_state = ESacs; + return; + case '#': /* SCF - Single control functions */ + vc_state = ESscf; + return; + case '%': /* DOCS - Designate other coding system */ + vc_state = ESdocs; + return; +#ifdef CONFIG_VT_HP + case '&': /* HP terminal emulation */ + vc_state = ESesc_and; + return; +#endif /* def CONFIG_VT_HP */ + case '(': /* GZD4 - G0-designate 94-set */ + vc_state = ESgzd4; + return; + case ')': /* G1D4 - G1-designate 94-set */ + vc_state = ESg1d4; + return; +#if 0 + case '*': /* G2D4 - G2-designate 94-set */ + vc_state = ESg2d4; + return; + case '+': /* G3D4 - G3-designate 94-set */ + vc_state = ESg3d4; + return; + case '-': /* G1D6 - G1-designate 96-set */ + vc_state = ESg1d6; + return; + case '.': /* G2D6 - G2-designate 96-set */ + vc_state = ESg2d6; + return; + case '/': /* G3D6 - G3-designate 96-set */ + vc_state = ESg3d6; + return; +#endif + /* ===== Private control functions ===== */ + + case '6': /* DECBI - Back index */ + return; + case '7': /* DECSC - Save cursor */ + vte_decsc(vc); + return; + case '8': /* DECRC - Restore cursor */ + vte_decrc(vc); + return; + case '9': /* DECFI - Forward index */ + return; + case '=': /* DECKPAM - Keypad application mode */ + decnkm = 1; + set_kbd_mode(&vc->kbd_table, VC_APPLIC); + return; + case '>': /* DECKPNM - Keypad numeric mode */ + decnkm = 0; + clr_kbd_mode(&vc->kbd_table, VC_APPLIC); + return; + + /* ===== C1 control functions ===== */ + case '@': /* unallocated */ + case 'A': /* unallocated */ + case 'B': /* BPH - Break permitted here */ + case 'C': /* NBH - No break here */ + case 'D': /* IND - Line feed (DEC only) */ +#ifndef VTE_STRICT_ISO + vte_lf(vc); +#endif /* ndef VTE_STRICT_ISO */ + return; + case 'E': /* NEL - Next line */ + vte_cr(vc); + vte_lf(vc); + return; + case 'F': /* SSA - Start of selected area */ + case 'G': /* ESA - End of selected area */ + return; + case 'H': /* HTS - Character tabulation set */ + tab_stop[x >> 5] |= (1 << (x & 31)); + return; + case 'I': /* HTJ - Character tabulation with justify */ + case 'J': /* VTS - Line tabulation set */ + case 'K': /* PLD - Partial line down */ + case 'L': /* PLU - Partial line up */ + return; + case 'M': /* RI - Reverse line feed */ + vte_ri(vc); + return; + case 'N': /* SS2 - Single shift 2 */ + shift = 1; + GS_charset = G2_charset; /* G2 -> GS */ + return; + case 'O': /* SS3 - Single shift 3 */ + shift = 1; + GS_charset = G3_charset; + return; + case 'P': /* DCS - Device control string */ + return; + case 'Q': /* PU1 - Private use 1 */ + case 'R': /* PU2 - Private use 2 */ + case 'S': /* STS - Set transmit state */ + case 'T': /* CCH - Cancel character */ + case 'U': /* MW - Message waiting */ + case 'V': /* SPA - Start of guarded area */ + case 'W': /* EPA - End of guarded area */ + case 'X': /* SOS - Start of string */ + case 'Y': /* unallocated */ + return; + case 'Z': /* SCI - Single character introducer */ +#ifndef VTE_STRICT_ISO + vte_da(tty); +#endif /* ndef VTE_STRICT_ISO */ + return; + case '[': /* CSI - Control sequence introducer */ + vc_state = EScsi; + return; + case '\\': /* ST - String Terminator */ + return; + case ']': /* OSC - Operating system command */ + /* XXX: Fixme! Wrong sequence and format! */ + vc_state = ESosc; + return; + case '^': /* PM - Privacy Message */ + case '_': /* APC - Application Program Command */ + return; + + /* ===== Single control functions ===== */ + case '`': /* DMI - Disable manual input */ + kam = 0; + return; + case 'b': /* EMI - Enable manual input */ + kam = 1; + return; + case 'c': /* RIS - Reset ti initial state */ + vte_ris(vc, 1); + return; + case 'd': /* CMD - Coding Method Delimiter */ + return; +#if 0 + case 'n': /* LS2 - Locking shift G2 */ + GL_charset = G2_charset; /* (G2 -> GL) */ + return; + case 'o': /* LS3 - Locking shift G3 */ + GL_charset = G3_charset; /* (G3 -> GL) */ + return; + case '|': /* LS3R - Locking shift G3 right */ + GR_charset = G3_charset; /* G3 -> GR */ + return; + case '}': /* LS2R - Locking shift G2 right */ + GR_charset = G2_charset; /* G2 -> GR */ + return; + case '~': /* LS1R - Locking shift G1 right */ + GR_charset = G1_charset; /* G1 -> GR */ + return; +#endif + } + return; + case ESacs: + vc_state = ESinit; + switch (c) { + case 'F': /* Select 7-bit C1 control transmission */ + if (decscl != 1) /* Ignore if in VT100 mode */ + c8bit = 0; + return; + case 'G': /* Select 8-Bit C1 control transmission */ + if (decscl != 1) /* Ignore if in VT100 mode */ + c8bit = 1; + return; + case 'L': /* ANSI conformance level 1 */ + case 'M': /* ANSI conformance level 2 */ + case 'N': /* ANSI conformance level 3 */ + /* Not yet implemented. */ + return; + } + return; + case ESosc: + vc_state = ESinit; + switch (c) { + case 'P': /* palette escape sequence */ + for (npar = 0; npar < NPAR; npar++) + par[npar] = 0; + npar = 0; + vc_state = ESpalette; + return; + case 'R': /* reset palette */ + reset_palette(vc); + vc_state = ESinit; + return; + } + return; + case ESpalette: + if ((c >= '0' && c <= '9') || (c >= 'A' && c <= 'F') + || (c >= 'a' && c <= 'f')) { + par[npar++] = + (c > '9' ? (c & 0xDF) - 'A' + 10 : c - '0'); + if (npar == 7) { + int i = par[0] * 3, j = 1; + palette[i] = 16 * par[j++]; + palette[i++] += par[j++]; + palette[i] = 16 * par[j++]; + palette[i++] += par[j++]; + palette[i] = 16 * par[j++]; + palette[i] += par[j]; + set_palette(vc); + vc_state = ESinit; + } + } else + vc_state = ESinit; + return; + case EScsi: + for (npar = 0; npar < NPAR; npar++) + par[npar] = 0; + npar = 0; + vc_state = EScsi_getpars; + if (c == '[') { + /* Function key */ + vc_state = ESfunckey; + return; + } + priv1 = (c == '<'); + priv2 = (c == '='); + priv3 = (c == '>'); + priv4 = (c == '?'); + if (priv1) { + vc_state = ESinit; + return; + } + if (priv2 || priv3 || priv4) { + return; + } + case EScsi_getpars: + if (c == ';' && npar < NPAR - 1) { + npar++; + return; + } else if (c >= '0' && c <= '9') { + par[npar] *= 10; + par[npar] += c - '0'; + return; + } else + vc_state = EScsi_gotpars; + case EScsi_gotpars: + vc_state = ESinit; + /* + * Process control functions with private parameter flag. + */ + switch (c) { + case '$': + if (priv4) { + vc_state = EScsi_dollar; + return; + } + break; + case 'J': + if (priv4) { + /* DECSED - Selective erase in display */ + return; + } + break; + case 'K': + if (priv4) { + /* DECSEL - Selective erase in display */ + return; + } + break; + case 'h': /* SM - Set Mode */ + set_mode(vc, 1); + return; + case 'l': /* RM - Reset Mode */ + set_mode(vc, 0); + return; + case 'c': + if (priv2) { + if (!par[0]) + vte_dec_da3(tty); + priv2 = 0; + return; + } + if (priv3) { + if (!par[0]) + vte_dec_da2(tty); + priv3 = 0; + return; + } + if (priv4) { + if (par[0]) + cursor_type = + par[0] | (par[1] << 8) | + (par[2] << 16); + else + cursor_type = CUR_DEFAULT; + priv4 = 0; + return; + } + break; + case 'm': + if (priv4) { + clear_selection(); + if (par[0]) + complement_mask = + par[0] << 8 | par[1]; + else + complement_mask = + s_complement_mask; + priv4 = 0; + return; + } + break; + case 'n': + if (priv4) { + switch (par[0]) { + case 6: /* DECXCPR - Extended CPR */ + vte_cpr(tty, 1); + break; + case 15: /* DEC printer status */ + vte_fake_dec_dsr(tty, "13"); + break; + case 25: /* DEC UDK status */ + vte_fake_dec_dsr(tty, "21"); + break; + case 26: /* DEC keyboard status */ + vte_fake_dec_dsr(tty, "27;1;0;1"); + break; + case 53: /* DEC locator status */ + vte_fake_dec_dsr(tty, "53"); + break; + case 62: /* DEC macro space */ + vte_decmsr(tty); + break; + case 75: /* DEC data integrity */ + vte_fake_dec_dsr(tty, "70"); + break; + case 85: /* DEC multiple session status */ + vte_fake_dec_dsr(tty, "83"); + break; + } + } else + switch (par[0]) { + case 5: /* DSR - Device status report */ + vte_dsr(tty); + break; + case 6: /* CPR - Cursor position report */ + vte_cpr(tty, 0); + break; + } + priv4 = 0; + return; + } + if (priv1 || priv2 || priv3 || priv4) { + priv1 = priv2 = priv3 = priv4 = 0; + return; + } + /* + * Process control functions with standard parameter strings. + */ + switch (c) { + + /* ===== Control functions w/ intermediate byte ===== */ + case ' ': /* Intermediate byte: SP (ISO 6429) */ + vc_state = EScsi_space; + return; + case '!': /* Intermediate byte: ! (DEC VT series) */ + vc_state = EScsi_exclam; + return; + case '"': /* Intermediate byte: " (DEC VT series) */ + vc_state = EScsi_dquote; + return; + case '$': /* Intermediate byte: $ (DEC VT series) */ + vc_state = EScsi_dollar; + return; + case '&': /* Intermediate byte: & (DEC VT series) */ + vc_state = EScsi_and; + return; + case '*': /* Intermediate byte: * (DEC VT series) */ + vc_state = EScsi_star; + return; + case '+': /* Intermediate byte: + (DEC VT series) */ + vc_state = EScsi_plus; + return; + /* ==== Control functions w/o intermediate byte ==== */ + case '@': /* ICH - Insert character */ + vte_ich(vc, par[0]); + return; + case 'A': /* CUU - Cursor up */ + case 'k': /* VPB - Line position backward */ + if (!par[0]) + par[0]++; + gotoxy(vc, x, y - par[0]); + return; + case 'B': /* CUD - Cursor down */ + case 'e': /* VPR - Line position forward */ + if (!par[0]) + par[0]++; + gotoxy(vc, x, y + par[0]); + return; + case 'C': /* CUF - Cursor right */ + case 'a': /* HPR - Character position forward */ + if (!par[0]) + par[0]++; + gotoxy(vc, x + par[0], y); + return; + case 'D': /* CUB - Cursor left */ + case 'j': /* HPB - Character position backward */ + if (!par[0]) + par[0]++; + gotoxy(vc, x - par[0], y); + return; + case 'E': /* CNL - Cursor next line */ + if (!par[0]) + par[0]++; + gotoxy(vc, 0, y + par[0]); + return; + case 'F': /* CPL - Cursor preceeding line */ + if (!par[0]) + par[0]++; + gotoxy(vc, 0, y - par[0]); + return; + case 'G': /* CHA - Cursor character absolute */ + case '`': /* HPA - Character position absolute */ + if (par[0]) + par[0]--; + gotoxy(vc, par[0], y); + return; + case 'H': /* CUP - Cursor position */ + case 'f': /* HVP - Horizontal and vertical position */ + if (par[0]) + par[0]--; + if (par[1]) + par[1]--; + gotoxay(vc, par[1], par[0]); + return; + case 'I': /* CHT - Cursor forward tabulation */ + if (!par[0]) + par[0]++; + vte_cht(vc, par[0]); + return; + case 'J': /* ED - Erase in page */ + vte_ed(vc, par[0]); + return; + case 'K': /* EL - Erase in line */ + vte_el(vc, par[0]); + return; + case 'L': /* IL - Insert line */ + vte_il(vc, par[0]); + return; + case 'M': /* DL - Delete line */ + vte_dl(vc, par[0]); + return; + case 'P': /* DCH - Delete character */ + vte_dch(vc, par[0]); + return; + case 'U': /* NP - Next page */ + case 'V': /* PP - Preceeding page */ + return; + case 'W': /* CTC - Cursor tabulation control */ + switch (par[0]) { + case 0: /* Set character tab stop at current position */ + tab_stop[x >> 5] |= (1 << (x & 31)); + return; + case 2: /* Clear character tab stop at curr. position */ + vte_tbc(vc, 0); + return; + case 5: /* All character tab stops are cleared. */ + vte_tbc(vc, 5); + return; + } + return; + case 'X': /* ECH - Erase character */ + vte_ech(vc, par[0]); + return; + case 'Y': /* CVT - Cursor line tabulation */ + if (!par[0]) + par[0]++; + vte_cvt(vc, par[0]); + return; + case 'Z': /* CBT - Cursor backward tabulation */ + vte_cbt(vc, par[0]); + return; + case ']': +#ifndef VT_STRICT_ISO + setterm_command(vc); +#endif /* def VT_STRICT_ISO */ + return; + case 'c': /* DA - Device attribute */ + if (!par[0]) + vte_da(tty); + return; + case 'd': /* VPA - Line position absolute */ + if (par[0]) + par[0]--; + gotoxay(vc, x, par[0]); + return; + case 'g': /* TBC - Tabulation clear */ + vte_tbc(vc, par[0]); + return; + case 'm': /* SGR - Select graphics rendition */ + vte_sgr(vc); + return; + + /* ===== Private control sequences ===== */ + + case 'q': /* DECLL - but only 3 leds */ + switch (par[0]) { + case 0: /* all LEDs off */ + case 1: /* LED 1 on */ + case 2: /* LED 2 on */ + case 3: /* LED 3 on */ + setledstate(&vc->kbd_table, + (par[0] < 3) ? par[0] : 4); + case 4: /* LED 4 on */ + ; + } + return; + case 'r': /* DECSTBM - Set top and bottom margin */ + if (!par[0]) + par[0]++; + if (!par[1]) + par[1] = video_num_lines; + /* Minimum allowed region is 2 lines */ + if (par[0] < par[1] && par[1] <= video_num_lines) { + top = par[0] - 1; + bottom = par[1]; + gotoxay(vc, 0, 0); + } + return; + case 's': /* DECSLRM - Set left and right margin */ + return; + case 't': /* DECSLPP - Set lines per page */ + return; + case 'x': /* DECREQTPARM - Request terminal parameters */ + vte_decreptparm(tty); + return; + case 'y': + if (par[0] == 4) { + /* DECTST - Invoke confidence test */ + return; + } + } + return; + case EScsi_space: + vc_state = ESinit; + switch (c) { + /* + * Note: All codes betweem 0x40 and 0x6f are subject to + * standardisation by the ISO. The codes netweem 0x70 + * and 0x7f are free for private use. + */ + case '@': /* SL - Scroll left */ + case 'A': /* SR - Scroll right */ + return; + case 'P': /* PPA - Page position absolute */ + case 'Q': /* PPR - Page position forward */ + case 'R': /* PPB - Page position backward */ + return; + } + return; + case EScsi_exclam: + vc_state = ESinit; + switch (c) { + case 'p': /* DECSTR - Soft terminal reset */ + /* + * Note: On a true DEC VT there are differences + * between RIS and DECSTR. Right now we ignore + * this... -dbk + */ + vte_ris(vc, 1); + return; + } + return; + case EScsi_dquote: + vc_state = ESinit; + switch (c) { + case 'p': /* DECSCL - Set operating level */ + vte_decscl(vc); + return; + case 'q': /* DECSCA - Select character protection + attribute */ + return; + case 'v': /* DECRQDE - Request window report */ + ; + } + return; + case EScsi_dollar: + vc_state = ESinit; + switch (c) { + case 'p': /* DECRQM - Request mode */ + vte_decrqm(tty, priv4); + return; + case 'r': /* DECCARA - Change attributes in rectangular area */ + return; + case 't': /* DECRARA - Reverse attributes in rectangular area */ + return; + case 'u': /* DECRQTSR - Request terminal state */ + if (par[0] == 1) + vte_dectsr(tty); + return; + case 'v': /* DECCRA - Copy rectangular area */ + return; + case 'w': /* DECRQPSR - Request presentation status */ + switch (par[0]) { + case 1: + vte_deccir(tty); + break; + case 2: + vte_dectabsr(tty); + break; + } + return; + case 'x': /* DECFRA - Fill rectangular area */ + return; + case 'z': /* DECERA - Erase rectangular area */ + return; + case '{': /* DECSERA - Selective erase rectangular area */ + return; + case '|': /* DECSCPP - Set columns per page */ + return; + case '}': /* DECSASD - Select active status display */ + return; + case '~': /* DECSSDT - Select status display type + */ + return; + } + return; + case EScsi_and: + vc_state = ESinit; + switch (c) { + case 'u': /* DECRQUPSS - Request user-preferred supplemental set */ + return; + case 'x': /* Enable Session Command */ + return; + } + return; + case EScsi_squote: + vc_state = ESinit; + switch (c) { + case '}': /* DECIC - Insert column */ + return; + case '~': /* DECDC - Delete column */ + return; + } + case EScsi_star: + vc_state = ESinit; + switch (c) { + case 'x': /* DECSACE - Select attribute change extent */ + return; + case 'y': /* DECRQCRA - Request checksum on rectangular area */ + return; + case 'z': /* DECINVM - Invoke macro */ + return; + case '|': /* DECSNLS - Select number of lines */ + return; + case '}': /* DECLFKC - Local function key control + */ + return; + } + return; + case EScsi_plus: + vc_state = ESinit; + switch (c) { + case 'p': /* DECSR - Secure reset */ + return; + } + return; + case ESdocs: + vc_state = ESinit; + switch (c) { + case '@': /* defined in ISO 2022 */ + utf = 0; + return; + case 'G': /* prelim official escape code */ + case '8': /* retained for compatibility */ + utf = 1; + return; + } + return; +#ifdef CONFIG_VT_HP + case ESesc_and: + vc_state = ESinit; + switch (c) { + case 'f': /* Set function key label */ + return; + case 'j': /* Display function key labels */ + return; + } + return; +#endif + case ESfunckey: + vc_state = ESinit; + return; + case ESscf: + vc_state = ESinit; + if (c == '8') { + /* DEC screen alignment test. kludge :-) */ + video_erase_char = + (video_erase_char & 0xff00) | 'E'; + vte_ed(vc, 2); + video_erase_char = + (video_erase_char & 0xff00) | ' '; + do_update_region(vc, origin, screenbuf_size / 2); + } + return; + case ESgzd4: + switch (c) { + case '0': /* DEC Special graphics */ + G0_charset = GRAF_MAP; + break; +#if 0 + case '>': /* DEC Technical */ + G0_charset = DEC_TECH_MAP; + break; +#endif + case 'A': /* ISO Latin-1 supplemental */ + G0_charset = LAT1_MAP; + break; + case 'B': /* ASCII */ + G0_charset = LAT1_MAP; + break; + case 'U': + G0_charset = IBMPC_MAP; + break; + case 'K': + G0_charset = USER_MAP; + break; + } + if (charset == 0) + set_translate(vc, G0_charset); + vc_state = ESinit; + return; + case ESg1d4: + switch (c) { + case '0': /* DEC Special graphics */ + G1_charset = GRAF_MAP; + break; +#if 0 + case '>': /* DEC Technical */ + G1_charset = DEC_TECH_MAP; + break; +#endif + case 'A': /* ISO Latin-1 supplemental */ + G1_charset = LAT1_MAP; + break; + case 'B': /* ASCII */ + G1_charset = LAT1_MAP; + break; + case 'U': + G1_charset = IBMPC_MAP; + break; + case 'K': + G1_charset = USER_MAP; + break; + } + if (charset == 1) + set_translate(vc, G1_charset); + vc_state = ESinit; + return; + case ESg2d4: + switch (c) { + case '0': /* DEC Special graphics */ + G2_charset = GRAF_MAP; + break; +#if 0 + case '>': /* DEC Technical */ + G2_charset = DEC_TECH_MAP; + break; +#endif + case 'A': /* ISO Latin-1 supplemental */ + G2_charset = LAT1_MAP; + break; + case 'B': /* ASCII */ + G2_charset = LAT1_MAP; + break; + case 'U': + G2_charset = IBMPC_MAP; + break; + case 'K': + G2_charset = USER_MAP; + break; + } + if (charset == 1) + set_translate(vc, G2_charset); + vc_state = ESinit; + return; + case ESg3d4: + switch (c) { + case '0': /* DEC Special graphics */ + G3_charset = GRAF_MAP; + break; +#if 0 + case '>': /* DEC Technical */ + G3_charset = DEC_TECH_MAP; + break; +#endif + case 'A': /* ISO Latin-1 supplemental */ + G3_charset = LAT1_MAP; + break; + case 'B': /* ASCII */ + G3_charset = LAT1_MAP; + break; + case 'U': + G3_charset = IBMPC_MAP; + break; + case 'K': + G3_charset = USER_MAP; + break; + } + if (charset == 1) + set_translate(vc, G3_charset); + vc_state = ESinit; + return; + default: + vc_state = ESinit; + } +} =================================================================== This BitKeeper patch contains the following changesets: + ## Wrapped with gzip_uu ## begin 664 bkpatch4191 M'XL(`')]I#T``\0[:7OB1M*?X5=TG#>S,(-!`GPRQV(LV^S8F!>P<TSFX1%2 M8[06$M$!)O'\]ZVJ;@D$PF:N9.)=0W=U===]=/M'=N-S[SCS7]\:CUW'S_[( M+EP_.,Z,]8<9M^TBU[U@9%O.?='A`<QV7!=F2Z'OE7S/*!FPQK7YKA_H`YMG M`:"M!\:(3;GG'V?48B4>">83?ISI:.<WE_5.-OOF#6N,=.>.=WG`WKS)!JXW MU6W3_[<.V[E.,?!TQQ_S0"\:[O@Q!GTL*TH9_MM3#RK*WOZCNJ]4#QX-U515 MO:IR4RE7#_>KV8B<?Z>2L8).590C]7!O;Z_\6%'5\E'VE*G%`_6(*>62JI24 M(Z:6CY7RL5K>50Z.%84]C9V]4MFNDCUAWY:D1M9@O9'ELZ%E<P9\#W3+\5DP MXBS@WMAR=)OQ<6CK@>4Z,&_R(L!S9IE<9S,=(%VFV[8[8SJSK;M1,./X_VP: M,"E$YL_]@(_9T/78Q+.<X!ZPZP$S+=/Y5\!&^I33=B.N3^<.]WWF#E/V+F;? ML^I>%?C87H@XN_N9_[)915>R;Y_A]:/I6:AJ)6.D>R63&].`%XUEJ1[M'3VJ MA]7RWF.Y8@*/=>/0*)L'PV'Y*U$?*?#O<6__J%PE;4X%1\UN\1G)[#@=)'O+ M`,'W(Y.T65G29?5X[PA^MM1EY7OHLL%.K.`]YQ/N"77>X$]*Z1Q[SXA4T*_T M^0Y;8\(O3'DX+*M?H(;?6S3J%XL&V%S]/I[FC*G`9*';UVS7F]$/<&,3QS^? MK4V%X?FSI9=9]I+%]K++3K4&N^UM]FD(WG`G<X^\5ZZ1!SS`+/8??<Q]UI5A MC!':)AN[4VZBWR//!7B3Z)@;!NC%I-K!`<!+CK@'^S0#-M;O`:5M#3DB&X<0 MQ;CN6Z"TNF,20L+ACP$_]VB);OO2S8)W!`@/2)M:!B?W*_8F9#KK]7YE`^Z# M>Q9.?`J?7.F"BZS-W0FZ>=T1*`V2(0'BJ<AH`A<Q^>%DXGJP,_CIX1".[@1+ M1%I#7#.'`.`$W"3NX2(122:>>^?I8X9!Q>-`B#L,9KK':VSNAK2WQTW+#SQK M$`8020*DNP318>S"7G-"!(.A8P*=42`240&^G+=NV#EWN`=";(<#VS+8)7#" M\3F#:#3!$7\$PAD(1+CD#$_1E:=@9RY@)C)JC%O$3%0])*L<;2(Q%ICK$98< MQ"LXO,?<"2[,PXGG#)D>KRUN8L&"4I-9CHAT[H2+&`ADSBS0H@%GH<^'H5T@ M'`#-?F[V+JYO>JS>^I7]7.]TZJW>KS6`#D:H7'S*!2YK/+$M0`VD@74&<Z"` M4%QIG<8%K*F?-"^;H!/`WK-FKZ5UN^SLNL/JK%WO])H-S)I8^Z;3ONYJ1<:Z MG)2!,#S!Z"$)"WAI@C.P;#\F_E<0L`\'M$T1USUN<(M,!71Z,G]>AH1%!V=S M1Z0"](*;-50[QPT*;.99`2KJNG1I_4+"!=9TC&*![1_LL2L=4HOZ%(3:T,<# MSS+OX.-5'?RD6CDJL)MN79)1ROZ>_=%R##L$*WP-CC%\*(%JAF#(H[=K,[X! MVI8V$03S#</]H6U-TN;NN>=P.W47T"'G+FV&>Y[CIB)+/95OZX.T\;'^7]=+ MG1BGC5J.%:2-@UL:^GWXV4S*-*#)#5.#$+U-ZLFYS0W*!%,FI:<=ZZE\A=FA ME<J]R'IA:EGHNC\N62M<Q3'I1]?&0]T`9^RO3PRLP)WX:>AI_[[MWKDKLSN2 MEOY8-SP7UN[`K(AG,H@)/TRNJ41SC)W&3AI2G(#'WC("14CNA&/V%].Z*+Q" M-@/KM&X#//U`K@&8C-;EOE&`"=WP\9=O#/'7W9]FE7ZK\G<9?B/T726>V)<3 MXG=%_#9=P$-[-;K-M;T,WT(@^-6_X\%$]_SXJYOXZD]T@Q?DDCY_,&Q]',V9 M?X1NP.-OKFWK7O0-(DN\RD_`P3EBJ(D=RD->IS#$%0R9Z#8/`B[@KBS?*+($ MV#!TC'L^1U#KS@'O6,A^JJ%@38BK#F?]_FU/ZR,7Q+^<<0C:`:D\4]@[MO.[ M4JE\V&''\*E<J>SD5]:=-KJ;U[7ENK*RMJ[;8YO7_?Y[M&%U;6&]W=B\L!^M M.X!UD7:2KX:?&4:V1`$):>,,#(UJ1=2YW=\P'@'G%8/]$7)O7B15C@YPVX,< MMWDJ>?).K96-G<1D>3&Y;RS,XP(L``^`>P.T'MH!1%8(KZ!)D,8%V#Q@!WO* MQ6\%II8.(;R`E>C,YV!Q9N($I]I9_>:RUS_1+B_[[6:O<8'KTJ=/;SKU7O.Z M)9EU\5OI<,&3RV9+8V>:=LIREV=YVF/J6B:4Q[QO#W/@UD,#BF6C#_%*9R^G M1C[[%RF8Z6)Q[(,'@/-#W-,'D'*R@1L$[AB/+68@)D",O:-(!_X@`SL"+-`, M]?@J!,Z"HL)\;LY>,14%*O#ELYF,@.X+T'XXR4U!Z<%W%20,<"Q?RV:X#>%? MH'@M<LL^>)4^;`-VL`LP#(Z?F;]Z!;"9B>NS5V\DF&_]R?N>.X.)3]F,P[G9 MGWGZA(%6U;*?8H9UM%NMT]66&==I"L:AM4&F$///LSZ#?X(G0-!SS!.,?I)Y MP#A`M,XUTYTYS_/M+5,DEW9W(R[M?B:7&I`0-NOG&K"K=]-I0;W2$3RR'!3% M@D>&MXE'<ML']OHU4VO)O1Y6]SNI-]ZS;KO>T%CNI)N^U<#?M!72_2!HEKN6 MD?`'0?\*D4#W$ITWG2YDJZ0,D,I"MDJ6EFO<]O(RYVQ=][1CJLJ@IC$,US-U MQ^`B>\2,W8(*Q9MX/!"5"T@?(BA4"I=G;,9%]AUX'#Q6@\814P[\Q0?E(YKO M61ZRXI8;8)H_9P8"6IA"8H8.:VPHW$2CBX,?<X)BJJ)"$9K"F@(>C4UA+\$D M^&)AO,A@=IVSB!O,0C,#$/CTZI5@H70=P-MT9J&LH&`X33+LI)=N1,;@6YY- MBC<GM`H/F)F-L*B$D5CO(\&37@3Z`$*Q._D``&_9WD?V@N547`TK7K"*FL^C MG64R`V#]/:[ZM'`L2]ND\`'*G'4V7&QBP^CO8L.RVS1<.QP[2XXS\R`\Y_=B MC=:I@V]MMJ#Z`^>1TTY70A(WG^="Z/B0WT!-!X6>%["7F$@%M:5QA#:@!`N( M53Y8HC%B.5J/1!HZN$+E.(->&BI`+"<]B&E&Z/G`5>QG."::*13.$UN?D]_- M$#[@=PX\;A\!=AE0FD?&H//*T"%P?O5T>81#"(H)5('/7$S<[F3BEC'`B#WI MPLE[/Q089'%I4GJ0WGQ]C0)K,*BFK"N@D"@W6(^7<Q(]8HR$2-Q1U[@CZ`/F M2#8EF9(CA8,@9MU9CF!*'D_S#&<$_.<Q1Z&?=2+9?#-C@*6"-RFDEI=)G8WP MOB!5\.OB>+G*SZVIW9ZHE1T2QY<9YC$,070)/4?$;%30,1_[/)CEZ#01%B*Q MCPW.`BO#Z8FR?.V)*!];*\6_G':9[KNX_1E&NV2<FRSY:XR64H)G!`=VM)W) M?HEE;F5'T4%7[.F)$TD+B]RJT'5)X4-D:M]"^1<,_,+3K''GB9.E:+SZ=^LX MT8XK=`/;J3FM<9%([61'%:MKT7KVL0?(]*ENV7B9@UY+]$74AX>XY/33,S%N MC+8+\XOXA9'X!S$'N1?\I@@MN9TEQTYFPMYF5[W\DGKFH7+.;9@Y%ND#V=T2 M8]/MXEE.;S`:FI?BW2B,KG:I-7KLO%-O7S0;4%RT3ILB<>J>=Y)2P3M@9/LT M0+;[W+.PZ>38<^I(\S$DPSYDR%&3?ZK;(0`H!;50+>S11<=!NHC\NXTER\;\ MZPUSX@0,+4=Z+TSCK8\BLXH<&)@;7MO$)\-.V5`87*3M?9R4^?52=A5Y%,`P M<&T3.QB6@Q6!+]PJ!W$%,FIE%M]EL;."ITQXACJ2Y.)MSC:(E!1$54+D0Z4* MK*<K$_0@9E$NCT=@N9JR?$\LA]H8E@_P$A!KWMQK5B[NL8L_\]*7(^@^@8+6 M6&8"]NV;)'"&IC;L=T!(''Y'=13H"J0:<IG'L1F[Z:"JD!V^(!CK4(KEI+#R M;.@Z`>7!H)OU5K?)?JD4]ZN[ZM'!$>AMXWK7\D?O\A%$E[K(,1I<7)#-`IEW M1)#X%@*J>_)-/M;NHOEC1N!@I!$HML<.&5:783`)H0H4XT06@/7IXA2OB\@@ M"2&/&FH"EOZ=*_UH[IB=J]$7H8=XNKX1>':L"(%[=X=M8BAM-RB'*M1U:'D^ MWB&"<W0$W[^(9TDT7/+.YH$?LXQ8]9I5RGBC)?F)MS\^ZUQ?B>EGF-,\N6HW M^E?U]CK5ZK94"^,2;;TULMD*52M@$5EBFPAV9-V-2,H#/J1[+T$:ZO\2;44A MQF]*8)HME(58'=<;Z_:JQQ`0Y2<@$CXE%7]5K@Z6/`K+.?*V5#H;!_V6&P[L M>3[%V:0)IBR]3<!U$RP8\4=N9-5WI"X7S@."H/6$\TA;63D4=@"BN_/P<A", MV\80TNQ>L\-]M;*[7VKV;EBO6%7W\[&&:`XF&+Y@@F]@2Q^R-(MT),(4P5*_ M24PNP%GN$F]Y(,R'?JQ+46=Z@2.?L`EQM#?DX?KBRPNF/"C#/'MD`]VX%XMJ MV[CWRA$1'FT9558"Z]=MEQJ,DMLM5F^SXU#!'1=<2>)?RD0I)1.QG4'PJ2CL MQ0LFOT,J4#D0CBO:AG[WZ>'/!PFU"XL^QHYWC<RX6;O8I+JR275EDUSJ+E7E M(V;HU?S27IL(A+0ZG$"ZPY?2CT5F=J;?<Z93QG7:[=`%O.,ZNW&N!?8YY#ID MZ-Q/S:J&L+X/64;?]./T"F^BY<>7\%D$)O;2XQ,P:<RWUM,PZL"LC.81T>Y; M\8*'QC`+152#</@!6"`R6WKZ-\S!6('M_.2_^\EW=@J+2[$"$_O"6J!A`BZY M+^Z\Q0K8(L$/V>-K7W=%@MK1VM>='LLUVI2G$J.T7WJ0P&JG&X$!Z!>Y(*4C M.-G,*,S:^$/PS9F$.H=X*6,%0LE?R"JH:U%;FV.C!CUG;LZ#=_E%MDU/4D`O MZ'9H`IY1K(9JPO7@R%&O6[=G^MQGHIH3CXU$!2S<*A98#BUG:C$;^:1UX9DU M^%$["0FB.F,3#.S:@%+['=VVX$73,90=L@RFAB0C`_LK!3'A_4*LVRG.J7;; M;&BLVZOW;KH+3>@FM6#U;F.SU7QW0U$29K*M?4!2][/6H6N;*ZW;K9]K3Y$G M[F?1"SY%Y<J^.Y!8,(>%[&$GA<UU>G-'O*[W>IWFR4WOR2.8^M_%8`A0/X/6 MV[HU9K>]<EF!"#&>P*$&E@TY4;$H:J<UG=\OU]1:N;9?.Z@=UHZ,SY/*XO9: MZ^,%9WQ?S"";4Y>9UM4:UZW3>N?7-?:Q#^*X6#R'DX^R'.^@VUR^X<9!%=AS MY9K<9CGUS32`55#Z'\*G2@4_'>&G*GRJXFRUK)#/+,.B,\L;TRNYZ$E<SG%@ MV"DZ!%*!STT'1&C;$''$8SB?Y10$<1V>[DDI[.CE?\J`W@IGI1C)<*,6$L(H M086YK7&1G'I:I]?\3#$=0VX(143SE.5F^#B.7ECNX*.-S7RK_%-\^^$1_+$? M,^VTT2W@60OQPY*MV:4UP,_VVO7.E7R(*]TNL/"JV:I?XEO$^I4&7[O(//7A MH00LI/^OE)6/FY@#_,,W0N-_AD'T_`2#(/Y75L3_:@HZ0WE]_(J5MV51]XHL MO\>NKD\U5B*%P:&.%@VN,0$KRS&8^,9^INOTW>'PLQIG)9$X`9U3K(01O8\; ME8`&'HA<@/)B`!!);5JK;;E3!N@:[Y&2AL@R[CDD'XA7U@*$+CHI?J>*^7Y@ M"MI>3(W=M_B-$NN"@!#=DMM&'S`#9T0=34F[F#=L[XLPQ*GX<HL."*BWD`!J MDRR??`6\$M-[?8GPK$$]WGC)CT"I0@M!=:%:&(,0!.%B]QQ*-8]B!&9;?_+< MRMU3?/1H^3NF5LJ0!1TJ\OPE^00+G\]BFLA%I]P/AT/+X#7FNV-Z9DP/K7E4 MDH0!A3TV$G_+L_0B'/3?I%@`!0M=!_[('=,:IA%?C8CO-HCX;OQ\Y@F.[2T6 MM>0BSITU[0!Z?<,9LQ\B?DDM(T;23)*1H.U@Q4'?)W3RMF-9[DS,@"'2<QN8 ME@Q<+\!P\%/:V?>CLU_CR:_I:C%Q<I&M)D]VYP;N@SZ/KQS3]>X@UKN?2>_" MP*5>_0IV?;:*?@7/88RG$^$!CXDO758Q>:N8OL8HP;=K]=[7&&4"PPI11]0` MR(C0"<A"ZOF(LZ)%@#THZ=8<:UNOH2$_>E!H1;4/IT;/*E\"@S_#XFKL(UH- MB%V[K$6/C'1[Z4(+'2>6MKHARK0G#&)?B=!=-!IXQ@O7L_[$/\FSHY,:;CAY MSJ[V8]=[*]#<@CE8QF<BB4VZ+9"TL2;\'`2QB;0H`+3",?<@>$$$&.CF*J^= M^V^I@_5V^[+9^!H=3&!8I2RVT!.B[`3J)MWSW!G2]B1+8I-\?W*#*]\#+USP MLN"5D;M/+3V*9=KM)F3J@R0"Z=(6CCVS`<]!'*9^Z9"G[F%S>@AZZF'$MZVQ M%3PCV,-8O=ZW$T3$'80G%JN*HCQMPN44$Q8=@]1\`X\2A^:U9&4Y-%^YD'MC M^A-W00//]O.Q$BXUXI\R><(%-1#PGTHL`"XMKA`SUIHS775$PL@O\5D]/DW$ M:Z"&=SDL70Z_24[4N3S[JHQHL7YQ\$_);+[1["PR.LO!II-X7"EDNBE?-ZPG MFRCRQF$.LEMN:P*NQ.977=S\"O\V@M%?!3RSZ_B?:]W\9+[\*UET0LA'.EO1 MT6T^%)JZ;1U%%M<1A2,9^Z;::+*I+!+%`6;PXA-B0260W0A+_@E)Z'^7[J9` M35>?(HV+!NB6?*DSF`0NRYPOAE9DR_Q3A!@)RF]L5?[?/"D'(CJBLY:-3"6U M'?G<VFU%]_]"='^$W(]EMVC@X)]\BMX--E/(A46-'/D1VS.A<^^X,R=JQ4P\ M/M8=L!-`(*&J.,R]>#C"E*XE?SRO)5^I!LOB$0)?\N#*\N.,[0K&)?VF8PI% M%L@*5!O=C],>;B2JN<5%:;)J6XPG"YIMMJZF[9HL<;:D`&N:-&3+-<>6J-Q4 M1(D*8TM,4&ZDH4H4&=NB\M(EE,S0MT2&27H:MD1JOBS9E21[:2*9-B]-)%/A M+U:&9$:\)7U.NCHG<]"ELR93S*6)9`*YF%C)"!<3R3SO2ZA>OK-]>B4URLB? M+]T-/>THSNN]KY"%T([W]>U0W.NI0A"<:VRI^:GGD.GDEBBL=,L1AM/M]!(" MIT$MH?M":6ZUA)AI[.0TH11261J)0?D$ZR*Q7#XQ:B>43;[`Z28V5P6[SK1Z M8K0J1Q.'5P5)5_7DJ*"IEQP41'570`59O20!@BSMY&L41Z;O6[IS.]V5RQ<\ MYYV$HY&O=GX[_?O,+9FC0+##/AQDX"[D$/]K[EF[V[AQ_9S\BDG:V[&;.M5( MKA.G=7IE2;:UD6W54M)L;W-UQZ.1K5BO2E;B=-/][9=X\#D<:>PDIYL]9RL/ M21`D01```3!&37"4ODM'>0+$(O'YGI/(D-V^BLTB%4*0IW&R@Y0`QF@0]V0T M#/6@?%LX#E4)?[8S]4Y9`BZ;@*FL(LLJV;)M6;;M1^@G+7\JA+81(>DC$KTA MK%%MLK#42IC\'+G(X\4U^59;B]&M[J.JTXW/9=H-B`8RU1US*80VMUK3*:A? M=:E3&;J+(<ZY?7Y*C\YE!GAN]X3`(B177Q#22IIBD@*UGQQRX)I#.RO9:YK$ M$*DI'8_(J4<LX$\!N'[A*B]'>;Y#T9LW:N$5?%IVC^TX0Z)E'YZ7\6A@N.C= M%EEH7@1=P^D/E*_".#]EG,%Z3!TLP.>1F0V'"6E/KCUTK?Z1T;\<]L"=LC>. M%U?8[XW8])NTDV2+Y\]Y4_C<KST86MCMZAD]'\7DD8P1G^\$[2)J8.U@BT]O M<+'U'*OU5)T]5GTW-M34[I3`6Y__?(9_?BO^'P+,?P,$9M.KM(=@TGZ/DS5L MV-UX0E%*!J80DSZ88\AH\@$<;H[^='C.<\E.H&YOAF2_QS@!;,E6K.)LU'H6 MC<A!H[^<Q]+M9[Q(DY5XJ,I[@9XNR).T27[,,)'\'28++]4%3V6#GH6S`<H; M39_%G#?/.6C9P6*6)L,!)+Z16>8X&\Q@#CZ^^J:2L(%AP/81#`7J]R"54B(( MJR\K0!@>76BFUVI-C;(L.GRB+"=("=@W&V&Q\[L1R;9>G7?I(@YFT_?I',+* MUQ#U=##X))+69Y$^"YJU(S'TYDFG<=8-:D?5LVJMVSAC[P;_I?PP)[S&BCZ; MS%50^$006$Z\C$!J,E\1/J9\-!],YJHRL)$AFF;1=QXOVD2Q>;`V6WI0$%;G M'X<_HJ[@,%1PIV<0JJS`$*"N;PAU7)AZH]7H-O3"^$6T_X`%Z:>C]#K-79!Z M2P\F=T'Z?^^"\!!R%P0D9Q"<JZ\:[&S*MCT,75O$[S@9VV`**=R0?V'F&+3W MB8:."R9_O9C'LTLQ"W.X=C>^VW>+B\OA@+/^<#F);--!@-?&@U%\X19,]7VU M6\19EMZE')6(7OJ&]+:9$0(72:ZX)@;>[T$R"2`0^@MB#F"N%STS"D']QA+3 MS5S]QA(9'H#_Q2_:\9]_X5<58B.#;>BK*28IC`[!X*I#;_1WL+WJ*!S]'0RQ MA^7L=[#('E;T=]O\6R-WGN[IF4$C?JML[H2B`P'Y#_#<RA_H.&W.J#&_/]ZW M'/>-^14E<D9Y;M&>+6=4S2Y;\VE&%\;(Y8SRW(HO1@S37B`G&+Y'V>^PM?1$ MZN]P%:`G4G^OP%SGAE/];"P6Q$^5S/BIK!R9GX&FV5&>5]U3<58TN\UJ"SV& M&[RM3RGD5`6;DM]-$B\7[D:7.QQB#@4J6\N9X:H9D',-^@9`PD(Z[J&.E*Z- MUJ`:+2?#)":?2^);,<4B"?EB(G8M!.EP]KWW0AJ!D.Q.\_#H99MS.HI_'-2& ME_>S^122EOV\:?0"[D%;'.A&MG?H`F-*,00HRPR@I2'\P#Q0;9NW01H_&"?( M:<O93/2"=U_)=#Y)YURU<WC&C&B(-[E0ET*8))=RF)..+Z6,@&[CAQ`CX31Z MR#.1-Q:<:Y/#TA0P1!G:LH8MSH>^9#ATJ0+J',P0[FA0Z,E4P*F=,F>3*!(@ M:&1[G+Q-?`.#3L1-X7?9^%TQ?F_S[^R^:56[D8Q#LW:M+'!W[>%9]8"_ZX^E M[%9RK_;AT_)ZH'_U9*QZ">^'W,C&3(2?J*.-*I2L8KA`CYVG6_"9B9IT4;H" MTE43=8\44)*>)%45%\G(J/EV.9[)C%&JPL2HP.%TAI@OO;RX0GPNQ'... [truncated message content] |
|
From: Linus T. <tor...@tr...> - 2002-10-09 19:51:36
|
On Wed, 9 Oct 2002, James Simmons wrote: > > This patch moves the terminal emulation code out of vt.c. Not in use yet > but I wanted to make the patch as small as possible. Actually, I find that a small patch that does nothing useful is never preferable over a larger patch that actually _does_ something. I hate having many "nonsense patches" followed by one small patch to enable it all. That just hides the real changes, and then the small patch _looks_ innocent, even though it may break everything in very subtle ways. Linus |
|
From: James S. <jsi...@ph...> - 2002-10-10 20:18:00
|
Okay. Just ignore the last patch I sent you. The other patchs are fine and don't depended on that last pacth. On Wed, 9 Oct 2002, Linus Torvalds wrote: > > On Wed, 9 Oct 2002, James Simmons wrote: > > > > This patch moves the terminal emulation code out of vt.c. Not in use yet > > but I wanted to make the patch as small as possible. > > Actually, I find that a small patch that does nothing useful is never > preferable over a larger patch that actually _does_ something. > > I hate having many "nonsense patches" followed by one small patch to > enable it all. That just hides the real changes, and then the small patch > _looks_ innocent, even though it may break everything in very subtle ways. > > Linus > > |
×
Want the latest updates on software, tech news, and AI?
Get latest updates about software, tech news, and AI from SourceForge directly in your inbox once a month.
Thanks for helping keep SourceForge clean.
X