X-Git-Url: https://git.distorted.org.uk/u/mdw/putty/blobdiff_plain/c83de30314874097728e01c7e7e94144548032b0..fabd1805a8f429ca83b4271aabd1206ac3537ebb:/terminal.c diff --git a/terminal.c b/terminal.c index 42f8de12..005bee55 100644 --- a/terminal.c +++ b/terminal.c @@ -1,5 +1,3 @@ -#include - #include #include #include @@ -7,20 +5,34 @@ #include #include #include "putty.h" -#include "tree234.h" - -#define CL_ANSIMIN 0x0001 /* Codes in all ANSI like terminals. */ -#define CL_VT100 0x0002 /* VT100 */ -#define CL_VT100AVO 0x0004 /* VT100 +AVO; 132x24 (not 132x14) & attrs */ -#define CL_VT102 0x0008 /* VT102 */ -#define CL_VT220 0x0010 /* VT220 */ -#define CL_VT320 0x0020 /* VT320 */ -#define CL_VT420 0x0040 /* VT420 */ -#define CL_VT510 0x0080 /* VT510, NB VT510 includes ANSI */ -#define CL_VT340TEXT 0x0100 /* VT340 extensions that appear in the VT420 */ -#define CL_SCOANSI 0x1000 /* SCOANSI not in ANSIMIN. */ -#define CL_ANSI 0x2000 /* ANSI ECMA-48 not in the VT100..VT420 */ -#define CL_OTHER 0x4000 /* Others, Xterm, linux, putty, dunno, etc */ +#include "terminal.h" + +#define poslt(p1,p2) ( (p1).y < (p2).y || ( (p1).y == (p2).y && (p1).x < (p2).x ) ) +#define posle(p1,p2) ( (p1).y < (p2).y || ( (p1).y == (p2).y && (p1).x <= (p2).x ) ) +#define poseq(p1,p2) ( (p1).y == (p2).y && (p1).x == (p2).x ) +#define posdiff(p1,p2) ( ((p1).y - (p2).y) * (term->cols+1) + (p1).x - (p2).x ) + +/* Product-order comparisons for rectangular block selection. */ +#define posPlt(p1,p2) ( (p1).y <= (p2).y && (p1).x < (p2).x ) +#define posPle(p1,p2) ( (p1).y <= (p2).y && (p1).x <= (p2).x ) + +#define incpos(p) ( (p).x == term->cols ? ((p).x = 0, (p).y++, 1) : ((p).x++, 0) ) +#define decpos(p) ( (p).x == 0 ? ((p).x = term->cols, (p).y--, 1) : ((p).x--, 0) ) + +#define VT52_PLUS + +#define CL_ANSIMIN 0x0001 /* Codes in all ANSI like terminals. */ +#define CL_VT100 0x0002 /* VT100 */ +#define CL_VT100AVO 0x0004 /* VT100 +AVO; 132x24 (not 132x14) & attrs */ +#define CL_VT102 0x0008 /* VT102 */ +#define CL_VT220 0x0010 /* VT220 */ +#define CL_VT320 0x0020 /* VT320 */ +#define CL_VT420 0x0040 /* VT420 */ +#define CL_VT510 0x0080 /* VT510, NB VT510 includes ANSI */ +#define CL_VT340TEXT 0x0100 /* VT340 extensions that appear in the VT420 */ +#define CL_SCOANSI 0x1000 /* SCOANSI not in ANSIMIN. */ +#define CL_ANSI 0x2000 /* ANSI ECMA-48 not in the VT100..VT420 */ +#define CL_OTHER 0x4000 /* Others, Xterm, linux, putty, dunno, etc */ #define TM_VT100 (CL_ANSIMIN|CL_VT100) #define TM_VT100AVO (TM_VT100|CL_VT100AVO) @@ -32,332 +44,406 @@ #define TM_PUTTY (0xFFFF) #define compatibility(x) \ - if ( ((CL_##x)&compatibility_level) == 0 ) { \ - termstate=TOPLEVEL; \ + if ( ((CL_##x)&term->compatibility_level) == 0 ) { \ + term->termstate=TOPLEVEL; \ break; \ } #define compatibility2(x,y) \ - if ( ((CL_##x|CL_##y)&compatibility_level) == 0 ) { \ - termstate=TOPLEVEL; \ + if ( ((CL_##x|CL_##y)&term->compatibility_level) == 0 ) { \ + term->termstate=TOPLEVEL; \ break; \ } -#define has_compat(x) ( ((CL_##x)&compatibility_level) != 0 ) - -static int compatibility_level = TM_PUTTY; - -static tree234 *scrollback; /* lines scrolled off top of screen */ -static tree234 *screen; /* lines on primary screen */ -static tree234 *alt_screen; /* lines on alternate screen */ -static int disptop; /* distance scrolled back (0 or -ve) */ - -static unsigned long *cpos; /* cursor position (convenience) */ +#define has_compat(x) ( ((CL_##x)&term->compatibility_level) != 0 ) -static unsigned long *disptext; /* buffer of text on real screen */ -static unsigned long *wanttext; /* buffer of text we want on screen */ - -#define VBELL_TIMEOUT 100 /* millisecond len of visual bell */ - -struct beeptime { - struct beeptime *next; - long ticks; -}; -static struct beeptime *beephead, *beeptail; -int nbeeps; -int beep_overloaded; -long lastbeep; - -static unsigned char *selspace; /* buffer for building selections in */ - -#define TSIZE (sizeof(unsigned long)) -#define fix_cpos do { cpos = lineptr(curs.y) + curs.x; } while(0) - -static unsigned long curr_attr, save_attr; -static unsigned long erase_char = ERASE_CHAR; - -typedef struct { - int y, x; -} pos; -#define poslt(p1,p2) ( (p1).y < (p2).y || ( (p1).y == (p2).y && (p1).x < (p2).x ) ) -#define posle(p1,p2) ( (p1).y < (p2).y || ( (p1).y == (p2).y && (p1).x <= (p2).x ) ) -#define poseq(p1,p2) ( (p1).y == (p2).y && (p1).x == (p2).x ) -#define posdiff(p1,p2) ( ((p2).y - (p1).y) * (cols+1) + (p2).x - (p1).x ) -#define incpos(p) ( (p).x == cols ? ((p).x = 0, (p).y++, 1) : ((p).x++, 0) ) -#define decpos(p) ( (p).x == 0 ? ((p).x = cols, (p).y--, 1) : ((p).x--, 0) ) - -static pos curs; /* cursor */ -static pos savecurs; /* saved cursor position */ -static int marg_t, marg_b; /* scroll margins */ -static int dec_om; /* DEC origin mode flag */ -static int wrap, wrapnext; /* wrap flags */ -static int insert; /* insert-mode flag */ -static int cset; /* 0 or 1: which char set */ -static int save_cset, save_csattr; /* saved with cursor position */ -static int rvideo; /* global reverse video flag */ -static int rvbell_timeout; /* for ESC[?5hESC[?5l vbell */ -static int cursor_on; /* cursor enabled flag */ -static int reset_132; /* Flag ESC c resets to 80 cols */ -static int use_bce; /* Use Background coloured erase */ -static int blinker; /* When blinking is the cursor on ? */ -static int tblinker; /* When the blinking text is on */ -static int blink_is_real; /* Actually blink blinking text */ -static int term_echoing; /* Does terminal want local echo? */ -static int term_editing; /* Does terminal want local edit? */ - -static unsigned long cset_attr[2]; +#define sel_nl_sz (sizeof(sel_nl)/sizeof(wchar_t)) +const wchar_t sel_nl[] = SEL_NL; /* - * Saved settings on the alternate screen. + * Fetch the character at a particular position in a line array, + * for purposes of `wordtype'. The reason this isn't just a simple + * array reference is that if the character we find is UCSWIDE, + * then we must look one space further to the left. */ -static int alt_x, alt_y, alt_om, alt_wrap, alt_wnext, alt_ins, alt_cset; -static int alt_t, alt_b; -static int alt_which; - -#define ARGS_MAX 32 /* max # of esc sequence arguments */ -#define ARG_DEFAULT 0 /* if an arg isn't specified */ -#define def(a,d) ( (a) == ARG_DEFAULT ? (d) : (a) ) -static int esc_args[ARGS_MAX]; -static int esc_nargs; -static int esc_query; -#define ANSI(x,y) ((x)+((y)<<8)) -#define ANSI_QUE(x) ANSI(x,TRUE) - -#define OSC_STR_MAX 2048 -static int osc_strlen; -static char osc_string[OSC_STR_MAX+1]; -static int osc_w; - -static char id_string[1024] = "\033[?6c"; - -static unsigned char *tabs; - -static enum { - TOPLEVEL, - SEEN_ESC, - SEEN_CSI, - SEEN_OSC, - SEEN_OSC_W, - - DO_CTRLS, - - IGNORE_NEXT, - SET_GL, SET_GR, - SEEN_OSC_P, - OSC_STRING, OSC_MAYBE_ST, - SEEN_ESCHASH, - VT52_ESC, - VT52_Y1, - VT52_Y2 -} termstate; - -static enum { - NO_SELECTION, ABOUT_TO, DRAGGING, SELECTED -} selstate; -static enum { - SM_CHAR, SM_WORD, SM_LINE -} selmode; -static pos selstart, selend, selanchor; - -static short wordness[256] = { - 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 01 */ - 0,1,2,1,1,1,1,1,1,1,1,1,1,2,2,2, 2,2,2,2,2,2,2,2,2,2,1,1,1,1,1,1, /* 23 */ - 1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, 2,2,2,2,2,2,2,2,2,2,2,1,1,1,1,2, /* 45 */ - 1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, 2,2,2,2,2,2,2,2,2,2,2,1,1,1,1,1, /* 67 */ - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 89 */ - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* AB */ - 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, 2,2,2,2,2,2,2,1,2,2,2,2,2,2,2,2, /* CD */ - 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, 2,2,2,2,2,2,2,1,2,2,2,2,2,2,2,2, /* EF */ -}; - -static unsigned char sel_nl[] = SEL_NL; -static char * paste_buffer = 0; -static int paste_len, paste_pos, paste_hold; +#define UCSGET(a, x) \ + ( (x)>0 && ((a)[(x)] & (CHAR_MASK | CSET_MASK)) == UCSWIDE ? \ + (a)[(x)-1] : (a)[(x)] ) /* * Internal prototypes. */ -static void do_paint (Context, int); -static void erase_lots (int, int, int); -static void swap_screen (int); -static void update_sbar (void); -static void deselect (void); -/* log session to file stuff ... */ -static FILE *lgfp = NULL; -static void logtraffic(unsigned char c, int logmode); +static unsigned long *resizeline(unsigned long *, int); +static unsigned long *lineptr(Terminal *, int, int); +static void do_paint(Terminal *, Context, int); +static void erase_lots(Terminal *, int, int, int); +static void swap_screen(Terminal *, int, int, int); +static void update_sbar(Terminal *); +static void deselect(Terminal *); +static void term_print_finish(Terminal *); +#ifdef OPTIMISE_SCROLL +static void scroll_display(Terminal *, int, int, int); +#endif /* OPTIMISE_SCROLL */ + +/* + * Resize a line to make it `cols' columns wide. + */ +static unsigned long *resizeline(unsigned long *line, int cols) +{ + int i, oldlen; + unsigned long lineattrs; + + if (line[0] != (unsigned long)cols) { + /* + * This line is the wrong length, which probably means it + * hasn't been accessed since a resize. Resize it now. + */ + oldlen = line[0]; + lineattrs = line[oldlen + 1]; + line = srealloc(line, TSIZE * (2 + cols)); + line[0] = cols; + for (i = oldlen; i < cols; i++) + line[i + 1] = ERASE_CHAR; + line[cols + 1] = lineattrs & LATTR_MODE; + } + + return line; +} /* * Retrieve a line of the screen or of the scrollback, according to * whether the y coordinate is non-negative or negative * (respectively). */ -unsigned long *lineptr(int y, int lineno) { - unsigned long *line, lineattrs; +static unsigned long *lineptr(Terminal *term, int y, int lineno) +{ + unsigned long *line, *newline; tree234 *whichtree; - int i, treeindex, oldlen; + int treeindex; if (y >= 0) { - whichtree = screen; + whichtree = term->screen; treeindex = y; } else { - whichtree = scrollback; - treeindex = y + count234(scrollback); + whichtree = term->scrollback; + treeindex = y + count234(term->scrollback); } line = index234(whichtree, treeindex); /* We assume that we don't screw up and retrieve something out of range. */ -if (line == NULL) { -debug(("line=%d y=%d treeindex=%d\n", lineno, y, treeindex)); -debug(("screen:%d scrollback:%d\n", count234(screen), count234(scrollback))); assert(line != NULL); -} - if (line[0] != cols) { - /* - * This line is the wrong length, which probably means it - * hasn't been accessed since a resize. Resize it now. - */ - oldlen = line[0]; - lineattrs = line[oldlen+1]; + newline = resizeline(line, term->cols); + if (newline != line) { delpos234(whichtree, treeindex); - line = srealloc(line, TSIZE * (2+cols)); - line[0] = cols; - for (i = oldlen; i < cols; i++) - line[i+1] = ERASE_CHAR; - line[cols+1] = lineattrs & LATTR_MODE; - addpos234(whichtree, line, treeindex); + addpos234(whichtree, newline, treeindex); + line = newline; } - return line+1; + return line + 1; } -#define lineptr(x) lineptr(x,__LINE__) + +#define lineptr(x) lineptr(term,x,__LINE__) + /* * Set up power-on settings for the terminal. */ -static void power_on(void) { - curs.x = curs.y = alt_x = alt_y = savecurs.x = savecurs.y = 0; - alt_t = marg_t = 0; - if (rows != -1) - alt_b = marg_b = rows - 1; +static void power_on(Terminal *term) +{ + term->curs.x = term->curs.y = 0; + term->alt_x = term->alt_y = 0; + term->savecurs.x = term->savecurs.y = 0; + term->alt_t = term->marg_t = 0; + if (term->rows != -1) + term->alt_b = term->marg_b = term->rows - 1; else - alt_b = marg_b = 0; - if (cols != -1) { + term->alt_b = term->marg_b = 0; + if (term->cols != -1) { int i; - for (i = 0; i < cols; i++) - tabs[i] = (i % 8 == 0 ? TRUE : FALSE); + for (i = 0; i < term->cols; i++) + term->tabs[i] = (i % 8 == 0 ? TRUE : FALSE); } - alt_om = dec_om = cfg.dec_om; - alt_wnext = wrapnext = alt_ins = insert = FALSE; - alt_wrap = wrap = cfg.wrap_mode; - alt_cset = cset = 0; - cset_attr[0] = cset_attr[1] = ATTR_ASCII; - rvideo = 0; - in_vbell = FALSE; - cursor_on = 1; - save_attr = curr_attr = ATTR_DEFAULT; - term_editing = term_echoing = FALSE; - ldisc_send(NULL, 0); /* cause ldisc to notice changes */ - app_cursor_keys = cfg.app_cursor; - app_keypad_keys = cfg.app_keypad; - use_bce = cfg.bce; - blink_is_real = cfg.blinktext; - erase_char = ERASE_CHAR; - alt_which = 0; + term->alt_om = term->dec_om = term->cfg.dec_om; + term->alt_ins = term->insert = FALSE; + term->alt_wnext = term->wrapnext = term->save_wnext = FALSE; + term->alt_wrap = term->wrap = term->cfg.wrap_mode; + term->alt_cset = term->cset = term->save_cset = 0; + term->alt_utf = term->utf = term->save_utf = 0; + term->utf_state = 0; + term->alt_sco_acs = term->sco_acs = term->save_sco_acs = 0; + term->cset_attr[0] = term->cset_attr[1] = term->save_csattr = ATTR_ASCII; + term->rvideo = 0; + term->in_vbell = FALSE; + term->cursor_on = 1; + term->big_cursor = 0; + term->save_attr = term->curr_attr = ATTR_DEFAULT; + term->term_editing = term->term_echoing = FALSE; + term->app_cursor_keys = term->cfg.app_cursor; + term->app_keypad_keys = term->cfg.app_keypad; + term->use_bce = term->cfg.bce; + term->blink_is_real = term->cfg.blinktext; + term->erase_char = ERASE_CHAR; + term->alt_which = 0; + term_print_finish(term); { int i; for (i = 0; i < 256; i++) - wordness[i] = cfg.wordness[i]; + term->wordness[i] = term->cfg.wordness[i]; } - if (screen) { - swap_screen (1); - erase_lots (FALSE, TRUE, TRUE); - swap_screen (0); - erase_lots (FALSE, TRUE, TRUE); + if (term->screen) { + swap_screen(term, 1, FALSE, FALSE); + erase_lots(term, FALSE, TRUE, TRUE); + swap_screen(term, 0, FALSE, FALSE); + erase_lots(term, FALSE, TRUE, TRUE); } } /* * Force a screen update. */ -void term_update(void) { +void term_update(Terminal *term) +{ Context ctx; - ctx = get_ctx(); + ctx = get_ctx(term->frontend); if (ctx) { - if ( (seen_key_event && (cfg.scroll_on_key)) || - (seen_disp_event && (cfg.scroll_on_disp)) ) { - disptop = 0; /* return to main screen */ - seen_disp_event = seen_key_event = 0; - update_sbar(); + int need_sbar_update = term->seen_disp_event; + if (term->seen_disp_event && term->cfg.scroll_on_disp) { + term->disptop = 0; /* return to main screen */ + term->seen_disp_event = 0; + need_sbar_update = TRUE; } - do_paint (ctx, TRUE); - sys_cursor(curs.x, curs.y - disptop); - free_ctx (ctx); + if (need_sbar_update) + update_sbar(term); + do_paint(term, ctx, TRUE); + sys_cursor(term->frontend, term->curs.x, term->curs.y - term->disptop); + free_ctx(ctx); + } +} + +/* + * Called from front end when a keypress occurs, to trigger + * anything magical that needs to happen in that situation. + */ +void term_seen_key_event(Terminal *term) +{ + /* + * On any keypress, clear the bell overload mechanism + * completely, on the grounds that large numbers of + * beeps coming from deliberate key action are likely + * to be intended (e.g. beeps from filename completion + * blocking repeatedly). + */ + term->beep_overloaded = FALSE; + while (term->beephead) { + struct beeptime *tmp = term->beephead; + term->beephead = tmp->next; + sfree(tmp); + } + term->beeptail = NULL; + term->nbeeps = 0; + + /* + * Reset the scrollback on keypress, if we're doing that. + */ + if (term->cfg.scroll_on_key) { + term->disptop = 0; /* return to main screen */ + term->seen_disp_event = 1; } } /* * Same as power_on(), but an external function. */ -void term_pwron(void) { - power_on(); +void term_pwron(Terminal *term) +{ + power_on(term); + if (term->ldisc) /* cause ldisc to notice changes */ + ldisc_send(term->ldisc, NULL, 0, 0); fix_cpos; - disptop = 0; - deselect(); - term_update(); + term->disptop = 0; + deselect(term); + term_update(term); +} + +/* + * When the user reconfigures us, we need to check the forbidden- + * alternate-screen config option, disable raw mouse mode if the + * user has disabled mouse reporting, and abandon a print job if + * the user has disabled printing. + */ +void term_reconfig(Terminal *term, Config *cfg) +{ + /* + * Before adopting the new config, check all those terminal + * settings which control power-on defaults; and if they've + * changed, we will modify the current state as well as the + * default one. The full list is: Auto wrap mode, DEC Origin + * Mode, BCE, blinking text, character classes. + */ + int reset_wrap, reset_decom, reset_bce, reset_blink, reset_charclass; + int i; + + reset_wrap = (term->cfg.wrap_mode != cfg->wrap_mode); + reset_decom = (term->cfg.dec_om != cfg->dec_om); + reset_bce = (term->cfg.bce != cfg->bce); + reset_blink = (term->cfg.blinktext != cfg->blinktext); + reset_charclass = 0; + for (i = 0; i < lenof(term->cfg.wordness); i++) + if (term->cfg.wordness[i] != cfg->wordness[i]) + reset_charclass = 1; + + term->cfg = *cfg; /* STRUCTURE COPY */ + + if (reset_wrap) + term->alt_wrap = term->wrap = term->cfg.wrap_mode; + if (reset_decom) + term->alt_om = term->dec_om = term->cfg.dec_om; + if (reset_bce) + term->use_bce = term->cfg.bce; + if (reset_blink) + term->blink_is_real = term->cfg.blinktext; + if (reset_charclass) + for (i = 0; i < 256; i++) + term->wordness[i] = term->cfg.wordness[i]; + + if (term->cfg.no_alt_screen) + swap_screen(term, 0, FALSE, FALSE); + if (term->cfg.no_mouse_rep) { + term->xterm_mouse = 0; + set_raw_mouse_mode(term->frontend, 0); + } + if (term->cfg.no_remote_charset) { + term->cset_attr[0] = term->cset_attr[1] = ATTR_ASCII; + term->sco_acs = term->alt_sco_acs = 0; + term->utf = 0; + } + if (!*term->cfg.printer) { + term_print_finish(term); + } } /* * Clear the scrollback. */ -void term_clrsb(void) { +void term_clrsb(Terminal *term) +{ unsigned long *line; - disptop = 0; - while ((line = delpos234(scrollback, 0)) != NULL) { + term->disptop = 0; + while ((line = delpos234(term->scrollback, 0)) != NULL) { sfree(line); } - update_sbar(); + update_sbar(term); } /* * Initialise the terminal. */ -void term_init(void) { - screen = alt_screen = scrollback = NULL; - disptop = 0; - disptext = wanttext = NULL; - tabs = NULL; - selspace = NULL; - deselect(); - rows = cols = -1; - power_on(); - beephead = beeptail = NULL; - nbeeps = 0; - lastbeep = FALSE; - beep_overloaded = FALSE; +Terminal *term_init(Config *mycfg, struct unicode_data *ucsdata, + void *frontend) +{ + Terminal *term; + + /* + * Allocate a new Terminal structure and initialise the fields + * that need it. + */ + term = smalloc(sizeof(Terminal)); + term->frontend = frontend; + term->ucsdata = ucsdata; + term->cfg = *mycfg; /* STRUCTURE COPY */ + term->logctx = NULL; + term->compatibility_level = TM_PUTTY; + strcpy(term->id_string, "\033[?6c"); + term->last_blink = term->last_tblink = 0; + term->paste_buffer = NULL; + term->paste_len = 0; + term->last_paste = 0; + bufchain_init(&term->inbuf); + bufchain_init(&term->printer_buf); + term->printing = term->only_printing = FALSE; + term->print_job = NULL; + term->vt52_mode = FALSE; + term->cr_lf_return = FALSE; + term->seen_disp_event = FALSE; + term->xterm_mouse = term->mouse_is_down = FALSE; + term->reset_132 = FALSE; + term->blinker = term->tblinker = 0; + term->has_focus = 1; + term->repeat_off = FALSE; + term->termstate = TOPLEVEL; + term->selstate = NO_SELECTION; + term->curstype = 0; + + term->screen = term->alt_screen = term->scrollback = NULL; + term->disptop = 0; + term->disptext = term->dispcurs = NULL; + term->tabs = NULL; + deselect(term); + term->rows = term->cols = -1; + power_on(term); + term->beephead = term->beeptail = NULL; + term->nbeeps = 0; + term->lastbeep = FALSE; + term->beep_overloaded = FALSE; + term->attr_mask = 0xffffffff; + term->resize_fn = NULL; + term->resize_ctx = NULL; + + return term; +} + +void term_free(Terminal *term) +{ + unsigned long *line; + struct beeptime *beep; + + while ((line = delpos234(term->scrollback, 0)) != NULL) + sfree(line); + freetree234(term->scrollback); + while ((line = delpos234(term->screen, 0)) != NULL) + sfree(line); + freetree234(term->screen); + while ((line = delpos234(term->alt_screen, 0)) != NULL) + sfree(line); + freetree234(term->alt_screen); + sfree(term->disptext); + while (term->beephead) { + beep = term->beephead; + term->beephead = beep->next; + sfree(beep); + } + bufchain_clear(&term->inbuf); + if(term->print_job) + printer_finish_job(term->print_job); + bufchain_clear(&term->printer_buf); + sfree(term->paste_buffer); + sfree(term); } /* * Set up the terminal for a given size. */ -void term_size(int newrows, int newcols, int newsavelines) { - tree234 *newsb, *newscreen, *newalt; - unsigned long *newdisp, *newwant, *oldline, *line; - int i, j, ccols; +void term_size(Terminal *term, int newrows, int newcols, int newsavelines) +{ + tree234 *newalt; + unsigned long *newdisp, *line; + int i, j; int sblen; - int save_alt_which = alt_which; + int save_alt_which = term->alt_which; - if (newrows == rows && newcols == cols && newsavelines == savelines) + if (newrows == term->rows && newcols == term->cols && + newsavelines == term->savelines) return; /* nothing to do */ - deselect(); - swap_screen(0); + deselect(term); + swap_screen(term, 0, FALSE, FALSE); - alt_t = marg_t = 0; - alt_b = marg_b = newrows - 1; + term->alt_t = term->marg_t = 0; + term->alt_b = term->marg_b = newrows - 1; - if (rows == -1) { - scrollback = newtree234(NULL); - screen = newtree234(NULL); - rows = 0; + if (term->rows == -1) { + term->scrollback = newtree234(NULL); + term->screen = newtree234(NULL); + term->rows = 0; } /* @@ -380,140 +466,194 @@ void term_size(int newrows, int newcols, int newsavelines) { * amount of scrollback we actually have, we must throw some * away. */ - sblen = count234(scrollback); - debug(("resizing rows=%d sblen=%d newrows=%d newsb=%d\n", - rows, sblen, newrows, newsavelines)); - if (newrows > rows) { - for (i = rows; i < newrows; i++) { - if (sblen > 0) { - line = delpos234(scrollback, --sblen); - } else { - line = smalloc(TSIZE * (newcols+2)); - line[0] = newcols; - for (j = 0; j <= newcols; j++) - line[j+1] = ERASE_CHAR; - } - addpos234(screen, line, 0); - } - } else if (newrows < rows) { - for (i = newrows; i < rows; i++) { - line = delpos234(screen, 0); - addpos234(scrollback, line, sblen++); + sblen = count234(term->scrollback); + /* Do this loop to expand the screen if newrows > rows */ + for (i = term->rows; i < newrows; i++) { + if (sblen > 0) { + line = delpos234(term->scrollback, --sblen); + } else { + line = smalloc(TSIZE * (newcols + 2)); + line[0] = newcols; + for (j = 0; j <= newcols; j++) + line[j + 1] = ERASE_CHAR; } + addpos234(term->screen, line, 0); } - assert(count234(screen) == newrows); + /* Do this loop to shrink the screen if newrows < rows */ + for (i = newrows; i < term->rows; i++) { + line = delpos234(term->screen, 0); + addpos234(term->scrollback, line, sblen++); + } + assert(count234(term->screen) == newrows); while (sblen > newsavelines) { - line = delpos234(scrollback, 0); + line = delpos234(term->scrollback, 0); sfree(line); sblen--; } - assert(count234(scrollback) <= newsavelines); - debug(("screen:%d scrollback:%d\n", count234(screen), count234(scrollback))); - disptop = 0; + assert(count234(term->scrollback) <= newsavelines); + term->disptop = 0; - newdisp = smalloc (newrows*(newcols+1)*TSIZE); - for (i=0; idisptext); + term->disptext = newdisp; + term->dispcurs = NULL; newalt = newtree234(NULL); - for (i=0; ierase_char; addpos234(newalt, line, i); } - if (alt_screen) { - while (NULL != (line = delpos234(alt_screen, 0))) + if (term->alt_screen) { + while (NULL != (line = delpos234(term->alt_screen, 0))) sfree(line); - freetree234(alt_screen); + freetree234(term->alt_screen); } - alt_screen = newalt; + term->alt_screen = newalt; - sfree (selspace); - selspace = smalloc ( (newrows+newsavelines) * (newcols+sizeof(sel_nl)) ); - - tabs = srealloc (tabs, newcols*sizeof(*tabs)); + term->tabs = srealloc(term->tabs, newcols * sizeof(*term->tabs)); { int i; - for (i = (cols > 0 ? cols : 0); i < newcols; i++) - tabs[i] = (i % 8 == 0 ? TRUE : FALSE); + for (i = (term->cols > 0 ? term->cols : 0); i < newcols; i++) + term->tabs[i] = (i % 8 == 0 ? TRUE : FALSE); } - if (rows > 0) - curs.y += newrows - rows; - if (curs.y < 0) - curs.y = 0; - if (curs.y >= newrows) - curs.y = newrows-1; - if (curs.x >= newcols) - curs.x = newcols-1; - alt_x = alt_y = 0; - wrapnext = alt_wnext = FALSE; - - rows = newrows; - cols = newcols; - savelines = newsavelines; + if (term->rows > 0) + term->curs.y += newrows - term->rows; + if (term->curs.y < 0) + term->curs.y = 0; + if (term->curs.y >= newrows) + term->curs.y = newrows - 1; + if (term->curs.x >= newcols) + term->curs.x = newcols - 1; + term->alt_x = term->alt_y = 0; + term->wrapnext = term->alt_wnext = FALSE; + + term->rows = newrows; + term->cols = newcols; + term->savelines = newsavelines; fix_cpos; - swap_screen(save_alt_which); + swap_screen(term, save_alt_which, FALSE, FALSE); + + update_sbar(term); + term_update(term); + if (term->resize_fn) + term->resize_fn(term->resize_ctx, term->cols, term->rows); +} - update_sbar(); - term_update(); +/* + * Hand a function and context pointer to the terminal which it can + * use to notify a back end of resizes. + */ +void term_provide_resize_fn(Terminal *term, + void (*resize_fn)(void *, int, int), + void *resize_ctx) +{ + term->resize_fn = resize_fn; + term->resize_ctx = resize_ctx; + if (term->cols > 0 && term->rows > 0) + resize_fn(resize_ctx, term->cols, term->rows); } /* - * Swap screens. + * Swap screens. If `reset' is TRUE and we have been asked to + * switch to the alternate screen, we must bring most of its + * configuration from the main screen and erase the contents of the + * alternate screen completely. (This is even true if we're already + * on it! Blame xterm.) */ -static void swap_screen (int which) { +static void swap_screen(Terminal *term, int which, int reset, int keep_cur_pos) +{ int t; tree234 *ttr; - if (which == alt_which) - return; - - alt_which = which; + if (!which) + reset = FALSE; /* do no weird resetting if which==0 */ + + if (which != term->alt_which) { + term->alt_which = which; + + ttr = term->alt_screen; + term->alt_screen = term->screen; + term->screen = ttr; + t = term->curs.x; + if (!reset && !keep_cur_pos) + term->curs.x = term->alt_x; + term->alt_x = t; + t = term->curs.y; + if (!reset && !keep_cur_pos) + term->curs.y = term->alt_y; + term->alt_y = t; + t = term->marg_t; + if (!reset) term->marg_t = term->alt_t; + term->alt_t = t; + t = term->marg_b; + if (!reset) term->marg_b = term->alt_b; + term->alt_b = t; + t = term->dec_om; + if (!reset) term->dec_om = term->alt_om; + term->alt_om = t; + t = term->wrap; + if (!reset) term->wrap = term->alt_wrap; + term->alt_wrap = t; + t = term->wrapnext; + if (!reset) term->wrapnext = term->alt_wnext; + term->alt_wnext = t; + t = term->insert; + if (!reset) term->insert = term->alt_ins; + term->alt_ins = t; + t = term->cset; + if (!reset) term->cset = term->alt_cset; + term->alt_cset = t; + t = term->utf; + if (!reset) term->utf = term->alt_utf; + term->alt_utf = t; + t = term->sco_acs; + if (!reset) term->sco_acs = term->alt_sco_acs; + term->alt_sco_acs = t; + } - ttr = alt_screen; alt_screen = screen; screen = ttr; - t = curs.x; curs.x = alt_x; alt_x = t; - t = curs.y; curs.y = alt_y; alt_y = t; - t = marg_t; marg_t = alt_t; alt_t = t; - t = marg_b; marg_b = alt_b; alt_b = t; - t = dec_om; dec_om = alt_om; alt_om = t; - t = wrap; wrap = alt_wrap; alt_wrap = t; - t = wrapnext; wrapnext = alt_wnext; alt_wnext = t; - t = insert; insert = alt_ins; alt_ins = t; - t = cset; cset = alt_cset; alt_cset = t; + if (reset && term->screen) { + /* + * Yes, this _is_ supposed to honour background-colour-erase. + */ + erase_lots(term, FALSE, TRUE, TRUE); + } - fix_cpos; + /* + * This might not be possible if we're called during + * initialisation. + */ + if (term->screen) + fix_cpos; } /* * Update the scroll bar. */ -static void update_sbar(void) { +static void update_sbar(Terminal *term) +{ int nscroll; - nscroll = count234(scrollback); + nscroll = count234(term->scrollback); - set_sbar (nscroll + rows, nscroll + disptop, rows); + set_sbar(term->frontend, nscroll + term->rows, + nscroll + term->disptop, term->rows); } /* * Check whether the region bounded by the two pointers intersects * the scroll region, and de-select the on-screen selection if so. */ -static void check_selection (pos from, pos to) { - if (poslt(from, selend) && poslt(selstart, to)) - deselect(); +static void check_selection(Terminal *term, pos from, pos to) +{ + if (poslt(from, term->selend) && poslt(term->selstart, to)) + deselect(term); } /* @@ -526,33 +666,37 @@ static void check_selection (pos from, pos to) { * after calling scroll() and before doing anything else that * uses the cpos shortcut pointer. */ -static void scroll (int topline, int botline, int lines, int sb) { +static void scroll(Terminal *term, int topline, int botline, int lines, int sb) +{ unsigned long *line, *line2; - int i; + int i, seltop, olddisptop, shift; - if (topline != 0 || alt_which != 0) + if (topline != 0 || term->alt_which != 0) sb = FALSE; + olddisptop = term->disptop; + shift = lines; if (lines < 0) { while (lines < 0) { - line = delpos234(screen, botline); - for (i = 0; i < cols; i++) - line[i+1] = erase_char; - line[cols+1] = 0; - addpos234(screen, line, topline); - - if (selstart.y >= topline && selstart.y <= botline) { - selstart.y++; - if (selstart.y > botline) { - selstart.y = botline; - selstart.x = 0; + line = delpos234(term->screen, botline); + line = resizeline(line, term->cols); + for (i = 0; i < term->cols; i++) + line[i + 1] = term->erase_char; + line[term->cols + 1] = 0; + addpos234(term->screen, line, topline); + + if (term->selstart.y >= topline && term->selstart.y <= botline) { + term->selstart.y++; + if (term->selstart.y > botline) { + term->selstart.y = botline; + term->selstart.x = 0; } } - if (selend.y >= topline && selend.y <= botline) { - selend.y++; - if (selend.y > botline) { - selend.y = botline; - selend.x = 0; + if (term->selend.y >= topline && term->selend.y <= botline) { + term->selend.y++; + if (term->selend.y > botline) { + term->selend.y = botline; + term->selend.x = 0; } } @@ -560,48 +704,123 @@ static void scroll (int topline, int botline, int lines, int sb) { } } else { while (lines > 0) { - line = delpos234(screen, topline); - if (sb && savelines > 0) { - int sblen = count234(scrollback); + line = delpos234(term->screen, topline); + if (sb && term->savelines > 0) { + int sblen = count234(term->scrollback); /* * We must add this line to the scrollback. We'll * remove a line from the top of the scrollback to * replace it, or allocate a new one if the * scrollback isn't full. */ - if (sblen == savelines) { - sblen--, line2 = delpos234(scrollback, 0); + if (sblen == term->savelines) { + sblen--, line2 = delpos234(term->scrollback, 0); } else { - line2 = smalloc(TSIZE * (cols+2)); - line2[0] = cols; + line2 = smalloc(TSIZE * (term->cols + 2)); + line2[0] = term->cols; } - addpos234(scrollback, line, sblen); + addpos234(term->scrollback, line, sblen); line = line2; + + /* + * If the user is currently looking at part of the + * scrollback, and they haven't enabled any options + * that are going to reset the scrollback as a + * result of this movement, then the chances are + * they'd like to keep looking at the same line. So + * we move their viewpoint at the same rate as the + * scroll, at least until their viewpoint hits the + * top end of the scrollback buffer, at which point + * we don't have the choice any more. + * + * Thanks to Jan Holmen Holsten for the idea and + * initial implementation. + */ + if (term->disptop > -term->savelines && term->disptop < 0) + term->disptop--; + } + line = resizeline(line, term->cols); + for (i = 0; i < term->cols; i++) + line[i + 1] = term->erase_char; + line[term->cols + 1] = 0; + addpos234(term->screen, line, botline); + + /* + * If the selection endpoints move into the scrollback, + * we keep them moving until they hit the top. However, + * of course, if the line _hasn't_ moved into the + * scrollback then we don't do this, and cut them off + * at the top of the scroll region. + * + * This applies to selstart and selend (for an existing + * selection), and also selanchor (for one being + * selected as we speak). + */ + seltop = sb ? -term->savelines : topline; + + if (term->selstart.y >= seltop && + term->selstart.y <= botline) { + term->selstart.y--; + if (term->selstart.y < seltop) { + term->selstart.y = seltop; + term->selstart.x = 0; + } } - for (i = 0; i < cols; i++) - line[i+1] = erase_char; - line[cols+1] = 0; - addpos234(screen, line, botline); - - if (selstart.y >= topline && selstart.y <= botline) { - selstart.y--; - if (selstart.y < topline) { - selstart.y = topline; - selstart.x = 0; + if (term->selend.y >= seltop && term->selend.y <= botline) { + term->selend.y--; + if (term->selend.y < seltop) { + term->selend.y = seltop; + term->selend.x = 0; } } - if (selend.y >= topline && selend.y <= botline) { - selend.y--; - if (selend.y < topline) { - selend.y = topline; - selend.x = 0; + if (term->selanchor.y >= seltop && term->selanchor.y <= botline) { + term->selanchor.y--; + if (term->selanchor.y < seltop) { + term->selanchor.y = seltop; + term->selanchor.x = 0; } } lines--; } } +#ifdef OPTIMISE_SCROLL + shift += term->disptop - olddisptop; + if (shift < term->rows && shift > -term->rows && shift != 0) + scroll_display(term, topline, botline, shift); +#endif /* OPTIMISE_SCROLL */ +} + +#ifdef OPTIMISE_SCROLL +/* + * Scroll the physical display, and our conception of it in disptext. + */ +static void scroll_display(Terminal *term, int topline, int botline, int lines) +{ + unsigned long *start, *end; + int distance, size, i; + + start = term->disptext + topline * (term->cols + 1); + end = term->disptext + (botline + 1) * (term->cols + 1); + distance = (lines > 0 ? lines : -lines) * (term->cols + 1); + size = end - start - distance; + if (lines > 0) { + memmove(start, start + distance, size * TSIZE); + if (term->dispcurs >= start + distance && + term->dispcurs <= start + distance + size) + term->dispcurs -= distance; + for (i = 0; i < distance; i++) + (start + size)[i] |= ATTR_INVALID; + } else { + memmove(start + distance, start, size * TSIZE); + if (term->dispcurs >= start && term->dispcurs <= start + size) + term->dispcurs += distance; + for (i = 0; i < distance; i++) + start[i] |= ATTR_INVALID; + } + do_scroll(term->frontend, topline, botline, lines); } +#endif /* OPTIMISE_SCROLL */ /* * Move the cursor to a given position, clipping at boundaries. We @@ -609,47 +828,106 @@ static void scroll (int topline, int botline, int lines, int sb) { * not to, 1 to disallow _passing_ the margins, and 2 to disallow * even _being_ outside the margins. */ -static void move (int x, int y, int marg_clip) { +static void move(Terminal *term, int x, int y, int marg_clip) +{ if (x < 0) x = 0; - if (x >= cols) - x = cols-1; + if (x >= term->cols) + x = term->cols - 1; if (marg_clip) { - if ((curs.y >= marg_t || marg_clip == 2) && y < marg_t) - y = marg_t; - if ((curs.y <= marg_b || marg_clip == 2) && y > marg_b) - y = marg_b; + if ((term->curs.y >= term->marg_t || marg_clip == 2) && + y < term->marg_t) + y = term->marg_t; + if ((term->curs.y <= term->marg_b || marg_clip == 2) && + y > term->marg_b) + y = term->marg_b; } if (y < 0) y = 0; - if (y >= rows) - y = rows-1; - curs.x = x; - curs.y = y; + if (y >= term->rows) + y = term->rows - 1; + term->curs.x = x; + term->curs.y = y; fix_cpos; - wrapnext = FALSE; + term->wrapnext = FALSE; } /* * Save or restore the cursor and SGR mode. */ -static void save_cursor(int save) { +static void save_cursor(Terminal *term, int save) +{ if (save) { - savecurs = curs; - save_attr = curr_attr; - save_cset = cset; - save_csattr = cset_attr[cset]; + term->savecurs = term->curs; + term->save_attr = term->curr_attr; + term->save_cset = term->cset; + term->save_utf = term->utf; + term->save_wnext = term->wrapnext; + term->save_csattr = term->cset_attr[term->cset]; + term->save_sco_acs = term->sco_acs; } else { - curs = savecurs; + term->curs = term->savecurs; /* Make sure the window hasn't shrunk since the save */ - if (curs.x >= cols) curs.x = cols-1; - if (curs.y >= rows) curs.y = rows-1; - - curr_attr = save_attr; - cset = save_cset; - cset_attr[cset] = save_csattr; + if (term->curs.x >= term->cols) + term->curs.x = term->cols - 1; + if (term->curs.y >= term->rows) + term->curs.y = term->rows - 1; + + term->curr_attr = term->save_attr; + term->cset = term->save_cset; + term->utf = term->save_utf; + term->wrapnext = term->save_wnext; + /* + * wrapnext might reset to False if the x position is no + * longer at the rightmost edge. + */ + if (term->wrapnext && term->curs.x < term->cols-1) + term->wrapnext = FALSE; + term->cset_attr[term->cset] = term->save_csattr; + term->sco_acs = term->save_sco_acs; fix_cpos; - if (use_bce) erase_char = (' ' |(curr_attr&(ATTR_FGMASK|ATTR_BGMASK))); + if (term->use_bce) + term->erase_char = (' ' | ATTR_ASCII | + (term->curr_attr & + (ATTR_FGMASK | ATTR_BGMASK))); + } +} + +/* + * This function is called before doing _anything_ which affects + * only part of a line of text. It is used to mark the boundary + * between two character positions, and it indicates that some sort + * of effect is going to happen on only one side of that boundary. + * + * The effect of this function is to check whether a CJK + * double-width character is straddling the boundary, and to remove + * it and replace it with two spaces if so. (Of course, one or + * other of those spaces is then likely to be replaced with + * something else again, as a result of whatever happens next.) + * + * Also, if the boundary is at the right-hand _edge_ of the screen, + * it implies something deliberate is being done to the rightmost + * column position; hence we must clear LATTR_WRAPPED2. + * + * The input to the function is the coordinates of the _second_ + * character of the pair. + */ +static void check_boundary(Terminal *term, int x, int y) +{ + unsigned long *ldata; + + /* Validate input coordinates, just in case. */ + if (x == 0 || x > term->cols) + return; + + ldata = lineptr(y); + if (x == term->cols) { + ldata[x] &= ~LATTR_WRAPPED2; + } else { + if ((ldata[x] & (CHAR_MASK | CSET_MASK)) == UCSWIDE) { + ldata[x-1] = ldata[x] = + (ldata[x-1] &~ (CHAR_MASK | CSET_MASK)) | ATTR_ASCII | ' '; + } } } @@ -657,43 +935,48 @@ static void save_cursor(int save) { * Erase a large portion of the screen: the whole screen, or the * whole line, or parts thereof. */ -static void erase_lots (int line_only, int from_begin, int to_end) { +static void erase_lots(Terminal *term, + int line_only, int from_begin, int to_end) +{ pos start, end; int erase_lattr; unsigned long *ldata; if (line_only) { - start.y = curs.y; + start.y = term->curs.y; start.x = 0; - end.y = curs.y + 1; + end.y = term->curs.y + 1; end.x = 0; erase_lattr = FALSE; } else { start.y = 0; start.x = 0; - end.y = rows; + end.y = term->rows; end.x = 0; erase_lattr = TRUE; } if (!from_begin) { - start = curs; + start = term->curs; } if (!to_end) { - end = curs; + end = term->curs; + incpos(end); } - check_selection (start, end); + if (!from_begin || !to_end) + check_boundary(term, term->curs.x, term->curs.y); + check_selection(term, start, end); /* Clear screen also forces a full window redraw, just in case. */ - if (start.y == 0 && start.x == 0 && end.y == rows) - term_invalidate(); + if (start.y == 0 && start.x == 0 && end.y == term->rows) + term_invalidate(term); ldata = lineptr(start.y); while (poslt(start, end)) { - if (start.y == cols && !erase_lattr) - ldata[start.x] &= ~ATTR_WRAPPED; + if (start.x == term->cols && !erase_lattr) + ldata[start.x] &= ~(LATTR_WRAPPED | LATTR_WRAPPED2); else - ldata[start.x] = erase_char; - if (incpos(start) && start.y < rows) + ldata[start.x] = term->erase_char; + if (incpos(start) && start.y < term->rows) ldata = lineptr(start.y); } } @@ -702,28 +985,32 @@ static void erase_lots (int line_only, int from_begin, int to_end) { * Insert or delete characters within the current line. n is +ve if * insertion is desired, and -ve for deletion. */ -static void insch (int n) { +static void insch(Terminal *term, int n) +{ int dir = (n < 0 ? -1 : +1); int m; pos cursplus; unsigned long *ldata; n = (n < 0 ? -n : n); - if (n > cols - curs.x) - n = cols - curs.x; - m = cols - curs.x - n; - cursplus.y = curs.y; - cursplus.x = curs.x + n; - check_selection (curs, cursplus); - ldata = lineptr(curs.y); + if (n > term->cols - term->curs.x) + n = term->cols - term->curs.x; + m = term->cols - term->curs.x - n; + cursplus.y = term->curs.y; + cursplus.x = term->curs.x + n; + check_selection(term, term->curs, cursplus); + check_boundary(term, term->curs.x, term->curs.y); + if (dir < 0) + check_boundary(term, term->curs.x + n, term->curs.y); + ldata = lineptr(term->curs.y); if (dir < 0) { - memmove (ldata + curs.x, ldata + curs.x + n, m*TSIZE); + memmove(ldata + term->curs.x, ldata + term->curs.x + n, m * TSIZE); while (n--) - ldata[curs.x + m++] = erase_char; + ldata[term->curs.x + m++] = term->erase_char; } else { - memmove (ldata + curs.x + n, ldata + curs.x, m*TSIZE); + memmove(ldata + term->curs.x + n, ldata + term->curs.x, m * TSIZE); while (n--) - ldata[curs.x + n] = erase_char; + ldata[term->curs.x + n] = term->erase_char; } } @@ -731,102 +1018,206 @@ static void insch (int n) { * Toggle terminal mode `mode' to state `state'. (`query' indicates * whether the mode is a DEC private one or a normal one.) */ -static void toggle_mode (int mode, int query, int state) { - long ticks; - if (query) switch (mode) { - case 1: /* application cursor keys */ - app_cursor_keys = state; - break; - case 2: /* VT52 mode */ - vt52_mode = !state; - break; - case 3: /* 80/132 columns */ - deselect(); - request_resize (state ? 132 : 80, rows, 1); - reset_132 = state; - break; - case 5: /* reverse video */ - /* - * Toggle reverse video. If we receive an OFF within the - * visual bell timeout period after an ON, we trigger an - * effective visual bell, so that ESC[?5hESC[?5l will - * always be an actually _visible_ visual bell. - */ - ticks = GetTickCount(); - if (rvideo && !state && /* we're turning it off */ - ticks < rvbell_timeout) { /* and it's not long since it was turned on */ - in_vbell = TRUE; /* we may clear rvideo but we set in_vbell */ - if (vbell_timeout < rvbell_timeout) /* don't move vbell end forward */ - vbell_timeout = rvbell_timeout; /* vbell end is at least then */ - } else if (!rvideo && state) { - /* This is an ON, so we notice the time and save it. */ - rvbell_timeout = ticks + VBELL_TIMEOUT; +static void toggle_mode(Terminal *term, int mode, int query, int state) +{ + unsigned long ticks; + + if (query) + switch (mode) { + case 1: /* application cursor keys */ + term->app_cursor_keys = state; + break; + case 2: /* VT52 mode */ + term->vt52_mode = !state; + if (term->vt52_mode) { + term->blink_is_real = FALSE; + term->vt52_bold = FALSE; + } else { + term->blink_is_real = term->cfg.blinktext; + } + break; + case 3: /* 80/132 columns */ + deselect(term); + if (!term->cfg.no_remote_resize) + request_resize(term->frontend, state ? 132 : 80, term->rows); + term->reset_132 = state; + break; + case 5: /* reverse video */ + /* + * Toggle reverse video. If we receive an OFF within the + * visual bell timeout period after an ON, we trigger an + * effective visual bell, so that ESC[?5hESC[?5l will + * always be an actually _visible_ visual bell. + */ + ticks = GETTICKCOUNT(); + /* turn off a previous vbell to avoid inconsistencies */ + if (ticks - term->vbell_startpoint >= VBELL_TIMEOUT) + term->in_vbell = FALSE; + if (term->rvideo && !state && /* we're turning it off... */ + (ticks - term->rvbell_startpoint) < VBELL_TIMEOUT) {/*...soon*/ + /* If there's no vbell timeout already, or this one lasts + * longer, replace vbell_timeout with ours. */ + if (!term->in_vbell || + (term->rvbell_startpoint - term->vbell_startpoint < + VBELL_TIMEOUT)) + term->vbell_startpoint = term->rvbell_startpoint; + term->in_vbell = TRUE; /* may clear rvideo but set in_vbell */ + } else if (!term->rvideo && state) { + /* This is an ON, so we notice the time and save it. */ + term->rvbell_startpoint = ticks; + } + term->rvideo = state; + term->seen_disp_event = TRUE; + if (state) + term_update(term); + break; + case 6: /* DEC origin mode */ + term->dec_om = state; + break; + case 7: /* auto wrap */ + term->wrap = state; + break; + case 8: /* auto key repeat */ + term->repeat_off = !state; + break; + case 10: /* set local edit mode */ + term->term_editing = state; + if (term->ldisc) /* cause ldisc to notice changes */ + ldisc_send(term->ldisc, NULL, 0, 0); + break; + case 25: /* enable/disable cursor */ + compatibility2(OTHER, VT220); + term->cursor_on = state; + term->seen_disp_event = TRUE; + break; + case 47: /* alternate screen */ + compatibility(OTHER); + deselect(term); + swap_screen(term, term->cfg.no_alt_screen ? 0 : state, FALSE, FALSE); + term->disptop = 0; + break; + case 1000: /* xterm mouse 1 */ + term->xterm_mouse = state ? 1 : 0; + set_raw_mouse_mode(term->frontend, state); + break; + case 1002: /* xterm mouse 2 */ + term->xterm_mouse = state ? 2 : 0; + set_raw_mouse_mode(term->frontend, state); + break; + case 1047: /* alternate screen */ + compatibility(OTHER); + deselect(term); + swap_screen(term, term->cfg.no_alt_screen ? 0 : state, TRUE, TRUE); + term->disptop = 0; + break; + case 1048: /* save/restore cursor */ + save_cursor(term, state); + if (!state) term->seen_disp_event = TRUE; + break; + case 1049: /* cursor & alternate screen */ + if (state) + save_cursor(term, state); + if (!state) term->seen_disp_event = TRUE; + compatibility(OTHER); + deselect(term); + swap_screen(term, term->cfg.no_alt_screen ? 0 : state, TRUE, FALSE); + if (!state) + save_cursor(term, state); + term->disptop = 0; + break; + } else + switch (mode) { + case 4: /* set insert mode */ + compatibility(VT102); + term->insert = state; + break; + case 12: /* set echo mode */ + term->term_echoing = !state; + if (term->ldisc) /* cause ldisc to notice changes */ + ldisc_send(term->ldisc, NULL, 0, 0); + break; + case 20: /* Return sends ... */ + term->cr_lf_return = state; + break; + case 34: /* Make cursor BIG */ + compatibility2(OTHER, VT220); + term->big_cursor = !state; } - rvideo = state; - seen_disp_event = TRUE; - if (state) term_update(); - break; - case 6: /* DEC origin mode */ - dec_om = state; - break; - case 7: /* auto wrap */ - wrap = state; - break; - case 8: /* auto key repeat */ - repeat_off = !state; - break; - case 10: /* set local edit mode */ - term_editing = state; - ldisc_send(NULL, 0); /* cause ldisc to notice changes */ - break; - case 25: /* enable/disable cursor */ - compatibility2(OTHER,VT220); - cursor_on = state; - seen_disp_event = TRUE; - break; - case 47: /* alternate screen */ - compatibility(OTHER); - deselect(); - swap_screen (state); - disptop = 0; - break; - } else switch (mode) { - case 4: /* set insert mode */ - compatibility(VT102); - insert = state; - break; - case 12: /* set echo mode */ - term_echoing = !state; - ldisc_send(NULL, 0); /* cause ldisc to notice changes */ - break; - case 20: /* Return sends ... */ - cr_lf_return = state; - break; - } } /* * Process an OSC sequence: set window title or icon name. */ -static void do_osc(void) { - if (osc_w) { - while (osc_strlen--) - wordness[(unsigned char)osc_string[osc_strlen]] = esc_args[0]; +static void do_osc(Terminal *term) +{ + if (term->osc_w) { + while (term->osc_strlen--) + term->wordness[(unsigned char) + term->osc_string[term->osc_strlen]] = term->esc_args[0]; } else { - osc_string[osc_strlen] = '\0'; - switch (esc_args[0]) { + term->osc_string[term->osc_strlen] = '\0'; + switch (term->esc_args[0]) { case 0: case 1: - set_icon (osc_string); - if (esc_args[0] == 1) + if (!term->cfg.no_remote_wintitle) + set_icon(term->frontend, term->osc_string); + if (term->esc_args[0] == 1) break; /* fall through: parameter 0 means set both */ case 2: case 21: - set_title (osc_string); + if (!term->cfg.no_remote_wintitle) + set_title(term->frontend, term->osc_string); + break; + } + } +} + +/* + * ANSI printing routines. + */ +static void term_print_setup(Terminal *term) +{ + bufchain_clear(&term->printer_buf); + term->print_job = printer_start_job(term->cfg.printer); +} +static void term_print_flush(Terminal *term) +{ + void *data; + int len; + int size; + while ((size = bufchain_size(&term->printer_buf)) > 5) { + bufchain_prefix(&term->printer_buf, &data, &len); + if (len > size-5) + len = size-5; + printer_job_data(term->print_job, data, len); + bufchain_consume(&term->printer_buf, len); + } +} +static void term_print_finish(Terminal *term) +{ + void *data; + int len, size; + char c; + + if (!term->printing && !term->only_printing) + return; /* we need do nothing */ + + term_print_flush(term); + while ((size = bufchain_size(&term->printer_buf)) > 0) { + bufchain_prefix(&term->printer_buf, &data, &len); + c = *(char *)data; + if (c == '\033' || c == '\233') { + bufchain_consume(&term->printer_buf, size); break; + } else { + printer_job_data(term->print_job, &c, 1); + bufchain_consume(&term->printer_buf, 1); } } + printer_finish_job(term->print_job); + term->print_job = NULL; + term->printing = term->only_printing = FALSE; } /* @@ -834,26 +1225,227 @@ static void do_osc(void) { * in-memory display. There's a big state machine in here to * process escape sequences... */ -void term_out(void) { - int c, inbuf_reap; - - for(inbuf_reap = 0; inbuf_reap < inbuf_head; inbuf_reap++) - { - c = inbuf[inbuf_reap]; +void term_out(Terminal *term) +{ + int c, unget; + unsigned char localbuf[256], *chars; + int nchars = 0; + + unget = -1; + + chars = NULL; /* placate compiler warnings */ + while (nchars > 0 || bufchain_size(&term->inbuf) > 0) { + if (unget == -1) { + if (nchars == 0) { + void *ret; + bufchain_prefix(&term->inbuf, &ret, &nchars); + if (nchars > sizeof(localbuf)) + nchars = sizeof(localbuf); + memcpy(localbuf, ret, nchars); + bufchain_consume(&term->inbuf, nchars); + chars = localbuf; + assert(chars != NULL); + } + c = *chars++; + nchars--; - /* - * Optionally log the session traffic to a file. Useful for - * debugging and possibly also useful for actual logging. - */ - logtraffic((unsigned char)c, LGTYP_DEBUG); + /* + * Optionally log the session traffic to a file. Useful for + * debugging and possibly also useful for actual logging. + */ + if (term->cfg.logtype == LGTYP_DEBUG && term->logctx) + logtraffic(term->logctx, (unsigned char) c, LGTYP_DEBUG); + } else { + c = unget; + unget = -1; + } /* Note only VT220+ are 8-bit VT102 is seven bit, it shouldn't even * be able to display 8-bit characters, but I'll let that go 'cause * of i18n. */ - if( ( (c&0x60) == 0 || c == '\177') && - termstate < DO_CTRLS && - ( (c&0x80) == 0 || has_compat(VT220))) { + + /* + * If we're printing, add the character to the printer + * buffer. + */ + if (term->printing) { + bufchain_add(&term->printer_buf, &c, 1); + + /* + * If we're in print-only mode, we use a much simpler + * state machine designed only to recognise the ESC[4i + * termination sequence. + */ + if (term->only_printing) { + if (c == '\033') + term->print_state = 1; + else if (c == (unsigned char)'\233') + term->print_state = 2; + else if (c == '[' && term->print_state == 1) + term->print_state = 2; + else if (c == '4' && term->print_state == 2) + term->print_state = 3; + else if (c == 'i' && term->print_state == 3) + term->print_state = 4; + else + term->print_state = 0; + if (term->print_state == 4) { + term_print_finish(term); + } + continue; + } + } + + /* First see about all those translations. */ + if (term->termstate == TOPLEVEL) { + if (in_utf(term)) + switch (term->utf_state) { + case 0: + if (c < 0x80) { + /* UTF-8 must be stateless so we ignore iso2022. */ + if (term->ucsdata->unitab_ctrl[c] != 0xFF) + c = term->ucsdata->unitab_ctrl[c]; + else c = ((unsigned char)c) | ATTR_ASCII; + break; + } else if ((c & 0xe0) == 0xc0) { + term->utf_size = term->utf_state = 1; + term->utf_char = (c & 0x1f); + } else if ((c & 0xf0) == 0xe0) { + term->utf_size = term->utf_state = 2; + term->utf_char = (c & 0x0f); + } else if ((c & 0xf8) == 0xf0) { + term->utf_size = term->utf_state = 3; + term->utf_char = (c & 0x07); + } else if ((c & 0xfc) == 0xf8) { + term->utf_size = term->utf_state = 4; + term->utf_char = (c & 0x03); + } else if ((c & 0xfe) == 0xfc) { + term->utf_size = term->utf_state = 5; + term->utf_char = (c & 0x01); + } else { + c = UCSERR; + break; + } + continue; + case 1: + case 2: + case 3: + case 4: + case 5: + if ((c & 0xC0) != 0x80) { + unget = c; + c = UCSERR; + term->utf_state = 0; + break; + } + term->utf_char = (term->utf_char << 6) | (c & 0x3f); + if (--term->utf_state) + continue; + + c = term->utf_char; + + /* Is somebody trying to be evil! */ + if (c < 0x80 || + (c < 0x800 && term->utf_size >= 2) || + (c < 0x10000 && term->utf_size >= 3) || + (c < 0x200000 && term->utf_size >= 4) || + (c < 0x4000000 && term->utf_size >= 5)) + c = UCSERR; + + /* Unicode line separator and paragraph separator are CR-LF */ + if (c == 0x2028 || c == 0x2029) + c = 0x85; + + /* High controls are probably a Baaad idea too. */ + if (c < 0xA0) + c = 0xFFFD; + + /* The UTF-16 surrogates are not nice either. */ + /* The standard give the option of decoding these: + * I don't want to! */ + if (c >= 0xD800 && c < 0xE000) + c = UCSERR; + + /* ISO 10646 characters now limited to UTF-16 range. */ + if (c > 0x10FFFF) + c = UCSERR; + + /* This is currently a TagPhobic application.. */ + if (c >= 0xE0000 && c <= 0xE007F) + continue; + + /* U+FEFF is best seen as a null. */ + if (c == 0xFEFF) + continue; + /* But U+FFFE is an error. */ + if (c == 0xFFFE || c == 0xFFFF) + c = UCSERR; + + /* Oops this is a 16bit implementation */ + if (c >= 0x10000) + c = 0xFFFD; + break; + } + /* Are we in the nasty ACS mode? Note: no sco in utf mode. */ + else if(term->sco_acs && + (c!='\033' && c!='\012' && c!='\015' && c!='\b')) + { + if (term->sco_acs == 2) c |= 0x80; + c |= ATTR_SCOACS; + } else { + switch (term->cset_attr[term->cset]) { + /* + * Linedraw characters are different from 'ESC ( B' + * only for a small range. For ones outside that + * range, make sure we use the same font as well as + * the same encoding. + */ + case ATTR_LINEDRW: + if (term->ucsdata->unitab_ctrl[c] != 0xFF) + c = term->ucsdata->unitab_ctrl[c]; + else + c = ((unsigned char) c) | ATTR_LINEDRW; + break; + + case ATTR_GBCHR: + /* If UK-ASCII, make the '#' a LineDraw Pound */ + if (c == '#') { + c = '}' | ATTR_LINEDRW; + break; + } + /*FALLTHROUGH*/ case ATTR_ASCII: + if (term->ucsdata->unitab_ctrl[c] != 0xFF) + c = term->ucsdata->unitab_ctrl[c]; + else + c = ((unsigned char) c) | ATTR_ASCII; + break; + case ATTR_SCOACS: + if (c>=' ') c = ((unsigned char)c) | ATTR_SCOACS; + break; + } + } + } + + /* How about C1 controls ? */ + if ((c & -32) == 0x80 && term->termstate < DO_CTRLS && + !term->vt52_mode && has_compat(VT220)) { + term->termstate = SEEN_ESC; + term->esc_query = FALSE; + c = '@' + (c & 0x1F); + } + + /* Or the GL control. */ + if (c == '\177' && term->termstate < DO_CTRLS && has_compat(OTHER)) { + if (term->curs.x && !term->wrapnext) + term->curs.x--; + term->wrapnext = FALSE; + fix_cpos; + if (!term->cfg.no_dbackspace) /* destructive bksp might be disabled */ + *term->cpos = (' ' | term->curr_attr | ATTR_ASCII); + } else + /* Or normal C0 controls. */ + if ((c & -32) == 0 && term->termstate < DO_CTRLS) { switch (c) { case '\005': /* terminal type query */ /* Strictly speaking this is VT100 but a VT100 defaults to @@ -864,1151 +1456,1812 @@ void term_out(void) { * * An xterm returns "xterm" (5 characters) */ - compatibility(ANSIMIN); - { + compatibility(ANSIMIN); + if (term->ldisc) { char abuf[256], *s, *d; - int state=0; - for(s=cfg.answerback, d=abuf; *s; s++) { - if (state) - { - if (*s >= 'a' && *s <= 'z') - *d++ = (*s - ('a'-1)); - else if ((*s >='@' && *s<='_') || - *s == '?' || (*s&0x80)) - *d++ = ('@'^*s); - else if (*s == '~') - *d++ = '^'; - state = 0; - } - else if (*s == '^') { - state = 1; - } - else - *d++ = xlat_kbd2tty((unsigned char)*s); + int state = 0; + for (s = term->cfg.answerback, d = abuf; *s; s++) { + if (state) { + if (*s >= 'a' && *s <= 'z') + *d++ = (*s - ('a' - 1)); + else if ((*s >= '@' && *s <= '_') || + *s == '?' || (*s & 0x80)) + *d++ = ('@' ^ *s); + else if (*s == '~') + *d++ = '^'; + state = 0; + } else if (*s == '^') { + state = 1; + } else + *d++ = *s; } - ldisc_send (abuf, d-abuf); + lpage_send(term->ldisc, DEFAULT_CODEPAGE, + abuf, d - abuf, 0); } break; case '\007': { struct beeptime *newbeep; - long ticks; + unsigned long ticks; - ticks = GetTickCount(); + ticks = GETTICKCOUNT(); - if (!beep_overloaded) { + if (!term->beep_overloaded) { newbeep = smalloc(sizeof(struct beeptime)); newbeep->ticks = ticks; newbeep->next = NULL; - if (!beephead) - beephead = newbeep; + if (!term->beephead) + term->beephead = newbeep; else - beeptail->next = newbeep; - beeptail = newbeep; - nbeeps++; + term->beeptail->next = newbeep; + term->beeptail = newbeep; + term->nbeeps++; } /* * Throw out any beeps that happened more than * t seconds ago. */ - while (beephead && - beephead->ticks < ticks - cfg.bellovl_t*1000) { - struct beeptime *tmp = beephead; - beephead = tmp->next; + while (term->beephead && + term->beephead->ticks < ticks - term->cfg.bellovl_t) { + struct beeptime *tmp = term->beephead; + term->beephead = tmp->next; sfree(tmp); - if (!beephead) - beeptail = NULL; - nbeeps--; + if (!term->beephead) + term->beeptail = NULL; + term->nbeeps--; } - if (cfg.bellovl && beep_overloaded && - ticks-lastbeep >= cfg.bellovl_s * 1000) { + if (term->cfg.bellovl && term->beep_overloaded && + ticks - term->lastbeep >= (unsigned)term->cfg.bellovl_s) { /* * If we're currently overloaded and the * last beep was more than s seconds ago, * leave overload mode. */ - beep_overloaded = FALSE; - } else if (cfg.bellovl && !beep_overloaded && - nbeeps >= cfg.bellovl_n) { + term->beep_overloaded = FALSE; + } else if (term->cfg.bellovl && !term->beep_overloaded && + term->nbeeps >= term->cfg.bellovl_n) { /* * Now, if we have n or more beeps * remaining in the queue, go into overload * mode. */ - beep_overloaded = TRUE; + term->beep_overloaded = TRUE; } - lastbeep = ticks; + term->lastbeep = ticks; /* * Perform an actual beep if we're not overloaded. */ - if ((!cfg.bellovl || !beep_overloaded) && cfg.beep != 0) { - if (cfg.beep != 2) - beep(cfg.beep); - else if(cfg.beep == 2) { - in_vbell = TRUE; - vbell_timeout = ticks + VBELL_TIMEOUT; - term_update(); + if (!term->cfg.bellovl || !term->beep_overloaded) { + beep(term->frontend, term->cfg.beep); + if (term->cfg.beep == BELL_VISUAL) { + term->in_vbell = TRUE; + term->vbell_startpoint = ticks; + term_update(term); } } - disptop = 0; + term->disptop = 0; } break; case '\b': - if (curs.x == 0 && curs.y == 0) - ; - else if (curs.x == 0 && curs.y > 0) - curs.x = cols-1, curs.y--; - else if (wrapnext) - wrapnext = FALSE; + if (term->curs.x == 0 && + (term->curs.y == 0 || term->wrap == 0)) + /* do nothing */ ; + else if (term->curs.x == 0 && term->curs.y > 0) + term->curs.x = term->cols - 1, term->curs.y--; + else if (term->wrapnext) + term->wrapnext = FALSE; else - curs.x--; + term->curs.x--; fix_cpos; - seen_disp_event = TRUE; + term->seen_disp_event = TRUE; break; case '\016': - compatibility(VT100); - cset = 1; + compatibility(VT100); + term->cset = 1; break; case '\017': - compatibility(VT100); - cset = 0; + compatibility(VT100); + term->cset = 0; break; case '\033': - if (vt52_mode) - termstate = VT52_ESC; + if (term->vt52_mode) + term->termstate = VT52_ESC; else { compatibility(ANSIMIN); - termstate = SEEN_ESC; + term->termstate = SEEN_ESC; + term->esc_query = FALSE; } break; - case 0233: - compatibility(VT220); - termstate = SEEN_CSI; - esc_nargs = 1; - esc_args[0] = ARG_DEFAULT; - esc_query = FALSE; - break; - case 0235: - compatibility(VT220); - termstate = SEEN_OSC; - esc_args[0] = 0; - break; - case '\r': - curs.x = 0; - wrapnext = FALSE; + case '\015': + term->curs.x = 0; + term->wrapnext = FALSE; fix_cpos; - seen_disp_event = TRUE; - paste_hold = 0; - logtraffic((unsigned char)c,LGTYP_ASCII); + term->seen_disp_event = TRUE; + term->paste_hold = 0; + if (term->logctx) + logtraffic(term->logctx, (unsigned char) c, LGTYP_ASCII); break; - case '\013': case '\014': - compatibility(VT100); - case '\n': - if (curs.y == marg_b) - scroll (marg_t, marg_b, 1, TRUE); - else if (curs.y < rows-1) - curs.y++; - if (cfg.lfhascr) - curs.x = 0; + if (has_compat(SCOANSI)) { + move(term, 0, 0, 0); + erase_lots(term, FALSE, FALSE, TRUE); + term->disptop = 0; + term->wrapnext = FALSE; + term->seen_disp_event = 1; + break; + } + case '\013': + compatibility(VT100); + case '\012': + if (term->curs.y == term->marg_b) + scroll(term, term->marg_t, term->marg_b, 1, TRUE); + else if (term->curs.y < term->rows - 1) + term->curs.y++; + if (term->cfg.lfhascr) + term->curs.x = 0; fix_cpos; - wrapnext = FALSE; - seen_disp_event = 1; - paste_hold = 0; - logtraffic((unsigned char)c,LGTYP_ASCII); + term->wrapnext = FALSE; + term->seen_disp_event = 1; + term->paste_hold = 0; + if (term->logctx) + logtraffic(term->logctx, (unsigned char) c, LGTYP_ASCII); break; case '\t': { - pos old_curs = curs; - unsigned long *ldata = lineptr(curs.y); + pos old_curs = term->curs; + unsigned long *ldata = lineptr(term->curs.y); do { - curs.x++; - } while (curs.x < cols-1 && !tabs[curs.x]); - - if ((ldata[cols] & LATTR_MODE) != LATTR_NORM) - { - if (curs.x >= cols/2) - curs.x = cols/2-1; - } - else - { - if (curs.x >= cols) - curs.x = cols-1; + term->curs.x++; + } while (term->curs.x < term->cols - 1 && + !term->tabs[term->curs.x]); + + if ((ldata[term->cols] & LATTR_MODE) != LATTR_NORM) { + if (term->curs.x >= term->cols / 2) + term->curs.x = term->cols / 2 - 1; + } else { + if (term->curs.x >= term->cols) + term->curs.x = term->cols - 1; } fix_cpos; - check_selection (old_curs, curs); + check_selection(term, old_curs, term->curs); } - seen_disp_event = TRUE; + term->seen_disp_event = TRUE; break; - case '\177': /* Destructive backspace - This does nothing on a real VT100 */ - compatibility(OTHER); - if (curs.x && !wrapnext) curs.x--; - wrapnext = FALSE; - fix_cpos; - *cpos = (' ' | curr_attr | ATTR_ASCII); - break; - } - } - else switch (termstate) { - case TOPLEVEL: - /* Only graphic characters get this far, ctrls are stripped above */ - if (wrapnext && wrap) { - cpos[1] |= ATTR_WRAPPED; - if (curs.y == marg_b) - scroll (marg_t, marg_b, 1, TRUE); - else if (curs.y < rows-1) - curs.y++; - curs.x = 0; - fix_cpos; - wrapnext = FALSE; - } - if (insert) - insch (1); - if (selstate != NO_SELECTION) { - pos cursplus = curs; - incpos(cursplus); - check_selection (curs, cursplus); } - switch (cset_attr[cset]) { - /* - * Linedraw characters are different from 'ESC ( B' - * only for a small range. For ones outside that - * range, make sure we use the same font as well as - * the same encoding. - */ - case ATTR_LINEDRW: - if (c<0x5f || c>0x7F) - *cpos++ = xlat_tty2scr((unsigned char)c) | curr_attr | - ATTR_ASCII; - else if (c==0x5F) - *cpos++ = ' ' | curr_attr | ATTR_ASCII; - else - *cpos++ = ((unsigned char)c) | curr_attr | ATTR_LINEDRW; - break; - case ATTR_GBCHR: - /* If UK-ASCII, make the '#' a LineDraw Pound */ - if (c == '#') { - *cpos++ = '}' | curr_attr | ATTR_LINEDRW; - break; + } else + switch (term->termstate) { + case TOPLEVEL: + /* Only graphic characters get this far; + * ctrls are stripped above */ + if (term->wrapnext && term->wrap) { + term->cpos[1] |= LATTR_WRAPPED; + if (term->curs.y == term->marg_b) + scroll(term, term->marg_t, term->marg_b, 1, TRUE); + else if (term->curs.y < term->rows - 1) + term->curs.y++; + term->curs.x = 0; + fix_cpos; + term->wrapnext = FALSE; } - /*FALLTHROUGH*/ - default: - *cpos = xlat_tty2scr((unsigned char)c) | curr_attr | - (c <= 0x7F ? cset_attr[cset] : ATTR_ASCII); - logtraffic((unsigned char)c, LGTYP_ASCII); - cpos++; - break; - } - curs.x++; - if (curs.x == cols) { - cpos--; - curs.x--; - wrapnext = TRUE; - } - seen_disp_event = 1; - break; - - case IGNORE_NEXT: - termstate = TOPLEVEL; - break; - case OSC_MAYBE_ST: - /* - * This state is virtually identical to SEEN_ESC, with the - * exception that we have an OSC sequence in the pipeline, - * and _if_ we see a backslash, we process it. - */ - if (c == '\\') { - do_osc(); - termstate = TOPLEVEL; - break; - } - /* else fall through */ - case SEEN_ESC: - termstate = TOPLEVEL; - switch (c) { - case ' ': /* some weird sequence? */ - compatibility(VT220); - termstate = IGNORE_NEXT; - break; - case '[': /* enter CSI mode */ - termstate = SEEN_CSI; - esc_nargs = 1; - esc_args[0] = ARG_DEFAULT; - esc_query = FALSE; - break; - case ']': /* xterm escape sequences */ - /* Compatibility is nasty here, xterm, linux, decterm yuk! */ - compatibility(OTHER); - termstate = SEEN_OSC; - esc_args[0] = 0; - break; - case '(': /* should set GL */ - compatibility(VT100); - termstate = SET_GL; - break; - case ')': /* should set GR */ - compatibility(VT100); - termstate = SET_GR; - break; - case '7': /* save cursor */ - compatibility(VT100); - save_cursor (TRUE); - break; - case '8': /* restore cursor */ - compatibility(VT100); - save_cursor (FALSE); - seen_disp_event = TRUE; - break; - case '=': - compatibility(VT100); - app_keypad_keys = TRUE; - break; - case '>': - compatibility(VT100); - app_keypad_keys = FALSE; - break; - case 'D': /* exactly equivalent to LF */ - compatibility(VT100); - if (curs.y == marg_b) - scroll (marg_t, marg_b, 1, TRUE); - else if (curs.y < rows-1) - curs.y++; - fix_cpos; - wrapnext = FALSE; - seen_disp_event = TRUE; - break; - case 'E': /* exactly equivalent to CR-LF */ - compatibility(VT100); - curs.x = 0; - if (curs.y == marg_b) - scroll (marg_t, marg_b, 1, TRUE); - else if (curs.y < rows-1) - curs.y++; - fix_cpos; - wrapnext = FALSE; - seen_disp_event = TRUE; - break; - case 'M': /* reverse index - backwards LF */ - compatibility(VT100); - if (curs.y == marg_t) - scroll (marg_t, marg_b, -1, TRUE); - else if (curs.y > 0) - curs.y--; - fix_cpos; - wrapnext = FALSE; - seen_disp_event = TRUE; - break; - case 'Z': /* terminal type query */ - compatibility(VT100); - ldisc_send (id_string, strlen(id_string)); - break; - case 'c': /* restore power-on settings */ - compatibility(VT100); - power_on(); - if (reset_132) { - request_resize (80, rows, 1); - reset_132 = 0; + if (term->insert) + insch(term, 1); + if (term->selstate != NO_SELECTION) { + pos cursplus = term->curs; + incpos(cursplus); + check_selection(term, term->curs, cursplus); } - fix_cpos; - disptop = 0; - seen_disp_event = TRUE; - break; - case '#': /* ESC # 8 fills screen with Es :-) */ - compatibility(VT100); - termstate = SEEN_ESCHASH; - break; - case 'H': /* set a tab */ - compatibility(VT100); - tabs[curs.x] = TRUE; - break; - } - break; - case SEEN_CSI: - termstate = TOPLEVEL; /* default */ - if( isdigit(c) ) - { - if (esc_nargs <= ARGS_MAX) { - if (esc_args[esc_nargs-1] == ARG_DEFAULT) - esc_args[esc_nargs-1] = 0; - esc_args[esc_nargs-1] = - 10 * esc_args[esc_nargs-1] + c - '0'; - } - termstate = SEEN_CSI; - } - else if( c == ';' ) - { - if (++esc_nargs <= ARGS_MAX) - esc_args[esc_nargs-1] = ARG_DEFAULT; - termstate = SEEN_CSI; - } - else if( c < '@' ) - { - if( esc_query ) esc_query = -1; - else if( c == '?' ) esc_query = TRUE; - else esc_query = c; - termstate = SEEN_CSI; - } - else switch (ANSI(c,esc_query)) { - case 'A': /* move up N lines */ - move (curs.x, curs.y - def(esc_args[0], 1), 1); - seen_disp_event = TRUE; - break; - case 'e': /* move down N lines */ - compatibility(ANSI); - case 'B': - move (curs.x, curs.y + def(esc_args[0], 1), 1); - seen_disp_event = TRUE; - break; - case 'a': /* move right N cols */ - compatibility(ANSI); - case 'C': - move (curs.x + def(esc_args[0], 1), curs.y, 1); - seen_disp_event = TRUE; - break; - case 'D': /* move left N cols */ - move (curs.x - def(esc_args[0], 1), curs.y, 1); - seen_disp_event = TRUE; - break; - case 'E': /* move down N lines and CR */ - compatibility(ANSI); - move (0, curs.y + def(esc_args[0], 1), 1); - seen_disp_event = TRUE; - break; - case 'F': /* move up N lines and CR */ - compatibility(ANSI); - move (0, curs.y - def(esc_args[0], 1), 1); - seen_disp_event = TRUE; - break; - case 'G': case '`': /* set horizontal posn */ - compatibility(ANSI); - move (def(esc_args[0], 1) - 1, curs.y, 0); - seen_disp_event = TRUE; - break; - case 'd': /* set vertical posn */ - compatibility(ANSI); - move (curs.x, (dec_om ? marg_t : 0) + def(esc_args[0], 1) - 1, - (dec_om ? 2 : 0)); - seen_disp_event = TRUE; - break; - case 'H': case 'f': /* set horz and vert posns at once */ - if (esc_nargs < 2) - esc_args[1] = ARG_DEFAULT; - move (def(esc_args[1], 1) - 1, - (dec_om ? marg_t : 0) + def(esc_args[0], 1) - 1, - (dec_om ? 2 : 0)); - seen_disp_event = TRUE; - break; - case 'J': /* erase screen or parts of it */ + if (((c & CSET_MASK) == ATTR_ASCII || (c & CSET_MASK) == 0) && + term->logctx) + logtraffic(term->logctx, (unsigned char) c, LGTYP_ASCII); { - unsigned int i = def(esc_args[0], 0) + 1; - if (i > 3) - i = 0; - erase_lots(FALSE, !!(i & 2), !!(i & 1)); - } - disptop = 0; - seen_disp_event = TRUE; - break; - case 'K': /* erase line or parts of it */ - { - unsigned int i = def(esc_args[0], 0) + 1; - if (i > 3) - i = 0; - erase_lots(TRUE, !!(i & 2), !!(i & 1)); - } - seen_disp_event = TRUE; - break; - case 'L': /* insert lines */ - compatibility(VT102); - if (curs.y <= marg_b) - scroll (curs.y, marg_b, -def(esc_args[0], 1), FALSE); - fix_cpos; - seen_disp_event = TRUE; - break; - case 'M': /* delete lines */ - compatibility(VT102); - if (curs.y <= marg_b) - scroll (curs.y, marg_b, def(esc_args[0], 1), TRUE); - fix_cpos; - seen_disp_event = TRUE; - break; - case '@': /* insert chars */ - /* XXX VTTEST says this is vt220, vt510 manual says vt102 */ - compatibility(VT102); - insch (def(esc_args[0], 1)); - seen_disp_event = TRUE; - break; - case 'P': /* delete chars */ - compatibility(VT102); - insch (-def(esc_args[0], 1)); - seen_disp_event = TRUE; - break; - case 'c': /* terminal type query */ - compatibility(VT100); - /* This is the response for a VT102 */ - ldisc_send (id_string, strlen(id_string)); - break; - case 'n': /* cursor position query */ - if (esc_args[0] == 6) { - char buf[32]; - sprintf (buf, "\033[%d;%dR", curs.y + 1, curs.x + 1); - ldisc_send (buf, strlen(buf)); + int width = 0; + if (DIRECT_CHAR(c)) + width = 1; + if (!width) + width = wcwidth((wchar_t) c); + switch (width) { + case 2: + /* + * If we're about to display a double-width + * character starting in the rightmost + * column, then we do something special + * instead. We must print a space in the + * last column of the screen, then wrap; + * and we also set LATTR_WRAPPED2 which + * instructs subsequent cut-and-pasting not + * only to splice this line to the one + * after it, but to ignore the space in the + * last character position as well. + * (Because what was actually output to the + * terminal was presumably just a sequence + * of CJK characters, and we don't want a + * space to be pasted in the middle of + * those just because they had the + * misfortune to start in the wrong parity + * column. xterm concurs.) + */ + check_boundary(term, term->curs.x, term->curs.y); + check_boundary(term, term->curs.x+2, term->curs.y); + if (term->curs.x == term->cols-1) { + *term->cpos++ = ATTR_ASCII | ' ' | term->curr_attr; + *term->cpos |= LATTR_WRAPPED | LATTR_WRAPPED2; + if (term->curs.y == term->marg_b) + scroll(term, term->marg_t, term->marg_b, + 1, TRUE); + else if (term->curs.y < term->rows - 1) + term->curs.y++; + term->curs.x = 0; + fix_cpos; + /* Now we must check_boundary again, of course. */ + check_boundary(term, term->curs.x, term->curs.y); + check_boundary(term, term->curs.x+2, term->curs.y); + } + *term->cpos++ = c | term->curr_attr; + *term->cpos++ = UCSWIDE | term->curr_attr; + term->curs.x++; + break; + case 1: + check_boundary(term, term->curs.x, term->curs.y); + check_boundary(term, term->curs.x+1, term->curs.y); + *term->cpos++ = c | term->curr_attr; + break; + default: + continue; + } } - else if (esc_args[0] == 5) { - ldisc_send ("\033[0n", 4); + term->curs.x++; + if (term->curs.x == term->cols) { + term->cpos--; + term->curs.x--; + term->wrapnext = TRUE; + if (term->wrap && term->vt52_mode) { + term->cpos[1] |= LATTR_WRAPPED; + if (term->curs.y == term->marg_b) + scroll(term, term->marg_t, term->marg_b, 1, TRUE); + else if (term->curs.y < term->rows - 1) + term->curs.y++; + term->curs.x = 0; + fix_cpos; + term->wrapnext = FALSE; + } } + term->seen_disp_event = 1; break; - case 'h': /* toggle modes to high */ - case ANSI_QUE('h'): - compatibility(VT100); - { - int i; - for (i=0; itermstate = TOPLEVEL; + break; } - break; - case 'l': /* toggle modes to low */ - case ANSI_QUE('l'): - compatibility(VT100); - { - int i; - for (i=0; i= ' ' && c <= '/') { + if (term->esc_query) + term->esc_query = -1; + else + term->esc_query = c; + break; } - break; - case 'g': /* clear tabs */ - compatibility(VT100); - if (esc_nargs == 1) { - if (esc_args[0] == 0) { - tabs[curs.x] = FALSE; - } else if (esc_args[0] == 3) { - int i; - for (i = 0; i < cols; i++) - tabs[i] = FALSE; + term->termstate = TOPLEVEL; + switch (ANSI(c, term->esc_query)) { + case '[': /* enter CSI mode */ + term->termstate = SEEN_CSI; + term->esc_nargs = 1; + term->esc_args[0] = ARG_DEFAULT; + term->esc_query = FALSE; + break; + case ']': /* xterm escape sequences */ + /* Compatibility is nasty here, xterm, linux, decterm yuk! */ + compatibility(OTHER); + term->termstate = SEEN_OSC; + term->esc_args[0] = 0; + break; + case '7': /* save cursor */ + compatibility(VT100); + save_cursor(term, TRUE); + break; + case '8': /* restore cursor */ + compatibility(VT100); + save_cursor(term, FALSE); + term->seen_disp_event = TRUE; + break; + case '=': + compatibility(VT100); + term->app_keypad_keys = TRUE; + break; + case '>': + compatibility(VT100); + term->app_keypad_keys = FALSE; + break; + case 'D': /* exactly equivalent to LF */ + compatibility(VT100); + if (term->curs.y == term->marg_b) + scroll(term, term->marg_t, term->marg_b, 1, TRUE); + else if (term->curs.y < term->rows - 1) + term->curs.y++; + fix_cpos; + term->wrapnext = FALSE; + term->seen_disp_event = TRUE; + break; + case 'E': /* exactly equivalent to CR-LF */ + compatibility(VT100); + term->curs.x = 0; + if (term->curs.y == term->marg_b) + scroll(term, term->marg_t, term->marg_b, 1, TRUE); + else if (term->curs.y < term->rows - 1) + term->curs.y++; + fix_cpos; + term->wrapnext = FALSE; + term->seen_disp_event = TRUE; + break; + case 'M': /* reverse index - backwards LF */ + compatibility(VT100); + if (term->curs.y == term->marg_t) + scroll(term, term->marg_t, term->marg_b, -1, TRUE); + else if (term->curs.y > 0) + term->curs.y--; + fix_cpos; + term->wrapnext = FALSE; + term->seen_disp_event = TRUE; + break; + case 'Z': /* terminal type query */ + compatibility(VT100); + if (term->ldisc) + ldisc_send(term->ldisc, term->id_string, + strlen(term->id_string), 0); + break; + case 'c': /* restore power-on settings */ + compatibility(VT100); + power_on(term); + if (term->ldisc) /* cause ldisc to notice changes */ + ldisc_send(term->ldisc, NULL, 0, 0); + if (term->reset_132) { + if (!term->cfg.no_remote_resize) + request_resize(term->frontend, 80, term->rows); + term->reset_132 = 0; } - } - break; - case 'r': /* set scroll margins */ - compatibility(VT100); - if (esc_nargs <= 2) { - int top, bot; - top = def(esc_args[0], 1) - 1; - bot = (esc_nargs <= 1 || esc_args[1] == 0 ? rows : - def(esc_args[1], rows)) - 1; - if (bot >= rows) - bot = rows-1; - /* VTTEST Bug 9 - if region is less than 2 lines - * don't change region. - */ - if (bot-top > 0) { - marg_t = top; - marg_b = bot; - curs.x = 0; - /* - * I used to think the cursor should be - * placed at the top of the newly marginned - * area. Apparently not: VMS TPU falls over - * if so. - * - * Well actually it should for Origin mode - RDB - */ - curs.y = (dec_om ? marg_t : 0); - fix_cpos; - seen_disp_event = TRUE; + fix_cpos; + term->disptop = 0; + term->seen_disp_event = TRUE; + break; + case 'H': /* set a tab */ + compatibility(VT100); + term->tabs[term->curs.x] = TRUE; + break; + + case ANSI('8', '#'): /* ESC # 8 fills screen with Es :-) */ + compatibility(VT100); + { + unsigned long *ldata; + int i, j; + pos scrtop, scrbot; + + for (i = 0; i < term->rows; i++) { + ldata = lineptr(i); + for (j = 0; j < term->cols; j++) + ldata[j] = ATTR_DEFAULT | 'E'; + ldata[term->cols] = 0; + } + term->disptop = 0; + term->seen_disp_event = TRUE; + scrtop.x = scrtop.y = 0; + scrbot.x = 0; + scrbot.y = term->rows; + check_selection(term, scrtop, scrbot); } - } - break; - case 'm': /* set graphics rendition */ - { - /* - * A VT100 without the AVO only had one attribute, either - * underline or reverse video depending on the cursor type, - * this was selected by CSI 7m. - * - * case 2: - * This is DIM on the VT100-AVO and VT102 - * case 5: - * This is BLINK on the VT100-AVO and VT102+ - * case 8: - * This is INVIS on the VT100-AVO and VT102 - * case 21: - * This like 22 disables BOLD, DIM and INVIS - * - * The ANSI colours appear on any terminal that has colour - * (obviously) but the interaction between sgr0 and the - * colours varies but is usually related to the background - * colour erase item. - * The interaction between colour attributes and the mono - * ones is also very implementation dependent. - * - * The 39 and 49 attributes are likely to be unimplemented. - */ - int i; - for (i=0; iesc_query)) { + case ANSI('3', '#'): + nlattr = LATTR_TOP; break; - case 39: /* default-foreground */ - curr_attr &= ~ATTR_FGMASK; - curr_attr |= ATTR_DEFFG; + case ANSI('4', '#'): + nlattr = LATTR_BOT; break; - case 40: case 41: case 42: case 43: - case 44: case 45: case 46: case 47: - /* background */ - curr_attr &= ~ATTR_BGMASK; - curr_attr |= (esc_args[i] - 40) << ATTR_BGSHIFT; + case ANSI('5', '#'): + nlattr = LATTR_NORM; break; - case 49: /* default-background */ - curr_attr &= ~ATTR_BGMASK; - curr_attr |= ATTR_DEFBG; + default: /* spiritually case ANSI('6', '#'): */ + nlattr = LATTR_WIDE; break; } + ldata = lineptr(term->curs.y); + ldata[term->cols] &= ~LATTR_MODE; + ldata[term->cols] |= nlattr; } - if (use_bce) - erase_char = - (' '| - (curr_attr&(ATTR_FGMASK|ATTR_BGMASK|ATTR_BLINK)) - ); - } - break; - case 's': /* save cursor */ - save_cursor (TRUE); - break; - case 'u': /* restore cursor */ - save_cursor (FALSE); - seen_disp_event = TRUE; - break; - case 't': /* set page size - ie window height */ - /* - * VT340/VT420 sequence DECSLPP, DEC only allows values - * 24/25/36/48/72/144 other emulators (eg dtterm) use - * illegal values (eg first arg 1..9) for window changing - * and reports. - */ - compatibility(VT340TEXT); - if (esc_nargs<=1 && (esc_args[0]<1 || esc_args[0]>=24)) { - request_resize (cols, def(esc_args[0], 24), 0); - deselect(); - } - break; - case ANSI('|', '*'): - /* VT420 sequence DECSNLS - * Set number of lines on screen - * VT420 uses VGA like hardware and can support any size in - * reasonable range (24..49 AIUI) with no default specified. - */ - compatibility(VT420); - if (esc_nargs==1 && esc_args[0]>0) { - request_resize (cols, def(esc_args[0], cfg.height), 0); - deselect(); - } - break; - case ANSI('|', '$'): - /* VT340/VT420 sequence DECSCPP - * Set number of columns per page - * Docs imply range is only 80 or 132, but I'll allow any. - */ - compatibility(VT340TEXT); - if (esc_nargs<=1) { - request_resize (def(esc_args[0], cfg.width), rows, 0); - deselect(); - } - break; - case 'X': /* write N spaces w/o moving cursor */ - /* XXX VTTEST says this is vt220, vt510 manual says vt100 */ - compatibility(ANSIMIN); - { - int n = def(esc_args[0], 1); - pos cursplus; - unsigned long *p = cpos; - if (n > cols - curs.x) - n = cols - curs.x; - cursplus = curs; - cursplus.x += n; - check_selection (curs, cursplus); - while (n--) - *p++ = erase_char; - seen_disp_event = TRUE; + break; + + case ANSI('A', '('): + compatibility(VT100); + if (!term->cfg.no_remote_charset) + term->cset_attr[0] = ATTR_GBCHR; + break; + case ANSI('B', '('): + compatibility(VT100); + if (!term->cfg.no_remote_charset) + term->cset_attr[0] = ATTR_ASCII; + break; + case ANSI('0', '('): + compatibility(VT100); + if (!term->cfg.no_remote_charset) + term->cset_attr[0] = ATTR_LINEDRW; + break; + case ANSI('U', '('): + compatibility(OTHER); + if (!term->cfg.no_remote_charset) + term->cset_attr[0] = ATTR_SCOACS; + break; + + case ANSI('A', ')'): + compatibility(VT100); + if (!term->cfg.no_remote_charset) + term->cset_attr[1] = ATTR_GBCHR; + break; + case ANSI('B', ')'): + compatibility(VT100); + if (!term->cfg.no_remote_charset) + term->cset_attr[1] = ATTR_ASCII; + break; + case ANSI('0', ')'): + compatibility(VT100); + if (!term->cfg.no_remote_charset) + term->cset_attr[1] = ATTR_LINEDRW; + break; + case ANSI('U', ')'): + compatibility(OTHER); + if (!term->cfg.no_remote_charset) + term->cset_attr[1] = ATTR_SCOACS; + break; + + case ANSI('8', '%'): /* Old Linux code */ + case ANSI('G', '%'): + compatibility(OTHER); + if (!term->cfg.no_remote_charset) + term->utf = 1; + break; + case ANSI('@', '%'): + compatibility(OTHER); + if (!term->cfg.no_remote_charset) + term->utf = 0; + break; } break; - case 'x': /* report terminal characteristics */ - compatibility(VT100); - { - char buf[32]; - int i = def(esc_args[0], 0); - if (i == 0 || i == 1) { - strcpy (buf, "\033[2;1;1;112;112;1;0x"); - buf[2] += i; - ldisc_send (buf, 20); + case SEEN_CSI: + term->termstate = TOPLEVEL; /* default */ + if (isdigit(c)) { + if (term->esc_nargs <= ARGS_MAX) { + if (term->esc_args[term->esc_nargs - 1] == ARG_DEFAULT) + term->esc_args[term->esc_nargs - 1] = 0; + term->esc_args[term->esc_nargs - 1] = + 10 * term->esc_args[term->esc_nargs - 1] + c - '0'; } - } - break; - case ANSI('L','='): - compatibility(OTHER); - use_bce = (esc_args[0]<=0); - erase_char = ERASE_CHAR; - if (use_bce) - erase_char = (' '|(curr_attr&(ATTR_FGMASK|ATTR_BGMASK))); - break; - case ANSI('E','='): - compatibility(OTHER); - blink_is_real = (esc_args[0]>=1); - break; - case ANSI('p','"'): - /* Allow the host to make this emulator a 'perfect' VT102. - * This first appeared in the VT220, but we do need to get - * back to PuTTY mode so I won't check it. - * - * The arg in 40..42 are a PuTTY extension. - * The 2nd arg, 8bit vs 7bit is not checked. - * - * Setting VT102 mode should also change the Fkeys to - * generate PF* codes as a real VT102 has no Fkeys. - * The VT220 does this, F11..F13 become ESC,BS,LF other Fkeys - * send nothing. - * - * Note ESC c will NOT change this! - */ + term->termstate = SEEN_CSI; + } else if (c == ';') { + if (++term->esc_nargs <= ARGS_MAX) + term->esc_args[term->esc_nargs - 1] = ARG_DEFAULT; + term->termstate = SEEN_CSI; + } else if (c < '@') { + if (term->esc_query) + term->esc_query = -1; + else if (c == '?') + term->esc_query = TRUE; + else + term->esc_query = c; + term->termstate = SEEN_CSI; + } else + switch (ANSI(c, term->esc_query)) { + case 'A': /* move up N lines */ + move(term, term->curs.x, + term->curs.y - def(term->esc_args[0], 1), 1); + term->seen_disp_event = TRUE; + break; + case 'e': /* move down N lines */ + compatibility(ANSI); + /* FALLTHROUGH */ + case 'B': + move(term, term->curs.x, + term->curs.y + def(term->esc_args[0], 1), 1); + term->seen_disp_event = TRUE; + break; + case ANSI('c', '>'): /* report xterm version */ + compatibility(OTHER); + /* this reports xterm version 136 so that VIM can + use the drag messages from the mouse reporting */ + if (term->ldisc) + ldisc_send(term->ldisc, "\033[>0;136;0c", 11, 0); + break; + case 'a': /* move right N cols */ + compatibility(ANSI); + /* FALLTHROUGH */ + case 'C': + move(term, term->curs.x + def(term->esc_args[0], 1), + term->curs.y, 1); + term->seen_disp_event = TRUE; + break; + case 'D': /* move left N cols */ + move(term, term->curs.x - def(term->esc_args[0], 1), + term->curs.y, 1); + term->seen_disp_event = TRUE; + break; + case 'E': /* move down N lines and CR */ + compatibility(ANSI); + move(term, 0, + term->curs.y + def(term->esc_args[0], 1), 1); + term->seen_disp_event = TRUE; + break; + case 'F': /* move up N lines and CR */ + compatibility(ANSI); + move(term, 0, + term->curs.y - def(term->esc_args[0], 1), 1); + term->seen_disp_event = TRUE; + break; + case 'G': + case '`': /* set horizontal posn */ + compatibility(ANSI); + move(term, def(term->esc_args[0], 1) - 1, + term->curs.y, 0); + term->seen_disp_event = TRUE; + break; + case 'd': /* set vertical posn */ + compatibility(ANSI); + move(term, term->curs.x, + ((term->dec_om ? term->marg_t : 0) + + def(term->esc_args[0], 1) - 1), + (term->dec_om ? 2 : 0)); + term->seen_disp_event = TRUE; + break; + case 'H': + case 'f': /* set horz and vert posns at once */ + if (term->esc_nargs < 2) + term->esc_args[1] = ARG_DEFAULT; + move(term, def(term->esc_args[1], 1) - 1, + ((term->dec_om ? term->marg_t : 0) + + def(term->esc_args[0], 1) - 1), + (term->dec_om ? 2 : 0)); + term->seen_disp_event = TRUE; + break; + case 'J': /* erase screen or parts of it */ + { + unsigned int i = def(term->esc_args[0], 0) + 1; + if (i > 3) + i = 0; + erase_lots(term, FALSE, !!(i & 2), !!(i & 1)); + } + term->disptop = 0; + term->seen_disp_event = TRUE; + break; + case 'K': /* erase line or parts of it */ + { + unsigned int i = def(term->esc_args[0], 0) + 1; + if (i > 3) + i = 0; + erase_lots(term, TRUE, !!(i & 2), !!(i & 1)); + } + term->seen_disp_event = TRUE; + break; + case 'L': /* insert lines */ + compatibility(VT102); + if (term->curs.y <= term->marg_b) + scroll(term, term->curs.y, term->marg_b, + -def(term->esc_args[0], 1), FALSE); + fix_cpos; + term->seen_disp_event = TRUE; + break; + case 'M': /* delete lines */ + compatibility(VT102); + if (term->curs.y <= term->marg_b) + scroll(term, term->curs.y, term->marg_b, + def(term->esc_args[0], 1), + TRUE); + fix_cpos; + term->seen_disp_event = TRUE; + break; + case '@': /* insert chars */ + /* XXX VTTEST says this is vt220, vt510 manual says vt102 */ + compatibility(VT102); + insch(term, def(term->esc_args[0], 1)); + term->seen_disp_event = TRUE; + break; + case 'P': /* delete chars */ + compatibility(VT102); + insch(term, -def(term->esc_args[0], 1)); + term->seen_disp_event = TRUE; + break; + case 'c': /* terminal type query */ + compatibility(VT100); + /* This is the response for a VT102 */ + if (term->ldisc) + ldisc_send(term->ldisc, term->id_string, + strlen(term->id_string), 0); + break; + case 'n': /* cursor position query */ + if (term->ldisc) { + if (term->esc_args[0] == 6) { + char buf[32]; + sprintf(buf, "\033[%d;%dR", term->curs.y + 1, + term->curs.x + 1); + ldisc_send(term->ldisc, buf, strlen(buf), 0); + } else if (term->esc_args[0] == 5) { + ldisc_send(term->ldisc, "\033[0n", 4, 0); + } + } + break; + case 'h': /* toggle modes to high */ + case ANSI_QUE('h'): + compatibility(VT100); + { + int i; + for (i = 0; i < term->esc_nargs; i++) + toggle_mode(term, term->esc_args[i], + term->esc_query, TRUE); + } + break; + case 'i': + case ANSI_QUE('i'): + compatibility(VT100); + { + if (term->esc_nargs != 1) break; + if (term->esc_args[0] == 5 && *term->cfg.printer) { + term->printing = TRUE; + term->only_printing = !term->esc_query; + term->print_state = 0; + term_print_setup(term); + } else if (term->esc_args[0] == 4 && + term->printing) { + term_print_finish(term); + } + } + break; + case 'l': /* toggle modes to low */ + case ANSI_QUE('l'): + compatibility(VT100); + { + int i; + for (i = 0; i < term->esc_nargs; i++) + toggle_mode(term, term->esc_args[i], + term->esc_query, FALSE); + } + break; + case 'g': /* clear tabs */ + compatibility(VT100); + if (term->esc_nargs == 1) { + if (term->esc_args[0] == 0) { + term->tabs[term->curs.x] = FALSE; + } else if (term->esc_args[0] == 3) { + int i; + for (i = 0; i < term->cols; i++) + term->tabs[i] = FALSE; + } + } + break; + case 'r': /* set scroll margins */ + compatibility(VT100); + if (term->esc_nargs <= 2) { + int top, bot; + top = def(term->esc_args[0], 1) - 1; + bot = (term->esc_nargs <= 1 + || term->esc_args[1] == 0 ? + term->rows : + def(term->esc_args[1], term->rows)) - 1; + if (bot >= term->rows) + bot = term->rows - 1; + /* VTTEST Bug 9 - if region is less than 2 lines + * don't change region. + */ + if (bot - top > 0) { + term->marg_t = top; + term->marg_b = bot; + term->curs.x = 0; + /* + * I used to think the cursor should be + * placed at the top of the newly marginned + * area. Apparently not: VMS TPU falls over + * if so. + * + * Well actually it should for + * Origin mode - RDB + */ + term->curs.y = (term->dec_om ? + term->marg_t : 0); + fix_cpos; + term->seen_disp_event = TRUE; + } + } + break; + case 'm': /* set graphics rendition */ + { + /* + * A VT100 without the AVO only had one + * attribute, either underline or + * reverse video depending on the + * cursor type, this was selected by + * CSI 7m. + * + * case 2: + * This is sometimes DIM, eg on the + * GIGI and Linux + * case 8: + * This is sometimes INVIS various ANSI. + * case 21: + * This like 22 disables BOLD, DIM and INVIS + * + * The ANSI colours appear on any + * terminal that has colour (obviously) + * but the interaction between sgr0 and + * the colours varies but is usually + * related to the background colour + * erase item. The interaction between + * colour attributes and the mono ones + * is also very implementation + * dependent. + * + * The 39 and 49 attributes are likely + * to be unimplemented. + */ + int i; + for (i = 0; i < term->esc_nargs; i++) { + switch (def(term->esc_args[i], 0)) { + case 0: /* restore defaults */ + term->curr_attr = ATTR_DEFAULT; + break; + case 1: /* enable bold */ + compatibility(VT100AVO); + term->curr_attr |= ATTR_BOLD; + break; + case 21: /* (enable double underline) */ + compatibility(OTHER); + case 4: /* enable underline */ + compatibility(VT100AVO); + term->curr_attr |= ATTR_UNDER; + break; + case 5: /* enable blink */ + compatibility(VT100AVO); + term->curr_attr |= ATTR_BLINK; + break; + case 7: /* enable reverse video */ + term->curr_attr |= ATTR_REVERSE; + break; + case 10: /* SCO acs off */ + compatibility(SCOANSI); + if (term->cfg.no_remote_charset) break; + term->sco_acs = 0; break; + case 11: /* SCO acs on */ + compatibility(SCOANSI); + if (term->cfg.no_remote_charset) break; + term->sco_acs = 1; break; + case 12: /* SCO acs on, |0x80 */ + compatibility(SCOANSI); + if (term->cfg.no_remote_charset) break; + term->sco_acs = 2; break; + case 22: /* disable bold */ + compatibility2(OTHER, VT220); + term->curr_attr &= ~ATTR_BOLD; + break; + case 24: /* disable underline */ + compatibility2(OTHER, VT220); + term->curr_attr &= ~ATTR_UNDER; + break; + case 25: /* disable blink */ + compatibility2(OTHER, VT220); + term->curr_attr &= ~ATTR_BLINK; + break; + case 27: /* disable reverse video */ + compatibility2(OTHER, VT220); + term->curr_attr &= ~ATTR_REVERSE; + break; + case 30: + case 31: + case 32: + case 33: + case 34: + case 35: + case 36: + case 37: + /* foreground */ + term->curr_attr &= ~ATTR_FGMASK; + term->curr_attr |= + (term->esc_args[i] - 30)<curr_attr &= ~ATTR_FGMASK; + term->curr_attr |= ATTR_DEFFG; + break; + case 40: + case 41: + case 42: + case 43: + case 44: + case 45: + case 46: + case 47: + /* background */ + term->curr_attr &= ~ATTR_BGMASK; + term->curr_attr |= + (term->esc_args[i] - 40)<curr_attr &= ~ATTR_BGMASK; + term->curr_attr |= ATTR_DEFBG; + break; + } + } + if (term->use_bce) + term->erase_char = (' ' | ATTR_ASCII | + (term->curr_attr & + (ATTR_FGMASK | + ATTR_BGMASK))); + } + break; + case 's': /* save cursor */ + save_cursor(term, TRUE); + break; + case 'u': /* restore cursor */ + save_cursor(term, FALSE); + term->seen_disp_event = TRUE; + break; + case 't': /* set page size - ie window height */ + /* + * VT340/VT420 sequence DECSLPP, DEC only allows values + * 24/25/36/48/72/144 other emulators (eg dtterm) use + * illegal values (eg first arg 1..9) for window changing + * and reports. + */ + if (term->esc_nargs <= 1 + && (term->esc_args[0] < 1 || + term->esc_args[0] >= 24)) { + compatibility(VT340TEXT); + if (!term->cfg.no_remote_resize) + request_resize(term->frontend, term->cols, + def(term->esc_args[0], 24)); + deselect(term); + } else if (term->esc_nargs >= 1 && + term->esc_args[0] >= 1 && + term->esc_args[0] < 24) { + compatibility(OTHER); - switch (esc_args[0]) { - case 61: compatibility_level &= ~TM_VTXXX; - compatibility_level |= TM_VT102; break; - case 62: compatibility_level &= ~TM_VTXXX; - compatibility_level |= TM_VT220; break; + switch (term->esc_args[0]) { + int x, y, len; + char buf[80], *p; + case 1: + set_iconic(term->frontend, FALSE); + break; + case 2: + set_iconic(term->frontend, TRUE); + break; + case 3: + if (term->esc_nargs >= 3) { + if (!term->cfg.no_remote_resize) + move_window(term->frontend, + def(term->esc_args[1], 0), + def(term->esc_args[2], 0)); + } + break; + case 4: + /* We should resize the window to a given + * size in pixels here, but currently our + * resizing code isn't healthy enough to + * manage it. */ + break; + case 5: + /* move to top */ + set_zorder(term->frontend, TRUE); + break; + case 6: + /* move to bottom */ + set_zorder(term->frontend, FALSE); + break; + case 7: + refresh_window(term->frontend); + break; + case 8: + if (term->esc_nargs >= 3) { + if (!term->cfg.no_remote_resize) + request_resize(term->frontend, + def(term->esc_args[2], term->cfg.width), + def(term->esc_args[1], term->cfg.height)); + } + break; + case 9: + if (term->esc_nargs >= 2) + set_zoomed(term->frontend, + term->esc_args[1] ? + TRUE : FALSE); + break; + case 11: + if (term->ldisc) + ldisc_send(term->ldisc, + is_iconic(term->frontend) ? + "\033[1t" : "\033[2t", 4, 0); + break; + case 13: + if (term->ldisc) { + get_window_pos(term->frontend, &x, &y); + len = sprintf(buf, "\033[3;%d;%dt", x, y); + ldisc_send(term->ldisc, buf, len, 0); + } + break; + case 14: + if (term->ldisc) { + get_window_pixels(term->frontend, &x, &y); + len = sprintf(buf, "\033[4;%d;%dt", x, y); + ldisc_send(term->ldisc, buf, len, 0); + } + break; + case 18: + if (term->ldisc) { + len = sprintf(buf, "\033[8;%d;%dt", + term->rows, term->cols); + ldisc_send(term->ldisc, buf, len, 0); + } + break; + case 19: + /* + * Hmmm. Strictly speaking we + * should return `the size of the + * screen in characters', but + * that's not easy: (a) window + * furniture being what it is it's + * hard to compute, and (b) in + * resize-font mode maximising the + * window wouldn't change the + * number of characters. *shrug*. I + * think we'll ignore it for the + * moment and see if anyone + * complains, and then ask them + * what they would like it to do. + */ + break; + case 20: + if (term->ldisc) { + p = get_window_title(term->frontend, TRUE); + len = strlen(p); + ldisc_send(term->ldisc, "\033]L", 3, 0); + ldisc_send(term->ldisc, p, len, 0); + ldisc_send(term->ldisc, "\033\\", 2, 0); + } + break; + case 21: + if (term->ldisc) { + p = get_window_title(term->frontend,FALSE); + len = strlen(p); + ldisc_send(term->ldisc, "\033]l", 3, 0); + ldisc_send(term->ldisc, p, len, 0); + ldisc_send(term->ldisc, "\033\\", 2, 0); + } + break; + } + } + break; + case 'S': + compatibility(SCOANSI); + scroll(term, term->marg_t, term->marg_b, + def(term->esc_args[0], 1), TRUE); + fix_cpos; + term->wrapnext = FALSE; + term->seen_disp_event = TRUE; + break; + case 'T': + compatibility(SCOANSI); + scroll(term, term->marg_t, term->marg_b, + -def(term->esc_args[0], 1), TRUE); + fix_cpos; + term->wrapnext = FALSE; + term->seen_disp_event = TRUE; + break; + case ANSI('|', '*'): + /* VT420 sequence DECSNLS + * Set number of lines on screen + * VT420 uses VGA like hardware and can support any size in + * reasonable range (24..49 AIUI) with no default specified. + */ + compatibility(VT420); + if (term->esc_nargs == 1 && term->esc_args[0] > 0) { + if (!term->cfg.no_remote_resize) + request_resize(term->frontend, term->cols, + def(term->esc_args[0], + term->cfg.height)); + deselect(term); + } + break; + case ANSI('|', '$'): + /* VT340/VT420 sequence DECSCPP + * Set number of columns per page + * Docs imply range is only 80 or 132, but I'll allow any. + */ + compatibility(VT340TEXT); + if (term->esc_nargs <= 1) { + if (!term->cfg.no_remote_resize) + request_resize(term->frontend, + def(term->esc_args[0], + term->cfg.width), term->rows); + deselect(term); + } + break; + case 'X': /* write N spaces w/o moving cursor */ + /* XXX VTTEST says this is vt220, vt510 manual says vt100 */ + compatibility(ANSIMIN); + { + int n = def(term->esc_args[0], 1); + pos cursplus; + unsigned long *p = term->cpos; + if (n > term->cols - term->curs.x) + n = term->cols - term->curs.x; + cursplus = term->curs; + cursplus.x += n; + check_boundary(term, term->curs.x, term->curs.y); + check_boundary(term, term->curs.x+n, term->curs.y); + check_selection(term, term->curs, cursplus); + while (n--) + *p++ = term->erase_char; + term->seen_disp_event = TRUE; + } + break; + case 'x': /* report terminal characteristics */ + compatibility(VT100); + if (term->ldisc) { + char buf[32]; + int i = def(term->esc_args[0], 0); + if (i == 0 || i == 1) { + strcpy(buf, "\033[2;1;1;112;112;1;0x"); + buf[2] += i; + ldisc_send(term->ldisc, buf, 20, 0); + } + } + break; + case 'Z': /* BackTab for xterm */ + compatibility(OTHER); + { + int i = def(term->esc_args[0], 1); + pos old_curs = term->curs; + + for(;i>0 && term->curs.x>0; i--) { + do { + term->curs.x--; + } while (term->curs.x >0 && + !term->tabs[term->curs.x]); + } + fix_cpos; + check_selection(term, old_curs, term->curs); + } + break; + case ANSI('L', '='): + compatibility(OTHER); + term->use_bce = (term->esc_args[0] <= 0); + term->erase_char = ERASE_CHAR; + if (term->use_bce) + term->erase_char = (' ' | ATTR_ASCII | + (term->curr_attr & + (ATTR_FGMASK | ATTR_BGMASK))); + break; + case ANSI('E', '='): + compatibility(OTHER); + term->blink_is_real = (term->esc_args[0] >= 1); + break; + case ANSI('p', '"'): + /* + * Allow the host to make this emulator a + * 'perfect' VT102. This first appeared in + * the VT220, but we do need to get back to + * PuTTY mode so I won't check it. + * + * The arg in 40..42,50 are a PuTTY extension. + * The 2nd arg, 8bit vs 7bit is not checked. + * + * Setting VT102 mode should also change + * the Fkeys to generate PF* codes as a + * real VT102 has no Fkeys. The VT220 does + * this, F11..F13 become ESC,BS,LF other + * Fkeys send nothing. + * + * Note ESC c will NOT change this! + */ - default: if( esc_args[0] > 60 && esc_args[0] < 70 ) - compatibility_level |= TM_VTXXX; - break; + switch (term->esc_args[0]) { + case 61: + term->compatibility_level &= ~TM_VTXXX; + term->compatibility_level |= TM_VT102; + break; + case 62: + term->compatibility_level &= ~TM_VTXXX; + term->compatibility_level |= TM_VT220; + break; - case 40: compatibility_level &= TM_VTXXX; break; - case 41: compatibility_level = TM_PUTTY; break; - case 42: compatibility_level = TM_SCOANSI; break; + default: + if (term->esc_args[0] > 60 && + term->esc_args[0] < 70) + term->compatibility_level |= TM_VTXXX; + break; - case ARG_DEFAULT: - compatibility_level = TM_PUTTY; break; - case 50: break; - } + case 40: + term->compatibility_level &= TM_VTXXX; + break; + case 41: + term->compatibility_level = TM_PUTTY; + break; + case 42: + term->compatibility_level = TM_SCOANSI; + break; - /* Change the response to CSI c */ - if (esc_args[0] == 50) { - int i; - char lbuf[64]; - strcpy(id_string, "\033[?"); - for (i=1; icompatibility_level = TM_PUTTY; + break; + case 50: + break; + } + /* Change the response to CSI c */ + if (term->esc_args[0] == 50) { + int i; + char lbuf[64]; + strcpy(term->id_string, "\033[?"); + for (i = 1; i < term->esc_nargs; i++) { + if (i != 1) + strcat(term->id_string, ";"); + sprintf(lbuf, "%d", term->esc_args[i]); + strcat(term->id_string, lbuf); + } + strcat(term->id_string, "c"); + } #if 0 - /* Is this a good idea ? - * Well we should do a soft reset at this point ... - */ - if (!has_compat(VT420) && has_compat(VT100)) { - if (reset_132) request_resize (132, 24, 1); - else request_resize ( 80, 24, 1); - } + /* Is this a good idea ? + * Well we should do a soft reset at this point ... + */ + if (!has_compat(VT420) && has_compat(VT100)) { + if (!term->cfg.no_remote_resize) { + if (term->reset_132) + request_resize(132, 24); + else + request_resize(80, 24); + } + } #endif + break; + } break; - } - break; - case SET_GL: - case SET_GR: - /* VT100 only here, checked above */ - switch (c) { - case 'A': - cset_attr[termstate == SET_GL ? 0 : 1] = ATTR_GBCHR; - break; - case '0': - cset_attr[termstate == SET_GL ? 0 : 1] = ATTR_LINEDRW; - break; - case 'B': - default: /* specifically, 'B' */ - cset_attr[termstate == SET_GL ? 0 : 1] = ATTR_ASCII; - break; - } - if( !has_compat(VT220) || c != '%' ) - termstate = TOPLEVEL; - break; - case SEEN_OSC: - osc_w = FALSE; - switch (c) { - case 'P': /* Linux palette sequence */ - termstate = SEEN_OSC_P; - osc_strlen = 0; + case SEEN_OSC: + term->osc_w = FALSE; + switch (c) { + case 'P': /* Linux palette sequence */ + term->termstate = SEEN_OSC_P; + term->osc_strlen = 0; + break; + case 'R': /* Linux palette reset */ + palette_reset(term->frontend); + term_invalidate(term); + term->termstate = TOPLEVEL; + break; + case 'W': /* word-set */ + term->termstate = SEEN_OSC_W; + term->osc_w = TRUE; + break; + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + term->esc_args[0] = 10 * term->esc_args[0] + c - '0'; + break; + case 'L': + /* + * Grotty hack to support xterm and DECterm title + * sequences concurrently. + */ + if (term->esc_args[0] == 2) { + term->esc_args[0] = 1; + break; + } + /* else fall through */ + default: + term->termstate = OSC_STRING; + term->osc_strlen = 0; + } break; - case 'R': /* Linux palette reset */ - palette_reset(); - term_invalidate(); - termstate = TOPLEVEL; + case OSC_STRING: + /* + * This OSC stuff is EVIL. It takes just one character to get into + * sysline mode and it's not initially obvious how to get out. + * So I've added CR and LF as string aborts. + * This shouldn't effect compatibility as I believe embedded + * control characters are supposed to be interpreted (maybe?) + * and they don't display anything useful anyway. + * + * -- RDB + */ + if (c == '\012' || c == '\015') { + term->termstate = TOPLEVEL; + } else if (c == 0234 || c == '\007') { + /* + * These characters terminate the string; ST and BEL + * terminate the sequence and trigger instant + * processing of it, whereas ESC goes back to SEEN_ESC + * mode unless it is followed by \, in which case it is + * synonymous with ST in the first place. + */ + do_osc(term); + term->termstate = TOPLEVEL; + } else if (c == '\033') + term->termstate = OSC_MAYBE_ST; + else if (term->osc_strlen < OSC_STR_MAX) + term->osc_string[term->osc_strlen++] = c; break; - case 'W': /* word-set */ - termstate = SEEN_OSC_W; - osc_w = TRUE; + case SEEN_OSC_P: + { + int max = (term->osc_strlen == 0 ? 21 : 16); + int val; + if (c >= '0' && c <= '9') + val = c - '0'; + else if (c >= 'A' && c <= 'A' + max - 10) + val = c - 'A' + 10; + else if (c >= 'a' && c <= 'a' + max - 10) + val = c - 'a' + 10; + else { + term->termstate = TOPLEVEL; + break; + } + term->osc_string[term->osc_strlen++] = val; + if (term->osc_strlen >= 7) { + palette_set(term->frontend, term->osc_string[0], + term->osc_string[1] * 16 + term->osc_string[2], + term->osc_string[3] * 16 + term->osc_string[4], + term->osc_string[5] * 16 + term->osc_string[6]); + term_invalidate(term); + term->termstate = TOPLEVEL; + } + } break; - case '0': case '1': case '2': case '3': case '4': - case '5': case '6': case '7': case '8': case '9': - esc_args[0] = 10 * esc_args[0] + c - '0'; + case SEEN_OSC_W: + switch (c) { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + term->esc_args[0] = 10 * term->esc_args[0] + c - '0'; + break; + default: + term->termstate = OSC_STRING; + term->osc_strlen = 0; + } break; - case 'L': - /* - * Grotty hack to support xterm and DECterm title - * sequences concurrently. - */ - if (esc_args[0] == 2) { - esc_args[0] = 1; + case VT52_ESC: + term->termstate = TOPLEVEL; + term->seen_disp_event = TRUE; + switch (c) { + case 'A': + move(term, term->curs.x, term->curs.y - 1, 1); + break; + case 'B': + move(term, term->curs.x, term->curs.y + 1, 1); + break; + case 'C': + move(term, term->curs.x + 1, term->curs.y, 1); + break; + case 'D': + move(term, term->curs.x - 1, term->curs.y, 1); + break; + /* + * From the VT100 Manual + * NOTE: The special graphics characters in the VT100 + * are different from those in the VT52 + * + * From VT102 manual: + * 137 _ Blank - Same + * 140 ` Reserved - Humm. + * 141 a Solid rectangle - Similar + * 142 b 1/ - Top half of fraction for the + * 143 c 3/ - subscript numbers below. + * 144 d 5/ + * 145 e 7/ + * 146 f Degrees - Same + * 147 g Plus or minus - Same + * 150 h Right arrow + * 151 i Ellipsis (dots) + * 152 j Divide by + * 153 k Down arrow + * 154 l Bar at scan 0 + * 155 m Bar at scan 1 + * 156 n Bar at scan 2 + * 157 o Bar at scan 3 - Similar + * 160 p Bar at scan 4 - Similar + * 161 q Bar at scan 5 - Similar + * 162 r Bar at scan 6 - Same + * 163 s Bar at scan 7 - Similar + * 164 t Subscript 0 + * 165 u Subscript 1 + * 166 v Subscript 2 + * 167 w Subscript 3 + * 170 x Subscript 4 + * 171 y Subscript 5 + * 172 z Subscript 6 + * 173 { Subscript 7 + * 174 | Subscript 8 + * 175 } Subscript 9 + * 176 ~ Paragraph + * + */ + case 'F': + term->cset_attr[term->cset = 0] = ATTR_LINEDRW; + break; + case 'G': + term->cset_attr[term->cset = 0] = ATTR_ASCII; + break; + case 'H': + move(term, 0, 0, 0); + break; + case 'I': + if (term->curs.y == 0) + scroll(term, 0, term->rows - 1, -1, TRUE); + else if (term->curs.y > 0) + term->curs.y--; + fix_cpos; + term->wrapnext = FALSE; + break; + case 'J': + erase_lots(term, FALSE, FALSE, TRUE); + term->disptop = 0; + break; + case 'K': + erase_lots(term, TRUE, FALSE, TRUE); + break; +#if 0 + case 'V': + /* XXX Print cursor line */ + break; + case 'W': + /* XXX Start controller mode */ + break; + case 'X': + /* XXX Stop controller mode */ + break; +#endif + case 'Y': + term->termstate = VT52_Y1; + break; + case 'Z': + if (term->ldisc) + ldisc_send(term->ldisc, "\033/Z", 3, 0); + break; + case '=': + term->app_keypad_keys = TRUE; + break; + case '>': + term->app_keypad_keys = FALSE; + break; + case '<': + /* XXX This should switch to VT100 mode not current or default + * VT mode. But this will only have effect in a VT220+ + * emulation. + */ + term->vt52_mode = FALSE; + term->blink_is_real = term->cfg.blinktext; + break; +#if 0 + case '^': + /* XXX Enter auto print mode */ + break; + case '_': + /* XXX Exit auto print mode */ + break; + case ']': + /* XXX Print screen */ + break; +#endif + +#ifdef VT52_PLUS + case 'E': + /* compatibility(ATARI) */ + move(term, 0, 0, 0); + erase_lots(term, FALSE, FALSE, TRUE); + term->disptop = 0; + break; + case 'L': + /* compatibility(ATARI) */ + if (term->curs.y <= term->marg_b) + scroll(term, term->curs.y, term->marg_b, -1, FALSE); + break; + case 'M': + /* compatibility(ATARI) */ + if (term->curs.y <= term->marg_b) + scroll(term, term->curs.y, term->marg_b, 1, TRUE); + break; + case 'b': + /* compatibility(ATARI) */ + term->termstate = VT52_FG; + break; + case 'c': + /* compatibility(ATARI) */ + term->termstate = VT52_BG; + break; + case 'd': + /* compatibility(ATARI) */ + erase_lots(term, FALSE, TRUE, FALSE); + term->disptop = 0; + break; + case 'e': + /* compatibility(ATARI) */ + term->cursor_on = TRUE; + break; + case 'f': + /* compatibility(ATARI) */ + term->cursor_on = FALSE; + break; + /* case 'j': Save cursor position - broken on ST */ + /* case 'k': Restore cursor position */ + case 'l': + /* compatibility(ATARI) */ + erase_lots(term, TRUE, TRUE, TRUE); + term->curs.x = 0; + term->wrapnext = FALSE; + fix_cpos; + break; + case 'o': + /* compatibility(ATARI) */ + erase_lots(term, TRUE, TRUE, FALSE); + break; + case 'p': + /* compatibility(ATARI) */ + term->curr_attr |= ATTR_REVERSE; + break; + case 'q': + /* compatibility(ATARI) */ + term->curr_attr &= ~ATTR_REVERSE; + break; + case 'v': /* wrap Autowrap on - Wyse style */ + /* compatibility(ATARI) */ + term->wrap = 1; + break; + case 'w': /* Autowrap off */ + /* compatibility(ATARI) */ + term->wrap = 0; break; - } - /* else fall through */ - default: - termstate = OSC_STRING; - osc_strlen = 0; - } - break; - case OSC_STRING: - /* - * This OSC stuff is EVIL. It takes just one character to get into - * sysline mode and it's not initially obvious how to get out. - * So I've added CR and LF as string aborts. - * This shouldn't effect compatibility as I believe embedded - * control characters are supposed to be interpreted (maybe?) - * and they don't display anything useful anyway. - * - * -- RDB - */ - if (c == '\n' || c == '\r') { - termstate = TOPLEVEL; - } else if (c == 0234 || c == '\007' ) { - /* - * These characters terminate the string; ST and BEL - * terminate the sequence and trigger instant - * processing of it, whereas ESC goes back to SEEN_ESC - * mode unless it is followed by \, in which case it is - * synonymous with ST in the first place. - */ - do_osc(); - termstate = TOPLEVEL; - } else if (c == '\033') - termstate = OSC_MAYBE_ST; - else if (osc_strlen < OSC_STR_MAX) - osc_string[osc_strlen++] = c; - break; - case SEEN_OSC_P: - { - int max = (osc_strlen == 0 ? 21 : 16); - int val; - if (c >= '0' && c <= '9') - val = c - '0'; - else if (c >= 'A' && c <= 'A'+max-10) - val = c - 'A' + 10; - else if (c >= 'a' && c <= 'a'+max-10) - val = c - 'a' + 10; - else - termstate = TOPLEVEL; - osc_string[osc_strlen++] = val; - if (osc_strlen >= 7) { - palette_set (osc_string[0], - osc_string[1] * 16 + osc_string[2], - osc_string[3] * 16 + osc_string[4], - osc_string[5] * 16 + osc_string[6]); - term_invalidate(); - termstate = TOPLEVEL; - } - } - break; - case SEEN_OSC_W: - switch (c) { - case '0': case '1': case '2': case '3': case '4': - case '5': case '6': case '7': case '8': case '9': - esc_args[0] = 10 * esc_args[0] + c - '0'; - break; - default: - termstate = OSC_STRING; - osc_strlen = 0; - } - break; - case SEEN_ESCHASH: - { - unsigned long nlattr; - unsigned long *ldata; - int i, j; - pos scrtop, scrbot; - switch (c) { - case '8': - for (i = 0; i < rows; i++) { - ldata = lineptr(i); - for (j = 0; j < cols; j++) - ldata[j] = ATTR_DEFAULT | 'E'; - ldata[cols] = 0; - } - disptop = 0; - seen_disp_event = TRUE; - scrtop.x = scrtop.y = 0; - scrbot.x = 0; scrbot.y = rows; - check_selection (scrtop, scrbot); - break; - - case '3': nlattr = LATTR_TOP; goto lattr_common; - case '4': nlattr = LATTR_BOT; goto lattr_common; - case '5': nlattr = LATTR_NORM; goto lattr_common; - case '6': nlattr = LATTR_WIDE; - lattr_common: - - ldata = lineptr(curs.y); - ldata[cols] &= ~LATTR_MODE; - ldata[cols] |= nlattr; + case 'R': + /* compatibility(OTHER) */ + term->vt52_bold = FALSE; + term->curr_attr = ATTR_DEFAULT; + if (term->use_bce) + term->erase_char = (' ' | ATTR_ASCII | + (term->curr_attr & + (ATTR_FGMASK | ATTR_BGMASK))); + break; + case 'S': + /* compatibility(VI50) */ + term->curr_attr |= ATTR_UNDER; + break; + case 'W': + /* compatibility(VI50) */ + term->curr_attr &= ~ATTR_UNDER; + break; + case 'U': + /* compatibility(VI50) */ + term->vt52_bold = TRUE; + term->curr_attr |= ATTR_BOLD; + break; + case 'T': + /* compatibility(VI50) */ + term->vt52_bold = FALSE; + term->curr_attr &= ~ATTR_BOLD; + break; +#endif } - } - termstate = TOPLEVEL; - break; - case VT52_ESC: - termstate = TOPLEVEL; - seen_disp_event = TRUE; - switch (c) { - case 'A': - move (curs.x, curs.y - 1, 1); - break; - case 'B': - move (curs.x, curs.y + 1, 1); - break; - case 'C': - move (curs.x + 1, curs.y, 1); - break; - case 'D': - move (curs.x - 1, curs.y, 1); - break; - case 'F': - cset_attr[cset=0] = ATTR_LINEDRW; - break; - case 'G': - cset_attr[cset=0] = ATTR_ASCII; - break; - case 'H': - move (0, 0, 0); - break; - case 'I': - if (curs.y == 0) - scroll (0, rows-1, -1, TRUE); - else if (curs.y > 0) - curs.y--; - fix_cpos; - wrapnext = FALSE; - break; - case 'J': - erase_lots(FALSE, FALSE, TRUE); - disptop = 0; - break; - case 'K': - erase_lots(TRUE, FALSE, TRUE); - break; - case 'V': - /* XXX Print cursor line */ break; - case 'W': - /* XXX Start controller mode */ + case VT52_Y1: + term->termstate = VT52_Y2; + move(term, term->curs.x, c - ' ', 0); break; - case 'X': - /* XXX Stop controller mode */ + case VT52_Y2: + term->termstate = TOPLEVEL; + move(term, c - ' ', term->curs.y, 0); break; - case 'Y': - termstate = VT52_Y1; - break; - case 'Z': - ldisc_send ("\033/Z", 3); - break; - case '=': - app_keypad_keys = TRUE; - break; - case '>': - app_keypad_keys = FALSE; - break; - case '<': - /* XXX This should switch to VT100 mode not current or default - * VT mode. But this will only have effect in a VT220+ - * emulation. - */ - vt52_mode = FALSE; - break; - case '^': - /* XXX Enter auto print mode */ - break; - case '_': - /* XXX Exit auto print mode */ + +#ifdef VT52_PLUS + case VT52_FG: + term->termstate = TOPLEVEL; + term->curr_attr &= ~ATTR_FGMASK; + term->curr_attr &= ~ATTR_BOLD; + term->curr_attr |= (c & 0x7) << ATTR_FGSHIFT; + if ((c & 0x8) || term->vt52_bold) + term->curr_attr |= ATTR_BOLD; + + if (term->use_bce) + term->erase_char = (' ' | ATTR_ASCII | + (term->curr_attr & + (ATTR_FGMASK | ATTR_BGMASK))); break; - case ']': - /* XXX Print screen */ + case VT52_BG: + term->termstate = TOPLEVEL; + term->curr_attr &= ~ATTR_BGMASK; + term->curr_attr &= ~ATTR_BLINK; + term->curr_attr |= (c & 0x7) << ATTR_BGSHIFT; + + /* Note: bold background */ + if (c & 0x8) + term->curr_attr |= ATTR_BLINK; + + if (term->use_bce) + term->erase_char = (' ' | ATTR_ASCII | + (term->curr_attr & + (ATTR_FGMASK | ATTR_BGMASK))); break; +#endif + default: break; /* placate gcc warning about enum use */ } - break; - case VT52_Y1: - termstate = VT52_Y2; - move(curs.x, c-' ', 0); - break; - case VT52_Y2: - termstate = TOPLEVEL; - move(c-' ', curs.y, 0); - break; - } - if (selstate != NO_SELECTION) { - pos cursplus = curs; + if (term->selstate != NO_SELECTION) { + pos cursplus = term->curs; incpos(cursplus); - check_selection (curs, cursplus); + check_selection(term, term->curs, cursplus); } } - inbuf_head = 0; + + term_print_flush(term); } +#if 0 /* * Compare two lines to determine whether they are sufficiently * alike to scroll-optimise one to the other. Return the degree of * similarity. */ -static int linecmp (unsigned long *a, unsigned long *b) { +static int linecmp(Terminal *term, unsigned long *a, unsigned long *b) +{ int i, n; - for (i=n=0; i < cols; i++) + for (i = n = 0; i < term->cols; i++) n += (*a++ == *b++); return n; } +#endif /* * Given a context, update the window. Out of paranoia, we don't * allow WM_PAINT responses to do scrolling optimisations. */ -static void do_paint (Context ctx, int may_optimise) { - int i, j, start, our_curs_y; - unsigned long attr, rv, cursor; +static void do_paint(Terminal *term, Context ctx, int may_optimise) +{ + int i, j, our_curs_y, our_curs_x; + unsigned long rv, cursor; pos scrpos; char ch[1024]; - long ticks; + long cursor_background = ERASE_CHAR; + unsigned long ticks; /* * Check the visual bell state. */ - if (in_vbell) { - ticks = GetTickCount(); - if (ticks - vbell_timeout >= 0) - in_vbell = FALSE; - } + if (term->in_vbell) { + ticks = GETTICKCOUNT(); + if (ticks - term->vbell_startpoint >= VBELL_TIMEOUT) + term->in_vbell = FALSE; + } + + rv = (!term->rvideo ^ !term->in_vbell ? ATTR_REVERSE : 0); /* Depends on: * screen array, disptop, scrtop, * selection, rv, * cfg.blinkpc, blink_is_real, tblinker, - * curs.y, curs.x, blinker, cfg.blink_cur, cursor_on, has_focus + * curs.y, curs.x, blinker, cfg.blink_cur, cursor_on, has_focus, wrapnext */ - if (cursor_on) { - if (has_focus) { - if (blinker || !cfg.blink_cur) - cursor = ATTR_ACTCURS; - else - cursor = 0; - } - else - cursor = ATTR_PASCURS; - if (wrapnext) - cursor |= ATTR_RIGHTCURS; - } - else + + /* Has the cursor position or type changed ? */ + if (term->cursor_on) { + if (term->has_focus) { + if (term->blinker || !term->cfg.blink_cur) + cursor = TATTR_ACTCURS; + else + cursor = 0; + } else + cursor = TATTR_PASCURS; + if (term->wrapnext) + cursor |= TATTR_RIGHTCURS; + } else cursor = 0; - rv = (!rvideo ^ !in_vbell ? ATTR_REVERSE : 0); - our_curs_y = curs.y - disptop; + our_curs_y = term->curs.y - term->disptop; + { + /* + * Adjust the cursor position in the case where it's + * resting on the right-hand half of a CJK wide character. + * xterm's behaviour here, which seems adequate to me, is + * to display the cursor covering the _whole_ character, + * exactly as if it were one space to the left. + */ + unsigned long *ldata = lineptr(term->curs.y); + our_curs_x = term->curs.x; + if (our_curs_x > 0 && + (ldata[our_curs_x] & (CHAR_MASK | CSET_MASK)) == UCSWIDE) + our_curs_x--; + } + + if (term->dispcurs && (term->curstype != cursor || + term->dispcurs != + term->disptext + our_curs_y * (term->cols + 1) + + our_curs_x)) { + if (term->dispcurs > term->disptext && + (*term->dispcurs & (CHAR_MASK | CSET_MASK)) == UCSWIDE) + term->dispcurs[-1] |= ATTR_INVALID; + if ( (term->dispcurs[1] & (CHAR_MASK | CSET_MASK)) == UCSWIDE) + term->dispcurs[1] |= ATTR_INVALID; + *term->dispcurs |= ATTR_INVALID; + term->curstype = 0; + } + term->dispcurs = NULL; - for (i=0; irows; i++) { unsigned long *ldata; int lattr; - scrpos.y = i + disptop; + int idx, dirty_line, dirty_run, selected; + unsigned long attr = 0; + int updated_line = 0; + int start = 0; + int ccount = 0; + int last_run_dirty = 0; + + scrpos.y = i + term->disptop; ldata = lineptr(scrpos.y); - lattr = (ldata[cols] & LATTR_MODE); - for (j=0; j<=cols; j++) { - unsigned long d = ldata[j]; - int idx = i*(cols+1)+j; + lattr = (ldata[term->cols] & LATTR_MODE); + + idx = i * (term->cols + 1); + dirty_run = dirty_line = (ldata[term->cols] != + term->disptext[idx + term->cols]); + term->disptext[idx + term->cols] = ldata[term->cols]; + + for (j = 0; j < term->cols; j++, idx++) { + unsigned long tattr, tchar; + unsigned long *d = ldata + j; + int break_run; scrpos.x = j; - - wanttext[idx] = lattr | (((d &~ ATTR_WRAPPED) ^ rv - ^ (posle(selstart, scrpos) && - poslt(scrpos, selend) ? - ATTR_REVERSE : 0)) | - (i==our_curs_y && j==curs.x ? cursor : 0)); - if (blink_is_real) { - if (has_focus && tblinker && (wanttext[idx]&ATTR_BLINK) ) - { - wanttext[idx] &= ATTR_MASK; - wanttext[idx] += ' '; + + tchar = (*d & (CHAR_MASK | CSET_MASK)); + tattr = (*d & (ATTR_MASK ^ CSET_MASK)); + switch (tchar & CSET_MASK) { + case ATTR_ASCII: + tchar = term->ucsdata->unitab_line[tchar & 0xFF]; + break; + case ATTR_LINEDRW: + tchar = term->ucsdata->unitab_xterm[tchar & 0xFF]; + break; + case ATTR_SCOACS: + tchar = term->ucsdata->unitab_scoacs[tchar&0xFF]; + break; + } + tattr |= (tchar & CSET_MASK); + tchar &= CHAR_MASK; + if ((d[1] & (CHAR_MASK | CSET_MASK)) == UCSWIDE) + tattr |= ATTR_WIDE; + + /* Video reversing things */ + if (term->selstate == DRAGGING || term->selstate == SELECTED) { + if (term->seltype == LEXICOGRAPHIC) + selected = (posle(term->selstart, scrpos) && + poslt(scrpos, term->selend)); + else + selected = (posPle(term->selstart, scrpos) && + posPlt(scrpos, term->selend)); + } else + selected = FALSE; + tattr = (tattr ^ rv + ^ (selected ? ATTR_REVERSE : 0)); + + /* 'Real' blinking ? */ + if (term->blink_is_real && (tattr & ATTR_BLINK)) { + if (term->has_focus && term->tblinker) { + tchar = ' '; + tattr &= ~CSET_MASK; + tattr |= ATTR_ACP; } - wanttext[idx] &= ~ATTR_BLINK; + tattr &= ~ATTR_BLINK; } - } - } - /* - * We would perform scrolling optimisations in here, if they - * didn't have a nasty tendency to cause the whole sodding - * program to hang for a second at speed-critical moments. - * We'll leave it well alone... - */ + /* + * Check the font we'll _probably_ be using to see if + * the character is wide when we don't want it to be. + */ + if ((tchar | tattr) != (term->disptext[idx]& ~ATTR_NARROW)) { + if ((tattr & ATTR_WIDE) == 0 && + char_width(ctx, (tchar | tattr) & 0xFFFF) == 2) + tattr |= ATTR_NARROW; + } else if (term->disptext[idx]&ATTR_NARROW) + tattr |= ATTR_NARROW; + + /* Cursor here ? Save the 'background' */ + if (i == our_curs_y && j == our_curs_x) { + cursor_background = tattr | tchar; + term->dispcurs = term->disptext + idx; + } + + if ((term->disptext[idx] ^ tattr) & ATTR_WIDE) + dirty_line = TRUE; + + break_run = (((tattr ^ attr) & term->attr_mask) || + j - start >= sizeof(ch)); + + /* Special hack for VT100 Linedraw glyphs */ + if ((attr & CSET_MASK) == 0x2300 && tchar >= 0xBA + && tchar <= 0xBD) break_run = TRUE; - for (i=0; iucsdata->dbcs_screenfont && !dirty_line) { + if ((tchar | tattr) == term->disptext[idx]) + break_run = TRUE; + else if (!dirty_run && ccount == 1) + break_run = TRUE; } - if (needs_update) { - if (start == -1) { - start = j; - attr = t & ATTR_MASK; + + if (break_run) { + if ((dirty_run || last_run_dirty) && ccount > 0) { + do_text(ctx, start, i, ch, ccount, attr, lattr); + updated_line = 1; + } + start = j; + ccount = 0; + attr = tattr; + if (term->ucsdata->dbcs_screenfont) + last_run_dirty = dirty_run; + dirty_run = dirty_line; + } + + if ((tchar | tattr) != term->disptext[idx]) + dirty_run = TRUE; + ch[ccount++] = (char) tchar; + term->disptext[idx] = tchar | tattr; + + /* If it's a wide char step along to the next one. */ + if (tattr & ATTR_WIDE) { + if (++j < term->cols) { + idx++; + d++; + /* + * By construction above, the cursor should not + * be on the right-hand half of this character. + * Ever. + */ + assert(!(i == our_curs_y && j == our_curs_x)); + if (term->disptext[idx] != *d) + dirty_run = TRUE; + term->disptext[idx] = *d; } - ch[j-start] = (char) (t & CHAR_MASK); } - disptext[idx] = t; + } + if (dirty_run && ccount > 0) { + do_text(ctx, start, i, ch, ccount, attr, lattr); + updated_line = 1; + } + + /* Cursor on this line ? (and changed) */ + if (i == our_curs_y && (term->curstype != cursor || updated_line)) { + ch[0] = (char) (cursor_background & CHAR_MASK); + attr = (cursor_background & ATTR_MASK) | cursor; + do_cursor(ctx, our_curs_x, i, ch, 1, attr, lattr); + term->curstype = cursor; } } } @@ -2017,72 +3270,74 @@ static void do_paint (Context ctx, int may_optimise) { * Flick the switch that says if blinking things should be shown or hidden. */ -void term_blink(int flg) { - static long last_blink = 0; - static long last_tblink = 0; +void term_blink(Terminal *term, int flg) +{ long now, blink_diff; - now = GetTickCount(); - blink_diff = now-last_tblink; + now = GETTICKCOUNT(); + blink_diff = now - term->last_tblink; - /* Make sure the text blinks no more than 2Hz */ - if (blink_diff<0 || blink_diff>450) - { - last_tblink = now; - tblinker = !tblinker; + /* Make sure the text blinks no more than 2Hz; we'll use 0.45 s period. */ + if (blink_diff < 0 || blink_diff > (TICKSPERSEC * 9 / 20)) { + term->last_tblink = now; + term->tblinker = !term->tblinker; } if (flg) { - blinker = 1; - last_blink = now; + term->blinker = 1; + term->last_blink = now; return; - } + } - blink_diff = now-last_blink; + blink_diff = now - term->last_blink; - /* Make sure the cursor blinks no faster than GetCaretBlinkTime() */ - if (blink_diff>=0 && blink_diff<(long)GetCaretBlinkTime()) - return; - - last_blink = now; - blinker = !blinker; + /* Make sure the cursor blinks no faster than system blink rate */ + if (blink_diff >= 0 && blink_diff < (long) CURSORBLINK) + return; + + term->last_blink = now; + term->blinker = !term->blinker; } /* * Invalidate the whole screen so it will be repainted in full. */ -void term_invalidate(void) { +void term_invalidate(Terminal *term) +{ int i; - for (i=0; irows * (term->cols + 1); i++) + term->disptext[i] = ATTR_INVALID; } /* * Paint the window in response to a WM_PAINT message. */ -void term_paint (Context ctx, int l, int t, int r, int b) { - int i, j, left, top, right, bottom; - - left = l / font_width; - right = (r - 1) / font_width; - top = t / font_height; - bottom = (b - 1) / font_height; - for (i = top; i <= bottom && i < rows ; i++) - { - if ( (disptext[i*(cols+1)+cols]&LATTR_MODE) == LATTR_NORM) - for (j = left; j <= right && j < cols ; j++) - disptext[i*(cols+1)+j] = ATTR_INVALID; +void term_paint(Terminal *term, Context ctx, + int left, int top, int right, int bottom, int immediately) +{ + int i, j; + if (left < 0) left = 0; + if (top < 0) top = 0; + if (right >= term->cols) right = term->cols-1; + if (bottom >= term->rows) bottom = term->rows-1; + + for (i = top; i <= bottom && i < term->rows; i++) { + if ((term->disptext[i * (term->cols + 1) + term->cols] & + LATTR_MODE) == LATTR_NORM) + for (j = left; j <= right && j < term->cols; j++) + term->disptext[i * (term->cols + 1) + j] = ATTR_INVALID; else - for (j = left/2; j <= right/2+1 && j < cols ; j++) - disptext[i*(cols+1)+j] = ATTR_INVALID; + for (j = left / 2; j <= right / 2 + 1 && j < term->cols; j++) + term->disptext[i * (term->cols + 1) + j] = ATTR_INVALID; } /* This should happen soon enough, also for some reason it sometimes * fails to actually do anything when re-sizing ... painting the wrong * window perhaps ? - do_paint (ctx, FALSE); - */ + */ + if (immediately) + do_paint (term, ctx, FALSE); } /* @@ -2092,127 +3347,330 @@ void term_paint (Context ctx, int l, int t, int r, int b) { * to denote it is relative to the end, and 0 to denote that it is * relative to the current position. */ -void term_scroll (int rel, int where) { - int sbtop = -count234(scrollback); - - disptop = (rel < 0 ? 0 : - rel > 0 ? sbtop : disptop) + where; - if (disptop < sbtop) - disptop = sbtop; - if (disptop > 0) - disptop = 0; - update_sbar(); - term_update(); +void term_scroll(Terminal *term, int rel, int where) +{ + int sbtop = -count234(term->scrollback); +#ifdef OPTIMISE_SCROLL + int olddisptop = term->disptop; + int shift; +#endif /* OPTIMISE_SCROLL */ + + term->disptop = (rel < 0 ? 0 : rel > 0 ? sbtop : term->disptop) + where; + if (term->disptop < sbtop) + term->disptop = sbtop; + if (term->disptop > 0) + term->disptop = 0; + update_sbar(term); +#ifdef OPTIMISE_SCROLL + shift = (term->disptop - olddisptop); + if (shift < term->rows && shift > -term->rows) + scroll_display(term, 0, term->rows - 1, shift); +#endif /* OPTIMISE_SCROLL */ + term_update(term); } -static void clipme(pos top, pos bottom, char *workbuf) { - char *wbptr; /* where next char goes within workbuf */ - int wblen = 0; /* workbuf len */ - int buflen; /* amount of memory allocated to workbuf */ +static void clipme(Terminal *term, pos top, pos bottom, int rect) +{ + wchar_t *workbuf; + wchar_t *wbptr; /* where next char goes within workbuf */ + int old_top_x; + int wblen = 0; /* workbuf len */ + int buflen; /* amount of memory allocated to workbuf */ - if ( workbuf != NULL ) { /* user supplied buffer? */ - buflen = -1; /* assume buffer passed in is big enough */ - wbptr = workbuf; /* start filling here */ - } - else - buflen = 0; /* No data is available yet */ + buflen = 5120; /* Default size */ + workbuf = smalloc(buflen * sizeof(wchar_t)); + wbptr = workbuf; /* start filling here */ + old_top_x = top.x; /* needed for rect==1 */ while (poslt(top, bottom)) { int nl = FALSE; unsigned long *ldata = lineptr(top.y); pos nlpos; + /* + * nlpos will point at the maximum position on this line we + * should copy up to. So we start it at the end of the + * line... + */ nlpos.y = top.y; - nlpos.x = cols; + nlpos.x = term->cols; - if (!(ldata[cols] & ATTR_WRAPPED)) { - while ((ldata[nlpos.x-1] & CHAR_MASK) == 0x20 && poslt(top, nlpos)) + /* + * ... move it backwards if there's unused space at the end + * of the line (and also set `nl' if this is the case, + * because in normal selection mode this means we need a + * newline at the end)... + */ + if (!(ldata[term->cols] & LATTR_WRAPPED)) { + while (((ldata[nlpos.x - 1] & 0xFF) == 0x20 || + (DIRECT_CHAR(ldata[nlpos.x - 1]) && + (ldata[nlpos.x - 1] & CHAR_MASK) == 0x20)) + && poslt(top, nlpos)) decpos(nlpos); if (poslt(nlpos, bottom)) nl = TRUE; + } else if (ldata[term->cols] & LATTR_WRAPPED2) { + /* Ignore the last char on the line in a WRAPPED2 line. */ + decpos(nlpos); + } + + /* + * ... and then clip it to the terminal x coordinate if + * we're doing rectangular selection. (In this case we + * still did the above, so that copying e.g. the right-hand + * column from a table doesn't fill with spaces on the + * right.) + */ + if (rect) { + if (nlpos.x > bottom.x) + nlpos.x = bottom.x; + nl = (top.y < bottom.y); } + while (poslt(top, bottom) && poslt(top, nlpos)) { - int ch = (ldata[top.x] & CHAR_MASK); - int set = (ldata[top.x] & CSET_MASK); - - /* VT Specials -> ISO8859-1 for Cut&Paste */ - static const unsigned char poorman2[] = -"* # HTFFCRLF\xB0 \xB1 NLVT+ + + + + - - - - - + + + + | <=>=PI!=\xA3 \xB7 "; - - if (set && !cfg.rawcnp) { - if (set == ATTR_LINEDRW && ch >= 0x60 && ch < 0x7F) { - int x; - if ((x = poorman2[2*(ch-0x60)+1]) == ' ') - x = 0; - ch = (x<<8) + poorman2[2*(ch-0x60)]; - } +#if 0 + char cbuf[16], *p; + sprintf(cbuf, "", (ldata[top.x] & 0xFFFF)); +#else + wchar_t cbuf[16], *p; + int uc = (ldata[top.x] & 0xFFFF); + int set, c; + + if (uc == UCSWIDE) { + top.x++; + continue; } - while(ch != 0) { - if (cfg.rawcnp || !!(ch&0xE0)) { - if ( wblen == buflen ) - { - workbuf = srealloc(workbuf, buflen += 100); - wbptr = workbuf + wblen; + switch (uc & CSET_MASK) { + case ATTR_LINEDRW: + if (!term->cfg.rawcnp) { + uc = term->ucsdata->unitab_xterm[uc & 0xFF]; + break; + } + case ATTR_ASCII: + uc = term->ucsdata->unitab_line[uc & 0xFF]; + break; + case ATTR_SCOACS: + uc = term->ucsdata->unitab_scoacs[uc&0xFF]; + break; + } + switch (uc & CSET_MASK) { + case ATTR_ACP: + uc = term->ucsdata->unitab_font[uc & 0xFF]; + break; + case ATTR_OEMCP: + uc = term->ucsdata->unitab_oemcp[uc & 0xFF]; + break; + } + + set = (uc & CSET_MASK); + c = (uc & CHAR_MASK); + cbuf[0] = uc; + cbuf[1] = 0; + + if (DIRECT_FONT(uc)) { + if (c >= ' ' && c != 0x7F) { + char buf[4]; + WCHAR wbuf[4]; + int rv; + if (is_dbcs_leadbyte(term->ucsdata->font_codepage, (BYTE) c)) { + buf[0] = c; + buf[1] = (char) (0xFF & ldata[top.x + 1]); + rv = mb_to_wc(term->ucsdata->font_codepage, 0, buf, 2, wbuf, 4); + top.x++; + } else { + buf[0] = c; + rv = mb_to_wc(term->ucsdata->font_codepage, 0, buf, 1, wbuf, 4); + } + + if (rv > 0) { + memcpy(cbuf, wbuf, rv * sizeof(wchar_t)); + cbuf[rv] = 0; } - wblen++; - *wbptr++ = (unsigned char) ch; } - ch>>=8; + } +#endif + + for (p = cbuf; *p; p++) { + /* Enough overhead for trailing NL and nul */ + if (wblen >= buflen - 16) { + workbuf = + srealloc(workbuf, + sizeof(wchar_t) * (buflen += 100)); + wbptr = workbuf + wblen; + } + wblen++; + *wbptr++ = *p; } top.x++; } if (nl) { int i; - for (i=0; i 0 ) /* indicates we allocated this buffer */ +#if SELECTION_NUL_TERMINATED + wblen++; + *wbptr++ = 0; +#endif + write_clip(term->frontend, workbuf, wblen, FALSE); /* transfer to clipbd */ + if (buflen > 0) /* indicates we allocated this buffer */ sfree(workbuf); - } -void term_copyall (void) { + +void term_copyall(Terminal *term) +{ pos top; - top.y = -count234(scrollback); + top.y = -count234(term->scrollback); top.x = 0; - clipme(top, curs, NULL /* dynamic allocation */); + clipme(term, top, term->curs, 0); +} + +/* + * The wordness array is mainly for deciding the disposition of the + * US-ASCII characters. + */ +static int wordtype(Terminal *term, int uc) +{ + struct ucsword { + int start, end, ctype; + }; + static const struct ucsword ucs_words[] = { + { + 128, 160, 0}, { + 161, 191, 1}, { + 215, 215, 1}, { + 247, 247, 1}, { + 0x037e, 0x037e, 1}, /* Greek question mark */ + { + 0x0387, 0x0387, 1}, /* Greek ano teleia */ + { + 0x055a, 0x055f, 1}, /* Armenian punctuation */ + { + 0x0589, 0x0589, 1}, /* Armenian full stop */ + { + 0x0700, 0x070d, 1}, /* Syriac punctuation */ + { + 0x104a, 0x104f, 1}, /* Myanmar punctuation */ + { + 0x10fb, 0x10fb, 1}, /* Georgian punctuation */ + { + 0x1361, 0x1368, 1}, /* Ethiopic punctuation */ + { + 0x166d, 0x166e, 1}, /* Canadian Syl. punctuation */ + { + 0x17d4, 0x17dc, 1}, /* Khmer punctuation */ + { + 0x1800, 0x180a, 1}, /* Mongolian punctuation */ + { + 0x2000, 0x200a, 0}, /* Various spaces */ + { + 0x2070, 0x207f, 2}, /* superscript */ + { + 0x2080, 0x208f, 2}, /* subscript */ + { + 0x200b, 0x27ff, 1}, /* punctuation and symbols */ + { + 0x3000, 0x3000, 0}, /* ideographic space */ + { + 0x3001, 0x3020, 1}, /* ideographic punctuation */ + { + 0x303f, 0x309f, 3}, /* Hiragana */ + { + 0x30a0, 0x30ff, 3}, /* Katakana */ + { + 0x3300, 0x9fff, 3}, /* CJK Ideographs */ + { + 0xac00, 0xd7a3, 3}, /* Hangul Syllables */ + { + 0xf900, 0xfaff, 3}, /* CJK Ideographs */ + { + 0xfe30, 0xfe6b, 1}, /* punctuation forms */ + { + 0xff00, 0xff0f, 1}, /* half/fullwidth ASCII */ + { + 0xff1a, 0xff20, 1}, /* half/fullwidth ASCII */ + { + 0xff3b, 0xff40, 1}, /* half/fullwidth ASCII */ + { + 0xff5b, 0xff64, 1}, /* half/fullwidth ASCII */ + { + 0xfff0, 0xffff, 0}, /* half/fullwidth ASCII */ + { + 0, 0, 0} + }; + const struct ucsword *wptr; + + uc &= (CSET_MASK | CHAR_MASK); + + switch (uc & CSET_MASK) { + case ATTR_LINEDRW: + uc = term->ucsdata->unitab_xterm[uc & 0xFF]; + break; + case ATTR_ASCII: + uc = term->ucsdata->unitab_line[uc & 0xFF]; + break; + case ATTR_SCOACS: + uc = term->ucsdata->unitab_scoacs[uc&0xFF]; + break; + } + switch (uc & CSET_MASK) { + case ATTR_ACP: + uc = term->ucsdata->unitab_font[uc & 0xFF]; + break; + case ATTR_OEMCP: + uc = term->ucsdata->unitab_oemcp[uc & 0xFF]; + break; + } + + /* For DBCS font's I can't do anything usefull. Even this will sometimes + * fail as there's such a thing as a double width space. :-( + */ + if (term->ucsdata->dbcs_screenfont && + term->ucsdata->font_codepage == term->ucsdata->line_codepage) + return (uc != ' '); + + if (uc < 0x80) + return term->wordness[uc]; + + for (wptr = ucs_words; wptr->start; wptr++) { + if (uc >= wptr->start && uc <= wptr->end) + return wptr->ctype; + } + + return 2; } /* * Spread the selection outwards according to the selection mode. */ -static pos sel_spread_half (pos p, int dir) { +static pos sel_spread_half(Terminal *term, pos p, int dir) +{ unsigned long *ldata; short wvalue; + int topy = -count234(term->scrollback); ldata = lineptr(p.y); - switch (selmode) { + switch (term->selmode) { case SM_CHAR: /* * In this mode, every character is a separate unit, except * for runs of spaces at the end of a non-wrapping line. */ - if (!(ldata[cols] & ATTR_WRAPPED)) { - unsigned long *q = ldata+cols; + if (!(ldata[term->cols] & LATTR_WRAPPED)) { + unsigned long *q = ldata + term->cols; while (q > ldata && (q[-1] & CHAR_MASK) == 0x20) q--; - if (q == ldata+cols) + if (q == ldata + term->cols) q--; - if (p.x >= q-ldata) - p.x = (dir == -1 ? q-ldata : cols - 1); + if (p.x >= q - ldata) + p.x = (dir == -1 ? q - ldata : term->cols - 1); } break; case SM_WORD: @@ -2220,280 +3678,442 @@ static pos sel_spread_half (pos p, int dir) { * In this mode, the units are maximal runs of characters * whose `wordness' has the same value. */ - wvalue = wordness[ldata[p.x] & CHAR_MASK]; + wvalue = wordtype(term, UCSGET(ldata, p.x)); if (dir == +1) { - while (p.x < cols && wordness[ldata[p.x+1] & CHAR_MASK] == wvalue) - p.x++; + while (1) { + int maxcols = (ldata[term->cols] & LATTR_WRAPPED2 ? + term->cols-1 : term->cols); + if (p.x < maxcols-1) { + if (wordtype(term, UCSGET(ldata, p.x + 1)) == wvalue) + p.x++; + else + break; + } else { + if (ldata[term->cols] & LATTR_WRAPPED) { + unsigned long *ldata2; + ldata2 = lineptr(p.y+1); + if (wordtype(term, UCSGET(ldata2, 0)) == wvalue) { + p.x = 0; + p.y++; + ldata = ldata2; + } else + break; + } else + break; + } + } } else { - while (p.x > 0 && wordness[ldata[p.x-1] & CHAR_MASK] == wvalue) - p.x--; + while (1) { + if (p.x > 0) { + if (wordtype(term, UCSGET(ldata, p.x - 1)) == wvalue) + p.x--; + else + break; + } else { + unsigned long *ldata2; + int maxcols; + if (p.y <= topy) + break; + ldata2 = lineptr(p.y-1); + maxcols = (ldata2[term->cols] & LATTR_WRAPPED2 ? + term->cols-1 : term->cols); + if (ldata2[term->cols] & LATTR_WRAPPED) { + if (wordtype(term, UCSGET(ldata2, maxcols-1)) + == wvalue) { + p.x = maxcols-1; + p.y--; + ldata = ldata2; + } else + break; + } else + break; + } + } } break; case SM_LINE: /* * In this mode, every line is a unit. */ - p.x = (dir == -1 ? 0 : cols - 1); + p.x = (dir == -1 ? 0 : term->cols - 1); break; } return p; } -static void sel_spread (void) { - selstart = sel_spread_half (selstart, -1); - decpos(selend); - selend = sel_spread_half (selend, +1); - incpos(selend); +static void sel_spread(Terminal *term) +{ + if (term->seltype == LEXICOGRAPHIC) { + term->selstart = sel_spread_half(term, term->selstart, -1); + decpos(term->selend); + term->selend = sel_spread_half(term, term->selend, +1); + incpos(term->selend); + } +} + +void term_do_paste(Terminal *term) +{ + wchar_t *data; + int len; + + get_clip(term->frontend, &data, &len); + if (data && len > 0) { + wchar_t *p, *q; + + term_seen_key_event(term); /* pasted data counts */ + + if (term->paste_buffer) + sfree(term->paste_buffer); + term->paste_pos = term->paste_hold = term->paste_len = 0; + term->paste_buffer = smalloc(len * sizeof(wchar_t)); + + p = q = data; + while (p < data + len) { + while (p < data + len && + !(p <= data + len - sel_nl_sz && + !memcmp(p, sel_nl, sizeof(sel_nl)))) + p++; + + { + int i; + for (i = 0; i < p - q; i++) { + term->paste_buffer[term->paste_len++] = q[i]; + } + } + + if (p <= data + len - sel_nl_sz && + !memcmp(p, sel_nl, sizeof(sel_nl))) { + term->paste_buffer[term->paste_len++] = '\015'; + p += sel_nl_sz; + } + q = p; + } + + /* Assume a small paste will be OK in one go. */ + if (term->paste_len < 256) { + if (term->ldisc) + luni_send(term->ldisc, term->paste_buffer, term->paste_len, 0); + if (term->paste_buffer) + sfree(term->paste_buffer); + term->paste_buffer = 0; + term->paste_pos = term->paste_hold = term->paste_len = 0; + } + } + get_clip(term->frontend, NULL, NULL); } -void term_mouse (Mouse_Button b, Mouse_Action a, int x, int y) { +void term_mouse(Terminal *term, Mouse_Button b, Mouse_Action a, int x, int y, + int shift, int ctrl, int alt) +{ pos selpoint; unsigned long *ldata; - - if (y<0) y = 0; - if (y>=rows) y = rows-1; - if (x<0) { - if (y > 0) { - x = cols-1; - y--; - } else - x = 0; + int raw_mouse = (term->xterm_mouse && + !term->cfg.no_mouse_rep && + !(term->cfg.mouse_override && shift)); + int default_seltype; + + if (y < 0) { + y = 0; + if (a == MA_DRAG && !raw_mouse) + term_scroll(term, 0, -1); } - if (x>=cols) x = cols-1; + if (y >= term->rows) { + y = term->rows - 1; + if (a == MA_DRAG && !raw_mouse) + term_scroll(term, 0, +1); + } + if (x < 0) { + if (y > 0) { + x = term->cols - 1; + y--; + } else + x = 0; + } + if (x >= term->cols) + x = term->cols - 1; - selpoint.y = y + disptop; + selpoint.y = y + term->disptop; selpoint.x = x; ldata = lineptr(selpoint.y); - if ((ldata[cols]&LATTR_MODE) != LATTR_NORM) + if ((ldata[term->cols] & LATTR_MODE) != LATTR_NORM) selpoint.x /= 2; - if (b == MB_SELECT && a == MA_CLICK) { - deselect(); - selstate = ABOUT_TO; - selanchor = selpoint; - selmode = SM_CHAR; - } else if (b == MB_SELECT && (a == MA_2CLK || a == MA_3CLK)) { - deselect(); - selmode = (a == MA_2CLK ? SM_WORD : SM_LINE); - selstate = DRAGGING; - selstart = selanchor = selpoint; - selend = selstart; - incpos(selend); - sel_spread(); - } else if ((b == MB_SELECT && a == MA_DRAG) || - (b == MB_EXTEND && a != MA_RELEASE)) { - if (selstate == ABOUT_TO && poseq(selanchor, selpoint)) + if (raw_mouse) { + int encstate = 0, r, c; + char abuf[16]; + + if (term->ldisc) { + + switch (b) { + case MBT_LEFT: + encstate = 0x20; /* left button down */ + break; + case MBT_MIDDLE: + encstate = 0x21; + break; + case MBT_RIGHT: + encstate = 0x22; + break; + case MBT_WHEEL_UP: + encstate = 0x60; + break; + case MBT_WHEEL_DOWN: + encstate = 0x61; + break; + default: break; /* placate gcc warning about enum use */ + } + switch (a) { + case MA_DRAG: + if (term->xterm_mouse == 1) + return; + encstate += 0x20; + break; + case MA_RELEASE: + encstate = 0x23; + term->mouse_is_down = 0; + break; + case MA_CLICK: + if (term->mouse_is_down == b) + return; + term->mouse_is_down = b; + break; + default: break; /* placate gcc warning about enum use */ + } + if (shift) + encstate += 0x04; + if (ctrl) + encstate += 0x10; + r = y + 33; + c = x + 33; + + sprintf(abuf, "\033[M%c%c%c", encstate, c, r); + ldisc_send(term->ldisc, abuf, 6, 0); + } + return; + } + + b = translate_button(term->frontend, b); + + /* + * Set the selection type (rectangular or normal) at the start + * of a selection attempt, from the state of Alt. + */ + if (!alt ^ !term->cfg.rect_select) + default_seltype = RECTANGULAR; + else + default_seltype = LEXICOGRAPHIC; + + if (term->selstate == NO_SELECTION) { + term->seltype = default_seltype; + } + + if (b == MBT_SELECT && a == MA_CLICK) { + deselect(term); + term->selstate = ABOUT_TO; + term->seltype = default_seltype; + term->selanchor = selpoint; + term->selmode = SM_CHAR; + } else if (b == MBT_SELECT && (a == MA_2CLK || a == MA_3CLK)) { + deselect(term); + term->selmode = (a == MA_2CLK ? SM_WORD : SM_LINE); + term->selstate = DRAGGING; + term->selstart = term->selanchor = selpoint; + term->selend = term->selstart; + incpos(term->selend); + sel_spread(term); + } else if ((b == MBT_SELECT && a == MA_DRAG) || + (b == MBT_EXTEND && a != MA_RELEASE)) { + if (term->selstate == ABOUT_TO && poseq(term->selanchor, selpoint)) return; - if (b == MB_EXTEND && a != MA_DRAG && selstate == SELECTED) { - if (posdiff(selpoint,selstart) < posdiff(selend,selstart)/2) { - selanchor = selend; - decpos(selanchor); + if (b == MBT_EXTEND && a != MA_DRAG && term->selstate == SELECTED) { + if (term->seltype == LEXICOGRAPHIC) { + /* + * For normal selection, we extend by moving + * whichever end of the current selection is closer + * to the mouse. + */ + if (posdiff(selpoint, term->selstart) < + posdiff(term->selend, term->selstart) / 2) { + term->selanchor = term->selend; + decpos(term->selanchor); + } else { + term->selanchor = term->selstart; + } } else { - selanchor = selstart; + /* + * For rectangular selection, we have a choice of + * _four_ places to put selanchor and selpoint: the + * four corners of the selection. + */ + if (2*selpoint.x < term->selstart.x + term->selend.x) + term->selanchor.x = term->selend.x-1; + else + term->selanchor.x = term->selstart.x; + + if (2*selpoint.y < term->selstart.y + term->selend.y) + term->selanchor.y = term->selend.y; + else + term->selanchor.y = term->selstart.y; } - selstate = DRAGGING; + term->selstate = DRAGGING; } - if (selstate != ABOUT_TO && selstate != DRAGGING) - selanchor = selpoint; - selstate = DRAGGING; - if (poslt(selpoint, selanchor)) { - selstart = selpoint; - selend = selanchor; - incpos(selend); + if (term->selstate != ABOUT_TO && term->selstate != DRAGGING) + term->selanchor = selpoint; + term->selstate = DRAGGING; + if (term->seltype == LEXICOGRAPHIC) { + /* + * For normal selection, we set (selstart,selend) to + * (selpoint,selanchor) in some order. + */ + if (poslt(selpoint, term->selanchor)) { + term->selstart = selpoint; + term->selend = term->selanchor; + incpos(term->selend); + } else { + term->selstart = term->selanchor; + term->selend = selpoint; + incpos(term->selend); + } } else { - selstart = selanchor; - selend = selpoint; - incpos(selend); + /* + * For rectangular selection, we may need to + * interchange x and y coordinates (if the user has + * dragged in the -x and +y directions, or vice versa). + */ + term->selstart.x = min(term->selanchor.x, selpoint.x); + term->selend.x = 1+max(term->selanchor.x, selpoint.x); + term->selstart.y = min(term->selanchor.y, selpoint.y); + term->selend.y = max(term->selanchor.y, selpoint.y); } - sel_spread(); - } else if ((b == MB_SELECT || b == MB_EXTEND) && a == MA_RELEASE) { - if (selstate == DRAGGING) { + sel_spread(term); + } else if ((b == MBT_SELECT || b == MBT_EXTEND) && a == MA_RELEASE) { + if (term->selstate == DRAGGING) { /* * We've completed a selection. We now transfer the * data to the clipboard. */ - clipme(selstart, selend, selspace); - selstate = SELECTED; + clipme(term, term->selstart, term->selend, + (term->seltype == RECTANGULAR)); + term->selstate = SELECTED; } else - selstate = NO_SELECTION; - } else if (b == MB_PASTE && (a==MA_CLICK || a==MA_2CLK || a==MA_3CLK)) { - char *data; - int len; - - get_clip((void **) &data, &len); - if (data) { - char *p, *q; - - if (paste_buffer) sfree(paste_buffer); - paste_pos = paste_hold = paste_len = 0; - paste_buffer = smalloc(len); - - p = q = data; - while (p < data+len) { - while (p < data+len && - !(p <= data+len-sizeof(sel_nl) && - !memcmp(p, sel_nl, sizeof(sel_nl)))) - p++; - - { - int i; - unsigned char c; - for(i=0;iselstate = NO_SELECTION; + } else if (b == MBT_PASTE + && (a == MA_CLICK +#if MULTICLICK_ONLY_EVENT + || a == MA_2CLK || a == MA_3CLK +#endif + )) { + request_paste(term->frontend); } - term_update(); + term_update(term); } -void term_nopaste() { - if(paste_len == 0) return; - sfree(paste_buffer); - paste_buffer = 0; - paste_len = 0; +void term_nopaste(Terminal *term) +{ + if (term->paste_len == 0) + return; + sfree(term->paste_buffer); + term->paste_buffer = NULL; + term->paste_len = 0; +} + +int term_paste_pending(Terminal *term) +{ + return term->paste_len != 0; } -void term_paste() { - static long last_paste = 0; +void term_paste(Terminal *term) +{ long now, paste_diff; - if(paste_len == 0) return; + if (term->paste_len == 0) + return; /* Don't wait forever to paste */ - if(paste_hold) { - now = GetTickCount(); - paste_diff = now-last_paste; - if (paste_diff>=0 && paste_diff<450) + if (term->paste_hold) { + now = GETTICKCOUNT(); + paste_diff = now - term->last_paste; + if (paste_diff >= 0 && paste_diff < 450) return; } - paste_hold = 0; + term->paste_hold = 0; - while(paste_pospaste_pos < term->paste_len) { int n = 0; - while (n + paste_pos < paste_len) { - if (paste_buffer[paste_pos + n++] == '\r') + while (n + term->paste_pos < term->paste_len) { + if (term->paste_buffer[term->paste_pos + n++] == '\015') break; } - ldisc_send (paste_buffer+paste_pos, n); - paste_pos += n; + if (term->ldisc) + luni_send(term->ldisc, term->paste_buffer + term->paste_pos, n, 0); + term->paste_pos += n; - if (paste_pos < paste_len) { - paste_hold = 1; + if (term->paste_pos < term->paste_len) { + term->paste_hold = 1; return; } } - sfree(paste_buffer); - paste_buffer = 0; - paste_len = 0; + sfree(term->paste_buffer); + term->paste_buffer = NULL; + term->paste_len = 0; } -static void deselect (void) { - selstate = NO_SELECTION; - selstart.x = selstart.y = selend.x = selend.y = 0; +static void deselect(Terminal *term) +{ + term->selstate = NO_SELECTION; + term->selstart.x = term->selstart.y = term->selend.x = term->selend.y = 0; } -void term_deselect (void) { - deselect(); - term_update(); +void term_deselect(Terminal *term) +{ + deselect(term); + term_update(term); } -int term_ldisc(int option) { - if (option == LD_ECHO) return term_echoing; - if (option == LD_EDIT) return term_editing; +int term_ldisc(Terminal *term, int option) +{ + if (option == LD_ECHO) + return term->term_echoing; + if (option == LD_EDIT) + return term->term_editing; return FALSE; } /* * from_backend(), to get data from the backend for the terminal. */ -void from_backend(int is_stderr, char *data, int len) { - while (len--) { - if (inbuf_head >= INBUF_SIZE) - term_out(); - inbuf[inbuf_head++] = *data++; - } -} - -/* - * Log session traffic. - */ -void logtraffic(unsigned char c, int logmode) { - if (cfg.logtype > 0) { - if (cfg.logtype == logmode) { - /* deferred open file from pgm start? */ - if (!lgfp) logfopen(); - if (lgfp) fputc (c, lgfp); - } - } -} +int from_backend(void *vterm, int is_stderr, char *data, int len) +{ + Terminal *term = (Terminal *)vterm; -/* open log file append/overwrite mode */ -void logfopen(void) { - char buf[256]; - time_t t; - struct tm *tm; - char writemod[4]; + assert(len > 0); - if (!cfg.logtype) - return; - sprintf (writemod, "wb"); /* default to rewrite */ - lgfp = fopen(cfg.logfilename, "r"); /* file already present? */ - if (lgfp) { - int i; - fclose(lgfp); - i = askappend(cfg.logfilename); - if (i == 1) - writemod[0] = 'a'; /* set append mode */ - else if (i == 0) { /* cancelled */ - lgfp = NULL; - cfg.logtype = 0; /* disable logging */ - return; - } - } + bufchain_add(&term->inbuf, data, len); - lgfp = fopen(cfg.logfilename, writemod); - if (lgfp) { /* enter into event log */ - sprintf(buf, "%s session log (%s mode) to file : ", - (writemod[0] == 'a') ? "Appending" : "Writing new", - (cfg.logtype == LGTYP_ASCII ? "ASCII" : - cfg.logtype == LGTYP_DEBUG ? "raw" : "") ); - /* Make sure we do not exceed the output buffer size */ - strncat (buf, cfg.logfilename, 128); - buf[strlen(buf)] = '\0'; - logevent(buf); - - /* --- write header line iinto log file */ - fputs ("=~=~=~=~=~=~=~=~=~=~=~= PuTTY log ", lgfp); - time(&t); - tm = localtime(&t); - strftime(buf, 24, "%Y.%m.%d %H:%M:%S", tm); - fputs (buf, lgfp); - fputs (" =~=~=~=~=~=~=~=~=~=~=~=\r\n", lgfp); - } + /* + * term_out() always completely empties inbuf. Therefore, + * there's no reason at all to return anything other than zero + * from this function, because there _can't_ be a question of + * the remote side needing to wait until term_out() has cleared + * a backlog. + * + * This is a slightly suboptimal way to deal with SSH2 - in + * principle, the window mechanism would allow us to continue + * to accept data on forwarded ports and X connections even + * while the terminal processing was going slowly - but we + * can't do the 100% right thing without moving the terminal + * processing into a separate thread, and that might hurt + * portability. So we manage stdout buffering the old SSH1 way: + * if the terminal processing goes slowly, the whole SSH + * connection stops accepting data until it's ready. + * + * In practice, I can't imagine this causing serious trouble. + */ + return 0; } -void logfclose (void) { - if (lgfp) { fclose(lgfp); lgfp = NULL; } +void term_provide_logctx(Terminal *term, void *logctx) +{ + term->logctx = logctx; }