X-Git-Url: https://git.distorted.org.uk/u/mdw/putty/blobdiff_plain/c723efc770478b91dfe153cabbcd3aeef9934073..ff89646a8828ce862d53b96a19ee6469dabce71a:/terminal.c diff --git a/terminal.c b/terminal.c index 4ecb39c6..95bd89f6 100644 --- a/terminal.c +++ b/terminal.c @@ -2,27 +2,91 @@ #include #include +#include +#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 */ + +#define TM_VT100 (CL_ANSIMIN|CL_VT100) +#define TM_VT100AVO (TM_VT100|CL_VT100AVO) +#define TM_VT102 (TM_VT100AVO|CL_VT102) +#define TM_VT220 (TM_VT102|CL_VT220) +#define TM_VTXXX (TM_VT220|CL_VT340TEXT|CL_VT510|CL_VT420|CL_VT320) +#define TM_SCOANSI (CL_ANSIMIN|CL_SCOANSI) + +#define TM_PUTTY (0xFFFF) + +#define compatibility(x) \ + if ( ((CL_##x)&compatibility_level) == 0 ) { \ + termstate=TOPLEVEL; \ + break; \ + } +#define compatibility2(x,y) \ + if ( ((CL_##x|CL_##y)&compatibility_level) == 0 ) { \ + 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 *text; /* buffer of text on terminal screen */ -static unsigned long *scrtop; /* top of working screen */ -static unsigned long *disptop; /* top of displayed screen */ -static unsigned long *sbtop; /* top of scrollback */ static unsigned long *cpos; /* cursor position (convenience) */ + static unsigned long *disptext; /* buffer of text on real screen */ static unsigned long *wanttext; /* buffer of text we want on screen */ -static unsigned long *alttext; /* buffer of text on alt. 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(*text)) -#define fix_cpos do { cpos = scrtop + curs_y * (cols+1) + curs_x; } while(0) +#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 int curs_x, curs_y; /* cursor */ -static int save_x, save_y; /* saved cursor position */ +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 */ @@ -30,6 +94,15 @@ 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]; @@ -41,29 +114,40 @@ static int alt_t, alt_b; static int alt_which; #define ARGS_MAX 32 /* max # of esc sequence arguments */ -#define ARG_DEFAULT -1 /* if an arg isn't specified */ +#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 unsigned char *tabs; - -#define MAXNL 5 -static int nl_count; +static char id_string[1024] = "\033[?6c"; -static int scroll_heuristic; +static unsigned char *tabs; static enum { - TOPLEVEL, IGNORE_NEXT, - SEEN_ESC, SEEN_CSI, SET_GL, SET_GR, - SEEN_OSC, SEEN_OSC_P, SEEN_OSC_W, OSC_STRING, OSC_MAYBE_ST, - SEEN_ESCHASH + 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 { @@ -72,7 +156,7 @@ static enum { static enum { SM_CHAR, SM_WORD, SM_LINE } selmode; -static unsigned long *selstart, *selend, *selanchor; +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 */ @@ -86,6 +170,8 @@ static short wordness[256] = { }; static unsigned char sel_nl[] = SEL_NL; +static char * paste_buffer = 0; +static int paste_len, paste_pos, paste_hold; /* * Internal prototypes. @@ -95,12 +181,56 @@ 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); /* + * 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; + tree234 *whichtree; + int i, treeindex, oldlen; + + if (y >= 0) { + whichtree = screen; + treeindex = y; + } else { + whichtree = scrollback; + treeindex = y + count234(scrollback); + } + line = index234(whichtree, treeindex); + + /* We assume that we don't screw up and retrieve something out of range. */ + 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]; + 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); + } + + return line+1; +} +#define lineptr(x) lineptr(x,__LINE__) +/* * Set up power-on settings for the terminal. */ static void power_on(void) { - curs_x = curs_y = alt_x = alt_y = save_x = save_y = 0; + 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; @@ -117,16 +247,23 @@ static void power_on(void) { 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; { int i; for (i = 0; i < 256; i++) wordness[i] = cfg.wordness[i]; } - if (text) { + if (screen) { swap_screen (1); erase_lots (FALSE, TRUE, TRUE); swap_screen (0); @@ -141,10 +278,15 @@ void term_update(void) { Context ctx; ctx = get_ctx(); 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(); + } do_paint (ctx, TRUE); + sys_cursor(curs.x, curs.y - disptop); free_ctx (ctx); - nl_count = 0; - scroll_heuristic = 0; } } @@ -154,7 +296,7 @@ void term_update(void) { void term_pwron(void) { power_on(); fix_cpos; - disptop = scrtop; + disptop = 0; deselect(); term_update(); } @@ -163,7 +305,11 @@ void term_pwron(void) { * Clear the scrollback. */ void term_clrsb(void) { - disptop = sbtop = scrtop; + unsigned long *line; + disptop = 0; + while ((line = delpos234(scrollback, 0)) != NULL) { + sfree(line); + } update_sbar(); } @@ -171,54 +317,92 @@ void term_clrsb(void) { * Initialise the terminal. */ void term_init(void) { - text = sbtop = scrtop = disptop = cpos = NULL; + screen = alt_screen = scrollback = NULL; + disptop = 0; disptext = wanttext = NULL; tabs = NULL; selspace = NULL; deselect(); rows = cols = -1; - nl_count = 0; power_on(); + beephead = beeptail = NULL; + nbeeps = 0; + lastbeep = FALSE; + beep_overloaded = FALSE; } /* * Set up the terminal for a given size. */ void term_size(int newrows, int newcols, int newsavelines) { - unsigned long *newtext, *newdisp, *newwant, *newalt; - int i, j, crows, ccols; + tree234 *newsb, *newscreen, *newalt; + unsigned long *newdisp, *newwant, *oldline, *line; + int i, j, ccols; + int sblen; + int save_alt_which = alt_which; if (newrows == rows && newcols == cols && newsavelines == savelines) return; /* nothing to do */ + deselect(); + swap_screen(0); + alt_t = marg_t = 0; alt_b = marg_b = newrows - 1; - newtext = smalloc ((newrows+newsavelines)*(newcols+1)*TSIZE); - disptop = newtext + newsavelines*(newcols+1); - for (i=0; i<(newrows+newsavelines)*(newcols+1); i++) - newtext[i] = ERASE_CHAR; - if (rows != -1) { - crows = rows + (scrtop - sbtop) / (cols+1); - if (crows > newrows+newsavelines) - crows = newrows+newsavelines; - ccols = (cols < newcols ? cols : newcols); - for (i=0; i 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); } - sbtop = disptop - (crows - newrows) * (newcols+1); - if (sbtop > disptop) - sbtop = disptop; - } else - sbtop = disptop; - scrtop = disptop; - sfree (text); - text = newtext; + } else if (newrows < rows) { + for (i = newrows; i < rows; i++) { + line = delpos234(screen, 0); + addpos234(scrollback, line, sblen++); + } + } + assert(count234(screen) == newrows); + while (sblen > newsavelines) { + line = delpos234(scrollback, 0); + sfree(line); + sblen--; + } + assert(count234(scrollback) <= newsavelines); + disptop = 0; newdisp = smalloc (newrows*(newcols+1)*TSIZE); for (i=0; i 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; + 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; @@ -264,7 +457,8 @@ void term_size(int newrows, int newcols, int newsavelines) { savelines = newsavelines; fix_cpos; - deselect(); + swap_screen(save_alt_which); + update_sbar(); term_update(); } @@ -274,19 +468,16 @@ void term_size(int newrows, int newcols, int newsavelines) { */ static void swap_screen (int which) { int t; - unsigned long tt; + tree234 *ttr; if (which == alt_which) return; alt_which = which; - for (t=0; t 0 && topline == 0 && botline == (rows-1) && sb) { - /* - * Since we're going to scroll the whole screen upwards, - * let's also affect the scrollback buffer. - */ - sbtop -= lines * (cols+1); - if (sbtop < text) - sbtop = text; - scroll_size += scroll_top - sbtop; - scroll_top = sbtop; - update_sbar(); - } + unsigned long *line, *line2; + int i; - if (scroll_size < 0) { - size += scroll_size; - scroll_size = 0; - } + if (topline != 0 || alt_which != 0) + sb = FALSE; + + 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; + } + } + if (selend.y >= topline && selend.y <= botline) { + selend.y++; + if (selend.y > botline) { + selend.y = botline; + selend.x = 0; + } + } - if (lines > 0) { - if (scroll_size) - memmove (scroll_top, scroll_top + size, scroll_size*TSIZE); - for (i = 0; i < size; i++) - scroll_top[i+scroll_size] = ERASE_CHAR; - if (selstart > scroll_top && - selstart < scroll_top + size + scroll_size) { - selstart -= size; - if (selstart < scroll_top) - selstart = scroll_top; - } - if (selend > scroll_top && - selend < scroll_top + size + scroll_size) { - selend -= size; - if (selend < scroll_top) - selend = scroll_top; + lines++; } } else { - if (scroll_size) - memmove (scroll_top + size, scroll_top, scroll_size*TSIZE); - for (i = 0; i < size; i++) - scroll_top[i] = ERASE_CHAR; - if (selstart > scroll_top && - selstart < scroll_top + size + scroll_size) { - selstart += size; - if (selstart > scroll_top + size + scroll_size) - selstart = scroll_top + size + scroll_size; - } - if (selend > scroll_top && - selend < scroll_top + size + scroll_size) { - selend += size; - if (selend > scroll_top + size + scroll_size) - selend = scroll_top + size + scroll_size; + while (lines > 0) { + line = delpos234(screen, topline); + if (sb && savelines > 0) { + int sblen = count234(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); + } else { + line2 = smalloc(TSIZE * (cols+2)); + line2[0] = cols; + } + addpos234(scrollback, line, sblen); + line = line2; + } + 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 (selend.y >= topline && selend.y <= botline) { + selend.y--; + if (selend.y < topline) { + selend.y = topline; + selend.x = 0; + } + } + + lines--; } } - - scroll_heuristic += lines; } /* @@ -414,17 +608,17 @@ static void move (int x, int y, int marg_clip) { if (x >= cols) x = cols-1; if (marg_clip) { - if ((curs_y >= marg_t || marg_clip == 2) && y < marg_t) + 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) + if ((curs.y <= marg_b || marg_clip == 2) && y > marg_b) y = marg_b; } if (y < 0) y = 0; if (y >= rows) y = rows-1; - curs_x = x; - curs_y = y; + curs.x = x; + curs.y = y; fix_cpos; wrapnext = FALSE; } @@ -434,18 +628,21 @@ static void move (int x, int y, int marg_clip) { */ static void save_cursor(int save) { if (save) { - save_x = curs_x; - save_y = curs_y; + savecurs = curs; save_attr = curr_attr; save_cset = cset; save_csattr = cset_attr[cset]; } else { - curs_x = save_x; - curs_y = save_y; + curs = 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; fix_cpos; + if (use_bce) erase_char = (' ' |(curr_attr&(ATTR_FGMASK|ATTR_BGMASK))); } } @@ -454,22 +651,44 @@ static void save_cursor(int save) { * whole line, or parts thereof. */ static void erase_lots (int line_only, int from_begin, int to_end) { - unsigned long *startpos, *endpos; + pos start, end; + int erase_lattr; + unsigned long *ldata; if (line_only) { - startpos = cpos - curs_x; - endpos = startpos + cols+1; + start.y = curs.y; + start.x = 0; + end.y = curs.y + 1; + end.x = 0; + erase_lattr = FALSE; } else { - startpos = scrtop; - endpos = startpos + rows * (cols+1); + start.y = 0; + start.x = 0; + end.y = rows; + end.x = 0; + erase_lattr = TRUE; + } + if (!from_begin) { + start = curs; + } + if (!to_end) { + end = curs; + } + check_selection (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(); + + ldata = lineptr(start.y); + while (poslt(start, end)) { + if (start.y == cols && !erase_lattr) + ldata[start.x] &= ~ATTR_WRAPPED; + else + ldata[start.x] = erase_char; + if (incpos(start) && start.y < rows) + ldata = lineptr(start.y); } - if (!from_begin) - startpos = cpos; - if (!to_end) - endpos = cpos; - check_selection (startpos, endpos); - while (startpos < endpos) - *startpos++ = ERASE_CHAR; } /* @@ -479,20 +698,25 @@ static void erase_lots (int line_only, int from_begin, int to_end) { static void insch (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; - check_selection (cpos, cpos+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 (dir < 0) { - memmove (cpos, cpos+n, m*TSIZE); + memmove (ldata + curs.x, ldata + curs.x + n, m*TSIZE); while (n--) - cpos[m++] = ERASE_CHAR; + ldata[curs.x + m++] = erase_char; } else { - memmove (cpos+n, cpos, m*TSIZE); + memmove (ldata + curs.x + n, ldata + curs.x, m*TSIZE); while (n--) - cpos[n] = ERASE_CHAR; + ldata[curs.x + n] = erase_char; } } @@ -501,17 +725,39 @@ static void insch (int n) { * 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); + 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; + } rvideo = state; - disptop = scrtop; + seen_disp_event = TRUE; + if (state) term_update(); break; case 6: /* DEC origin mode */ dec_om = state; @@ -519,15 +765,36 @@ static void toggle_mode (int mode, int query, int state) { 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 = scrtop; + 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; } } @@ -561,122 +828,285 @@ static void do_osc(void) { * process escape sequences... */ void term_out(void) { - int c; - int must_update = FALSE; - - while ( (c = inbuf_getc()) != -1) { -#ifdef LOG - { - static FILE *fp = NULL; - if (!fp) fp = fopen("putty.log", "wb"); - if (fp) fputc (c, fp); - } -#endif - switch (termstate) { - case TOPLEVEL: - do_toplevel: + int c, inbuf_reap; + + for(inbuf_reap = 0; inbuf_reap < inbuf_head; inbuf_reap++) + { + c = inbuf[inbuf_reap]; + + /* + * Optionally log the session traffic to a file. Useful for + * debugging and possibly also useful for actual logging. + */ + logtraffic((unsigned char)c, LGTYP_DEBUG); + + /* 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))) { switch (c) { case '\005': /* terminal type query */ - back->send ("\033[?1;2c", 7); + /* Strictly speaking this is VT100 but a VT100 defaults to + * no response. Other terminals respond at their option. + * + * Don't put a CR in the default string as this tends to + * upset some weird software. + * + * An xterm returns "xterm" (5 characters) + */ + compatibility(ANSIMIN); + { + 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); + } + ldisc_send (abuf, d-abuf); + } break; case '\007': - beep(); - disptop = scrtop; - must_update = TRUE; + { + struct beeptime *newbeep; + long ticks; + + ticks = GetTickCount(); + + if (!beep_overloaded) { + newbeep = smalloc(sizeof(struct beeptime)); + newbeep->ticks = ticks; + newbeep->next = NULL; + if (!beephead) + beephead = newbeep; + else + beeptail->next = newbeep; + beeptail = newbeep; + nbeeps++; + } + + /* + * Throw out any beeps that happened more than + * t seconds ago. + */ + while (beephead && + beephead->ticks < ticks - cfg.bellovl_t) { + struct beeptime *tmp = beephead; + beephead = tmp->next; + sfree(tmp); + if (!beephead) + beeptail = NULL; + nbeeps--; + } + + if (cfg.bellovl && beep_overloaded && + ticks-lastbeep >= 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) { + /* + * Now, if we have n or more beeps + * remaining in the queue, go into overload + * mode. + */ + beep_overloaded = TRUE; + } + 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(); + } + } + disptop = 0; + } break; case '\b': - if (curs_x == 0 && curs_y > 0) - curs_x = cols-1, curs_y--; + 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; else - curs_x--; + curs.x--; fix_cpos; - disptop = scrtop; - must_update = TRUE; + seen_disp_event = TRUE; break; case '\016': + compatibility(VT100); cset = 1; break; case '\017': + compatibility(VT100); cset = 0; break; case '\033': - termstate = SEEN_ESC; + if (vt52_mode) + termstate = VT52_ESC; + else { + compatibility(ANSIMIN); + termstate = SEEN_ESC; + } 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; + curs.x = 0; wrapnext = FALSE; fix_cpos; - disptop = scrtop; - must_update = TRUE; + seen_disp_event = TRUE; + paste_hold = 0; + logtraffic((unsigned char)c,LGTYP_ASCII); break; case '\013': case '\014': + compatibility(VT100); case '\n': - if (curs_y == marg_b) + 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; + else if (curs.y < rows-1) + curs.y++; + if (cfg.lfhascr) + curs.x = 0; fix_cpos; wrapnext = FALSE; - disptop = scrtop; - nl_count++; + seen_disp_event = 1; + paste_hold = 0; + logtraffic((unsigned char)c,LGTYP_ASCII); break; case '\t': - do { - curs_x++; - } while (curs_x < cols-1 && !tabs[curs_x]); - if (curs_x >= cols) - curs_x = cols-1; { - unsigned long *old_cpos = cpos; + pos old_curs = curs; + unsigned long *ldata = lineptr(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; + } + fix_cpos; - check_selection (old_cpos, cpos); + check_selection (old_curs, curs); } - disptop = scrtop; - must_update = TRUE; + seen_disp_event = TRUE; break; - default: - if (c >= ' ' && c != 0234) { - if (wrapnext) { - 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; - nl_count++; - } - if (insert) - insch (1); - check_selection (cpos, cpos+1); - *cpos++ = c | curr_attr | - (c <= 0x7F ? cset_attr[cset] : ATTR_ASCII); - curs_x++; - if (curs_x == cols) { - cpos--; - curs_x--; - wrapnext = wrap; - } - disptop = scrtop; + 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; } + /*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; @@ -695,12 +1125,8 @@ void term_out(void) { case SEEN_ESC: termstate = TOPLEVEL; switch (c) { - case '\005': case '\007': case '\b': case '\016': case '\017': - case '\033': case 0233: case 0234: case 0235: case '\r': - case '\013': case '\014': case '\n': case '\t': - termstate = TOPLEVEL; - goto do_toplevel; /* hack... */ case ' ': /* some weird sequence? */ + compatibility(VT220); termstate = IGNORE_NEXT; break; case '[': /* enter CSI mode */ @@ -710,88 +1136,96 @@ void term_out(void) { 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); - disptop = scrtop; - must_update = TRUE; + 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 */ - if (curs_y == marg_b) + compatibility(VT100); + if (curs.y == marg_b) scroll (marg_t, marg_b, 1, TRUE); - else if (curs_y < rows-1) - curs_y++; + else if (curs.y < rows-1) + curs.y++; fix_cpos; wrapnext = FALSE; - disptop = scrtop; - nl_count++; + seen_disp_event = TRUE; break; case 'E': /* exactly equivalent to CR-LF */ - curs_x = 0; - wrapnext = FALSE; - if (curs_y == marg_b) + 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++; + else if (curs.y < rows-1) + curs.y++; fix_cpos; wrapnext = FALSE; - nl_count++; - disptop = scrtop; + seen_disp_event = TRUE; break; case 'M': /* reverse index - backwards LF */ - if (curs_y == marg_t) + compatibility(VT100); + if (curs.y == marg_t) scroll (marg_t, marg_b, -1, TRUE); - else if (curs_y > 0) - curs_y--; + else if (curs.y > 0) + curs.y--; fix_cpos; wrapnext = FALSE; - disptop = scrtop; - must_update = TRUE; + seen_disp_event = TRUE; break; case 'Z': /* terminal type query */ - back->send ("\033[?6c", 5); + 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; + } fix_cpos; - disptop = scrtop; - must_update = TRUE; + 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 */ - tabs[curs_x] = TRUE; + compatibility(VT100); + tabs[curs.x] = TRUE; break; } break; case SEEN_CSI: termstate = TOPLEVEL; /* default */ - switch (c) { - case '\005': case '\007': case '\b': case '\016': case '\017': - case '\033': case 0233: case 0234: case 0235: case '\r': - case '\013': case '\014': case '\n': case '\t': - termstate = TOPLEVEL; - goto do_toplevel; /* hack... */ - case '0': case '1': case '2': case '3': case '4': - case '5': case '6': case '7': case '8': case '9': + if( isdigit(c) ) + { if (esc_nargs <= ARGS_MAX) { if (esc_args[esc_nargs-1] == ARG_DEFAULT) esc_args[esc_nargs-1] = 0; @@ -799,56 +1233,61 @@ void term_out(void) { 10 * esc_args[esc_nargs-1] + c - '0'; } termstate = SEEN_CSI; - break; - case ';': + } + else if( c == ';' ) + { if (++esc_nargs <= ARGS_MAX) esc_args[esc_nargs-1] = ARG_DEFAULT; termstate = SEEN_CSI; - break; - case '?': - esc_query = TRUE; + } + else if( c < '@' ) + { + if( esc_query ) esc_query = -1; + else if( c == '?' ) esc_query = TRUE; + else esc_query = c; termstate = SEEN_CSI; - break; + } + else switch (ANSI(c,esc_query)) { case 'A': /* move up N lines */ - move (curs_x, curs_y - def(esc_args[0], 1), 1); - disptop = scrtop; - must_update = TRUE; + move (curs.x, curs.y - def(esc_args[0], 1), 1); + seen_disp_event = TRUE; break; - case 'B': case 'e': /* move down N lines */ - move (curs_x, curs_y + def(esc_args[0], 1), 1); - disptop = scrtop; - must_update = TRUE; + 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 'C': case 'a': /* move right N cols */ - move (curs_x + def(esc_args[0], 1), curs_y, 1); - disptop = scrtop; - must_update = TRUE; + 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); - disptop = scrtop; - must_update = TRUE; + move (curs.x - def(esc_args[0], 1), curs.y, 1); + seen_disp_event = TRUE; break; case 'E': /* move down N lines and CR */ - move (0, curs_y + def(esc_args[0], 1), 1); - disptop = scrtop; - must_update = TRUE; + 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 */ - move (0, curs_y - def(esc_args[0], 1), 1); - disptop = scrtop; - must_update = TRUE; + compatibility(ANSI); + move (0, curs.y - def(esc_args[0], 1), 1); + seen_disp_event = TRUE; break; case 'G': case '`': /* set horizontal posn */ - move (def(esc_args[0], 1) - 1, curs_y, 0); - disptop = scrtop; - must_update = TRUE; + compatibility(ANSI); + move (def(esc_args[0], 1) - 1, curs.y, 0); + seen_disp_event = TRUE; break; case 'd': /* set vertical posn */ - move (curs_x, (dec_om ? marg_t : 0) + def(esc_args[0], 1) - 1, + compatibility(ANSI); + move (curs.x, (dec_om ? marg_t : 0) + def(esc_args[0], 1) - 1, (dec_om ? 2 : 0)); - disptop = scrtop; - must_update = TRUE; + seen_disp_event = TRUE; break; case 'H': case 'f': /* set horz and vert posns at once */ if (esc_nargs < 2) @@ -856,8 +1295,7 @@ void term_out(void) { move (def(esc_args[1], 1) - 1, (dec_om ? marg_t : 0) + def(esc_args[0], 1) - 1, (dec_om ? 2 : 0)); - disptop = scrtop; - must_update = TRUE; + seen_disp_event = TRUE; break; case 'J': /* erase screen or parts of it */ { @@ -866,8 +1304,8 @@ void term_out(void) { i = 0; erase_lots(FALSE, !!(i & 2), !!(i & 1)); } - disptop = scrtop; - must_update = TRUE; + disptop = 0; + seen_disp_event = TRUE; break; case 'K': /* erase line or parts of it */ { @@ -876,51 +1314,71 @@ void term_out(void) { i = 0; erase_lots(TRUE, !!(i & 2), !!(i & 1)); } - disptop = scrtop; - must_update = TRUE; + seen_disp_event = TRUE; break; case 'L': /* insert lines */ - if (curs_y <= marg_b) - scroll (curs_y, marg_b, -def(esc_args[0], 1), FALSE); - disptop = scrtop; - must_update = TRUE; + 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 */ - if (curs_y <= marg_b) - scroll (curs_y, marg_b, def(esc_args[0], 1), FALSE); - disptop = scrtop; - must_update = TRUE; + 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)); - disptop = scrtop; - must_update = TRUE; + seen_disp_event = TRUE; break; case 'P': /* delete chars */ + compatibility(VT102); insch (-def(esc_args[0], 1)); - disptop = scrtop; - must_update = TRUE; + seen_disp_event = TRUE; break; case 'c': /* terminal type query */ - back->send ("\033[?6c", 5); + 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); - back->send (buf, strlen(buf)); + sprintf (buf, "\033[%d;%dR", curs.y + 1, curs.x + 1); + ldisc_send (buf, strlen(buf)); + } + else if (esc_args[0] == 5) { + ldisc_send ("\033[0n", 4); } break; - case 'h': /* toggle a mode to high */ - toggle_mode (esc_args[0], esc_query, TRUE); + case 'h': /* toggle modes to high */ + case ANSI_QUE('h'): + compatibility(VT100); + { + int i; + for (i=0; i= rows) bot = rows-1; - if (top <= bot) { + /* 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; + 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 = 0; + curs.y = (dec_om ? marg_t : 0); fix_cpos; - disptop = scrtop; - must_update = TRUE; + 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 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; i=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; - check_selection (cpos, cpos+n); + if (n > cols - curs.x) + n = cols - curs.x; + cursplus = curs; + cursplus.x += n; + check_selection (curs, cursplus); while (n--) - *p++ = ERASE_CHAR; - disptop = scrtop; - must_update = TRUE; + *p++ = erase_char; + seen_disp_event = TRUE; } 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; - back->send (buf, 20); + ldisc_send (buf, 20); } } 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! + */ + + 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; + + default: if( esc_args[0] > 60 && esc_args[0] < 70 ) + compatibility_level |= TM_VTXXX; + break; + + case 40: compatibility_level &= TM_VTXXX; break; + case 41: compatibility_level = TM_PUTTY; break; + case 42: compatibility_level = TM_SCOANSI; break; + + case ARG_DEFAULT: + compatibility_level = TM_PUTTY; break; + case 50: break; + } + + /* Change the response to CSI c */ + if (esc_args[0] == 50) { + int i; + char lbuf[64]; + strcpy(id_string, "\033[?"); + for (i=1; i 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 */ + break; + case 'X': + /* XXX Stop controller mode */ + 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 */ + break; + case ']': + /* XXX Print screen */ + break; + } + 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; + incpos(cursplus); + check_selection (curs, cursplus); } - check_selection (cpos, cpos+1); } - - if (must_update || nl_count > MAXNL) - term_update(); + inbuf_head = 0; } /* @@ -1184,23 +1907,69 @@ static int linecmp (unsigned long *a, unsigned long *b) { * 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){ +static void do_paint (Context ctx, int may_optimise) { int i, j, start, our_curs_y; unsigned long attr, rv, cursor; + pos scrpos; char ch[1024]; + long ticks; - cursor = (has_focus ? ATTR_ACTCURS : ATTR_PASCURS); - rv = (rvideo ? ATTR_REVERSE : 0); - our_curs_y = curs_y + (scrtop - disptop) / (cols+1); + /* + * Check the visual bell state. + */ + if (in_vbell) { + ticks = GetTickCount(); + if (ticks - vbell_timeout >= 0) + in_vbell = FALSE; + } + + /* 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 + */ + 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 + cursor = 0; + rv = (!rvideo ^ !in_vbell ? ATTR_REVERSE : 0); + our_curs_y = curs.y - disptop; for (i=0; i450) + { + last_tblink = now; + tblinker = !tblinker; + } + + if (flg) { + blinker = 1; + last_blink = now; + return; + } + + blink_diff = now-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; +} + +/* * Invalidate the whole screen so it will be repainted in full. */ void term_invalidate(void) { @@ -1257,10 +2062,20 @@ void term_paint (Context ctx, int l, int t, int r, int b) { top = t / font_height; bottom = (b - 1) / font_height; for (i = top; i <= bottom && i < rows ; i++) - for (j = left; j <= right && j < cols ; j++) - disptext[i*(cols+1)+j] = ATTR_INVALID; + { + 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; + else + for (j = left/2; j <= right/2+1 && j < cols ; j++) + disptext[i*(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); + */ } /* @@ -1271,29 +2086,111 @@ void term_paint (Context ctx, int l, int t, int r, int b) { * relative to the current position. */ void term_scroll (int rel, int where) { - int n = where * (cols+1); + int sbtop = -count234(scrollback); - disptop = (rel < 0 ? scrtop : - rel > 0 ? sbtop : disptop) + n; + disptop = (rel < 0 ? 0 : + rel > 0 ? sbtop : disptop) + where; if (disptop < sbtop) disptop = sbtop; - if (disptop > scrtop) - disptop = scrtop; + if (disptop > 0) + disptop = 0; update_sbar(); term_update(); } +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 */ + + 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 */ + + while (poslt(top, bottom)) { + int nl = FALSE; + unsigned long *ldata = lineptr(top.y); + pos nlpos; + + nlpos.y = top.y; + nlpos.x = cols; + + if (!(ldata[cols] & ATTR_WRAPPED)) { + while ((ldata[nlpos.x-1] & CHAR_MASK) == 0x20 && poslt(top, nlpos)) + decpos(nlpos); + if (poslt(nlpos, bottom)) + nl = TRUE; + } + 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)]; + } + } + + while(ch != 0) { + if (cfg.rawcnp || !!(ch&0xE0)) { + if ( wblen == buflen ) + { + workbuf = srealloc(workbuf, buflen += 100); + wbptr = workbuf + wblen; + } + wblen++; + *wbptr++ = (unsigned char) ch; + } + ch>>=8; + } + top.x++; + } + if (nl) { + int i; + for (i=0; i 0 ) /* indicates we allocated this buffer */ + sfree(workbuf); + +} +void term_copyall (void) { + pos top; + top.y = -count234(scrollback); + top.x = 0; + clipme(top, curs, NULL /* dynamic allocation */); +} + /* * Spread the selection outwards according to the selection mode. */ -static unsigned long *sel_spread_half (unsigned long *p, int dir) { - unsigned long *linestart, *lineend; - int x; +static pos sel_spread_half (pos p, int dir) { + unsigned long *ldata; short wvalue; - x = (p - text) % (cols+1); - linestart = p - x; - lineend = linestart + cols; + ldata = lineptr(p.y); switch (selmode) { case SM_CHAR: @@ -1301,14 +2198,14 @@ static unsigned long *sel_spread_half (unsigned long *p, int dir) { * In this mode, every character is a separate unit, except * for runs of spaces at the end of a non-wrapping line. */ - if (!(linestart[cols] & ATTR_WRAPPED)) { - unsigned long *q = lineend; - while (q > linestart && (q[-1] & CHAR_MASK) == 0x20) + if (!(ldata[cols] & ATTR_WRAPPED)) { + unsigned long *q = ldata+cols; + while (q > ldata && (q[-1] & CHAR_MASK) == 0x20) q--; - if (q == lineend) + if (q == ldata+cols) q--; - if (p >= q) - p = (dir == -1 ? q : lineend - 1); + if (p.x >= q-ldata) + p.x = (dir == -1 ? q-ldata : cols - 1); } break; case SM_WORD: @@ -1316,20 +2213,20 @@ static unsigned long *sel_spread_half (unsigned long *p, int dir) { * In this mode, the units are maximal runs of characters * whose `wordness' has the same value. */ - wvalue = wordness[*p & CHAR_MASK]; + wvalue = wordness[ldata[p.x] & CHAR_MASK]; if (dir == +1) { - while (p < lineend && wordness[p[1] & CHAR_MASK] == wvalue) - p++; + while (p.x < cols && wordness[ldata[p.x+1] & CHAR_MASK] == wvalue) + p.x++; } else { - while (p > linestart && wordness[p[-1] & CHAR_MASK] == wvalue) - p--; + while (p.x > 0 && wordness[ldata[p.x-1] & CHAR_MASK] == wvalue) + p.x--; } break; case SM_LINE: /* * In this mode, every line is a unit. */ - p = (dir == -1 ? linestart : lineend - 1); + p.x = (dir == -1 ? 0 : cols - 1); break; } return p; @@ -1337,11 +2234,14 @@ static unsigned long *sel_spread_half (unsigned long *p, int dir) { static void sel_spread (void) { selstart = sel_spread_half (selstart, -1); - selend = sel_spread_half (selend - 1, +1) + 1; + decpos(selend); + selend = sel_spread_half (selend, +1); + incpos(selend); } void term_mouse (Mouse_Button b, Mouse_Action a, int x, int y) { - unsigned long *selpoint; + pos selpoint; + unsigned long *ldata; if (y<0) y = 0; if (y>=rows) y = rows-1; @@ -1354,7 +2254,11 @@ void term_mouse (Mouse_Button b, Mouse_Action a, int x, int y) { } if (x>=cols) x = cols-1; - selpoint = disptop + y * (cols+1) + x; + selpoint.y = y + disptop; + selpoint.x = x; + ldata = lineptr(selpoint.y); + if ((ldata[cols]&LATTR_MODE) != LATTR_NORM) + selpoint.x /= 2; if (b == MB_SELECT && a == MA_CLICK) { deselect(); @@ -1366,28 +2270,33 @@ void term_mouse (Mouse_Button b, Mouse_Action a, int x, int y) { selmode = (a == MA_2CLK ? SM_WORD : SM_LINE); selstate = DRAGGING; selstart = selanchor = selpoint; - selend = selstart + 1; + selend = selstart; + incpos(selend); sel_spread(); } else if ((b == MB_SELECT && a == MA_DRAG) || (b == MB_EXTEND && a != MA_RELEASE)) { - if (selstate == ABOUT_TO && selanchor == selpoint) + if (selstate == ABOUT_TO && poseq(selanchor, selpoint)) return; if (b == MB_EXTEND && a != MA_DRAG && selstate == SELECTED) { - if (selpoint-selstart < (selend-selstart)/2) - selanchor = selend - 1; - else + if (posdiff(selpoint,selstart) < posdiff(selend,selstart)/2) { + selanchor = selend; + decpos(selanchor); + } else { selanchor = selstart; + } selstate = DRAGGING; } if (selstate != ABOUT_TO && selstate != DRAGGING) selanchor = selpoint; selstate = DRAGGING; - if (selpoint < selanchor) { + if (poslt(selpoint, selanchor)) { selstart = selpoint; - selend = selanchor + 1; + selend = selanchor; + incpos(selend); } else { selstart = selanchor; - selend = selpoint + 1; + selend = selpoint; + incpos(selend); } sel_spread(); } else if ((b == MB_SELECT || b == MB_EXTEND) && a == MA_RELEASE) { @@ -1396,30 +2305,7 @@ void term_mouse (Mouse_Button b, Mouse_Action a, int x, int y) { * We've completed a selection. We now transfer the * data to the clipboard. */ - unsigned char *p = selspace; - unsigned long *q = selstart; - - while (q < selend) { - int nl = FALSE; - unsigned long *lineend = q - (q-text) % (cols+1) + cols; - unsigned long *nlpos = lineend; - - if (!(*nlpos & ATTR_WRAPPED)) { - while ((nlpos[-1] & CHAR_MASK) == 0x20 && nlpos > q) - nlpos--; - if (nlpos < selend) - nl = TRUE; - } - while (q < nlpos && q < selend) - *p++ = (unsigned char) (*q++ & CHAR_MASK); - if (nl) { - int i; - for (i=0; isend (q, p-q); + + { + int i; + unsigned char c; + for(i=0;isend ("\r", 1); + paste_buffer[paste_len++] = '\r'; p += sizeof(sel_nl); } q = p; } + + /* Assume a small paste will be OK in one go. */ + if (paste_len<256) { + ldisc_send (paste_buffer, paste_len); + if (paste_buffer) sfree(paste_buffer); + paste_buffer = 0; + paste_pos = paste_hold = paste_len = 0; + } } get_clip(NULL, NULL); } @@ -1451,12 +2360,133 @@ void term_mouse (Mouse_Button b, Mouse_Action a, int x, int y) { term_update(); } +void term_nopaste() { + if(paste_len == 0) return; + sfree(paste_buffer); + paste_buffer = 0; + paste_len = 0; +} + +void term_paste() { + static long last_paste = 0; + long now, paste_diff; + + if(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) + return; + } + paste_hold = 0; + + while(paste_pos= 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); + } + } +} + +/* open log file append/overwrite mode */ +void logfopen(void) { + char buf[256]; + time_t t; + struct tm *tm; + char writemod[4]; + + 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; + } + } + + 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); + } +} + +void logfclose (void) { + if (lgfp) { fclose(lgfp); lgfp = NULL; } +}