projects / u / mdw / putty / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Improve socket error handling so that a socket error isn't an
[u/mdw/putty] / terminal.c
CommitLineData
374330e2 1#include <windows.h>
2
3#include <stdio.h>
4#include <stdlib.h>
49bad831 5#include <ctype.h>
374330e2 6
e1c8e0ed 7#include <time.h>
374330e2 8#include "putty.h"
9
c9def1b8 10#define CL_ANSIMIN 0x0001 /* Codes in all ANSI like terminals. */
e14a5a13 11#define CL_VT100 0x0002 /* VT100 */
12#define CL_VT100AVO 0x0004 /* VT100 +AVO; 132x24 (not 132x14) & attrs */
13#define CL_VT102 0x0008 /* VT102 */
14#define CL_VT220 0x0010 /* VT220 */
15#define CL_VT320 0x0020 /* VT320 */
16#define CL_VT420 0x0040 /* VT420 */
17#define CL_VT510 0x0080 /* VT510, NB VT510 includes ANSI */
18#define CL_VT340TEXT 0x0100 /* VT340 extensions that appear in the VT420 */
c9def1b8 19#define CL_SCOANSI 0x1000 /* SCOANSI not in ANSIMIN. */
20#define CL_ANSI 0x2000 /* ANSI ECMA-48 not in the VT100..VT420 */
21#define CL_OTHER 0x4000 /* Others, Xterm, linux, putty, dunno, etc */
e14a5a13 22
c9def1b8 23#define TM_VT100 (CL_ANSIMIN|CL_VT100)
24#define TM_VT100AVO (TM_VT100|CL_VT100AVO)
25#define TM_VT102 (TM_VT100AVO|CL_VT102)
26#define TM_VT220 (TM_VT102|CL_VT220)
27#define TM_VTXXX (TM_VT220|CL_VT340TEXT|CL_VT510|CL_VT420|CL_VT320)
28#define TM_SCOANSI (CL_ANSIMIN|CL_SCOANSI)
29
30#define TM_PUTTY (0xFFFF)
e14a5a13 31
32#define compatibility(x) \
33 if ( ((CL_##x)&compatibility_level) == 0 ) { \
34 termstate=TOPLEVEL; \
35 break; \
36 }
c9def1b8 37#define compatibility2(x,y) \
38 if ( ((CL_##x|CL_##y)&compatibility_level) == 0 ) { \
39 termstate=TOPLEVEL; \
40 break; \
41 }
e14a5a13 42
43#define has_compat(x) ( ((CL_##x)&compatibility_level) != 0 )
44
45static int compatibility_level = TM_PUTTY;
46
47
374330e2 48static unsigned long *text; /* buffer of text on terminal screen */
49static unsigned long *scrtop; /* top of working screen */
50static unsigned long *disptop; /* top of displayed screen */
51static unsigned long *sbtop; /* top of scrollback */
c9def1b8 52static unsigned long *sbbot; /* furthest extent of scrollback */
374330e2 53static unsigned long *cpos; /* cursor position (convenience) */
54static unsigned long *disptext; /* buffer of text on real screen */
55static unsigned long *wanttext; /* buffer of text we want on screen */
56static unsigned long *alttext; /* buffer of text on alt. screen */
57
58static unsigned char *selspace; /* buffer for building selections in */
59
60#define TSIZE (sizeof(*text))
61#define fix_cpos do { cpos = scrtop + curs_y * (cols+1) + curs_x; } while(0)
62
63static unsigned long curr_attr, save_attr;
e14a5a13 64static unsigned long erase_char = ERASE_CHAR;
374330e2 65
66static int curs_x, curs_y; /* cursor */
67static int save_x, save_y; /* saved cursor position */
68static int marg_t, marg_b; /* scroll margins */
69static int dec_om; /* DEC origin mode flag */
70static int wrap, wrapnext; /* wrap flags */
71static int insert; /* insert-mode flag */
72static int cset; /* 0 or 1: which char set */
73static int save_cset, save_csattr; /* saved with cursor position */
74static int rvideo; /* global reverse video flag */
e14a5a13 75static int cursor_on; /* cursor enabled flag */
76static int reset_132; /* Flag ESC c resets to 80 cols */
77static int use_bce; /* Use Background coloured erase */
78static int blinker; /* When blinking is the cursor on ? */
c9def1b8 79static int tblinker; /* When the blinking text is on */
80static int blink_is_real; /* Actually blink blinking text */
374330e2 81
82static unsigned long cset_attr[2];
83
84/*
85 * Saved settings on the alternate screen.
86 */
87static int alt_x, alt_y, alt_om, alt_wrap, alt_wnext, alt_ins, alt_cset;
88static int alt_t, alt_b;
89static int alt_which;
90
91#define ARGS_MAX 32 /* max # of esc sequence arguments */
064916ea 92#define ARG_DEFAULT 0 /* if an arg isn't specified */
374330e2 93#define def(a,d) ( (a) == ARG_DEFAULT ? (d) : (a) )
94static int esc_args[ARGS_MAX];
95static int esc_nargs;
96static int esc_query;
8b811b12 97#define ANSI(x,y) ((x)+((y)<<8))
98#define ANSI_QUE(x) ANSI(x,TRUE)
374330e2 99
100#define OSC_STR_MAX 2048
101static int osc_strlen;
102static char osc_string[OSC_STR_MAX+1];
103static int osc_w;
104
c9def1b8 105static char id_string[1024] = "\033[?6c";
106
374330e2 107static unsigned char *tabs;
108
374330e2 109static enum {
cabfd08c 110 TOPLEVEL,
111 SEEN_ESC,
112 SEEN_CSI,
113 SEEN_OSC,
114 SEEN_OSC_W,
115
116 DO_CTRLS,
117
118 IGNORE_NEXT,
119 SET_GL, SET_GR,
120 SEEN_OSC_P,
121 OSC_STRING, OSC_MAYBE_ST,
e14a5a13 122 SEEN_ESCHASH,
123 VT52_ESC,
124 VT52_Y1,
125 VT52_Y2
374330e2 126} termstate;
127
128static enum {
129 NO_SELECTION, ABOUT_TO, DRAGGING, SELECTED
130} selstate;
131static enum {
132 SM_CHAR, SM_WORD, SM_LINE
133} selmode;
134static unsigned long *selstart, *selend, *selanchor;
135
136static short wordness[256] = {
137 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 */
138 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 */
139 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 */
140 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 */
141 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 */
142 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 */
143 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 */
144 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 */
145};
146
147static unsigned char sel_nl[] = SEL_NL;
c9def1b8 148static char * paste_buffer = 0;
149static int paste_len, paste_pos, paste_hold;
374330e2 150
151/*
152 * Internal prototypes.
153 */
154static void do_paint (Context, int);
155static void erase_lots (int, int, int);
156static void swap_screen (int);
157static void update_sbar (void);
158static void deselect (void);
e1c8e0ed 159/* log session to file stuff ... */
160static FILE *lgfp = NULL;
161static void logtraffic(unsigned char c, int logmode);
374330e2 162
163/*
164 * Set up power-on settings for the terminal.
165 */
166static void power_on(void) {
167 curs_x = curs_y = alt_x = alt_y = save_x = save_y = 0;
168 alt_t = marg_t = 0;
169 if (rows != -1)
170 alt_b = marg_b = rows - 1;
171 else
172 alt_b = marg_b = 0;
173 if (cols != -1) {
174 int i;
175 for (i = 0; i < cols; i++)
176 tabs[i] = (i % 8 == 0 ? TRUE : FALSE);
177 }
178 alt_om = dec_om = cfg.dec_om;
179 alt_wnext = wrapnext = alt_ins = insert = FALSE;
180 alt_wrap = wrap = cfg.wrap_mode;
181 alt_cset = cset = 0;
182 cset_attr[0] = cset_attr[1] = ATTR_ASCII;
183 rvideo = 0;
e14a5a13 184 cursor_on = 1;
374330e2 185 save_attr = curr_attr = ATTR_DEFAULT;
186 app_cursor_keys = cfg.app_cursor;
187 app_keypad_keys = cfg.app_keypad;
c9def1b8 188 use_bce = cfg.bce;
189 blink_is_real = cfg.blinktext;
e14a5a13 190 erase_char = ERASE_CHAR;
374330e2 191 alt_which = 0;
192 {
193 int i;
194 for (i = 0; i < 256; i++)
195 wordness[i] = cfg.wordness[i];
196 }
197 if (text) {
198 swap_screen (1);
199 erase_lots (FALSE, TRUE, TRUE);
200 swap_screen (0);
201 erase_lots (FALSE, TRUE, TRUE);
202 }
203}
204
205/*
206 * Force a screen update.
207 */
208void term_update(void) {
209 Context ctx;
210 ctx = get_ctx();
211 if (ctx) {
c9def1b8 212 if ( (seen_key_event && (cfg.scroll_on_key)) ||
a094ae43 213 (seen_disp_event && (cfg.scroll_on_disp)) ) {
cabfd08c 214 disptop = scrtop;
215 seen_disp_event = seen_key_event = 0;
8ac3e544 216 update_sbar();
cabfd08c 217 }
374330e2 218 do_paint (ctx, TRUE);
ec8679e9 219 sys_cursor(curs_x, curs_y + (scrtop - disptop) / (cols+1));
374330e2 220 free_ctx (ctx);
374330e2 221 }
222}
223
224/*
225 * Same as power_on(), but an external function.
226 */
227void term_pwron(void) {
228 power_on();
229 fix_cpos;
230 disptop = scrtop;
231 deselect();
232 term_update();
233}
234
235/*
236 * Clear the scrollback.
237 */
238void term_clrsb(void) {
239 disptop = sbtop = scrtop;
240 update_sbar();
241}
242
243/*
244 * Initialise the terminal.
245 */
246void term_init(void) {
c9def1b8 247 text = sbtop = sbbot = scrtop = disptop = cpos = NULL;
374330e2 248 disptext = wanttext = NULL;
249 tabs = NULL;
250 selspace = NULL;
251 deselect();
252 rows = cols = -1;
374330e2 253 power_on();
254}
255
256/*
257 * Set up the terminal for a given size.
258 */
259void term_size(int newrows, int newcols, int newsavelines) {
260 unsigned long *newtext, *newdisp, *newwant, *newalt;
261 int i, j, crows, ccols;
262
d6832394 263 int save_alt_which = alt_which;
264
374330e2 265 if (newrows == rows && newcols == cols && newsavelines == savelines)
266 return; /* nothing to do */
267
d6832394 268 deselect();
269 swap_screen(0);
270
374330e2 271 alt_t = marg_t = 0;
272 alt_b = marg_b = newrows - 1;
273
274 newtext = smalloc ((newrows+newsavelines)*(newcols+1)*TSIZE);
c9def1b8 275 sbbot = newtext + newsavelines*(newcols+1);
374330e2 276 for (i=0; i<(newrows+newsavelines)*(newcols+1); i++)
c9def1b8 277 newtext[i] = erase_char;
374330e2 278 if (rows != -1) {
279 crows = rows + (scrtop - sbtop) / (cols+1);
280 if (crows > newrows+newsavelines)
281 crows = newrows+newsavelines;
c9def1b8 282 if (newrows>crows)
283 disptop = newtext;
284 else
285 disptop = newtext + (crows-newrows)*(newcols+1);
374330e2 286 ccols = (cols < newcols ? cols : newcols);
287 for (i=0; i<crows; i++) {
c9def1b8 288 int oldidx = (rows - crows + i) * (cols+1);
289 int newidx = (newrows - crows + i) * (newcols+1);
290
374330e2 291 for (j=0; j<ccols; j++)
c9def1b8 292 disptop[newidx+j] = scrtop[oldidx+j];
293 disptop[newidx+newcols] =
294 (cols == newcols ? scrtop[oldidx+cols]
295 : (scrtop[oldidx+cols]&LATTR_MODE));
374330e2 296 }
c9def1b8 297 sbtop = newtext;
298 } else {
299 sbtop = disptop = newtext;
300 }
374330e2 301 scrtop = disptop;
302 sfree (text);
303 text = newtext;
304
305 newdisp = smalloc (newrows*(newcols+1)*TSIZE);
306 for (i=0; i<newrows*(newcols+1); i++)
307 newdisp[i] = ATTR_INVALID;
308 sfree (disptext);
309 disptext = newdisp;
310
311 newwant = smalloc (newrows*(newcols+1)*TSIZE);
312 for (i=0; i<newrows*(newcols+1); i++)
313 newwant[i] = ATTR_INVALID;
314 sfree (wanttext);
315 wanttext = newwant;
316
317 newalt = smalloc (newrows*(newcols+1)*TSIZE);
318 for (i=0; i<newrows*(newcols+1); i++)
e14a5a13 319 newalt[i] = erase_char;
374330e2 320 sfree (alttext);
321 alttext = newalt;
322
323 sfree (selspace);
324 selspace = smalloc ( (newrows+newsavelines) * (newcols+sizeof(sel_nl)) );
325
326 tabs = srealloc (tabs, newcols*sizeof(*tabs));
327 {
328 int i;
329 for (i = (cols > 0 ? cols : 0); i < newcols; i++)
330 tabs[i] = (i % 8 == 0 ? TRUE : FALSE);
331 }
332
333 if (rows > 0)
334 curs_y += newrows - rows;
335 if (curs_y < 0)
336 curs_y = 0;
337 if (curs_y >= newrows)
338 curs_y = newrows-1;
339 if (curs_x >= newcols)
340 curs_x = newcols-1;
341 alt_x = alt_y = 0;
342 wrapnext = alt_wnext = FALSE;
343
344 rows = newrows;
345 cols = newcols;
346 savelines = newsavelines;
347 fix_cpos;
348
d6832394 349 swap_screen(save_alt_which);
350
374330e2 351 update_sbar();
352 term_update();
353}
354
355/*
356 * Swap screens.
357 */
358static void swap_screen (int which) {
359 int t;
360 unsigned long tt;
361
362 if (which == alt_which)
363 return;
364
365 alt_which = which;
366
367 for (t=0; t<rows*(cols+1); t++) {
368 tt = scrtop[t]; scrtop[t] = alttext[t]; alttext[t] = tt;
369 }
370
371 t = curs_x; curs_x = alt_x; alt_x = t;
372 t = curs_y; curs_y = alt_y; alt_y = t;
373 t = marg_t; marg_t = alt_t; alt_t = t;
374 t = marg_b; marg_b = alt_b; alt_b = t;
375 t = dec_om; dec_om = alt_om; alt_om = t;
376 t = wrap; wrap = alt_wrap; alt_wrap = t;
377 t = wrapnext; wrapnext = alt_wnext; alt_wnext = t;
378 t = insert; insert = alt_ins; alt_ins = t;
379 t = cset; cset = alt_cset; alt_cset = t;
380
381 fix_cpos;
382}
383
384/*
374330e2 385 * Update the scroll bar.
386 */
387static void update_sbar(void) {
388 int min;
389
390 min = (sbtop - text) / (cols+1);
391 set_sbar ((scrtop - text) / (cols+1) + rows - min,
392 (disptop - text) / (cols+1) - min,
393 rows);
394}
395
396/*
397 * Check whether the region bounded by the two pointers intersects
398 * the scroll region, and de-select the on-screen selection if so.
399 */
400static void check_selection (unsigned long *from, unsigned long *to) {
401 if (from < selend && selstart < to)
402 deselect();
403}
404
405/*
406 * Scroll the screen. (`lines' is +ve for scrolling forward, -ve
407 * for backward.) `sb' is TRUE if the scrolling is permitted to
408 * affect the scrollback buffer.
409 */
410static void scroll (int topline, int botline, int lines, int sb) {
411 unsigned long *scroll_top;
c9def1b8 412 unsigned long *newscr;
374330e2 413 int scroll_size, size, i;
c9def1b8 414 int scrtop_is_disptop = (scrtop==disptop);
415static int recursive = 0;
416
417 /* Only scroll more than the window if we're doing a 10% scroll */
418 if (!recursive && lines > botline - topline + 1)
419 lines = botline - topline + 1;
374330e2 420
421 scroll_top = scrtop + topline*(cols+1);
422 size = (lines < 0 ? -lines : lines) * (cols+1);
423 scroll_size = (botline - topline + 1) * (cols+1) - size;
424
cabfd08c 425 if (lines > 0 && topline == 0 && alt_which == 0 && sb) {
374330e2 426 /*
cabfd08c 427 * Since we're going to scroll the top line and we're on the
c9def1b8 428 * scrolling screen let's also effect the scrollback buffer.
429 *
430 * This is normally done by moving the position the screen
431 * painter reads from to reduce the amount of memory copying
432 * required.
374330e2 433 */
c9def1b8 434 if (scroll_size >= 0 && !recursive) {
435 newscr = scrtop + lines * (cols+1);
436
437 if (newscr > sbbot && botline == rows-1) {
438 /* We've hit the bottom of memory, so we have to do a
439 * physical scroll. But instead of just 1 line do it
440 * by 10% of the available memory.
441 *
442 * If the scroll region isn't the whole screen then we can't
443 * do this as it stands. We would need to recover the bottom
444 * of the screen from the scroll buffer after being sure that
445 * it doesn't get deleted.
446 */
447
448 i = (rows+savelines)/10;
449
450 /* Make it simple and ensure safe recursion */
451 if ( i<savelines-1) {
452 recursive ++;
453 scroll(topline, botline, i, sb);
454 recursive --;
455
456 newscr = scrtop - i * (cols+1);
457 if (scrtop_is_disptop) disptop = newscr;
458 scrtop = newscr;
459 }
460
461 newscr = scrtop + lines * (cols+1);
462 }
463
464 if (newscr <= sbbot) {
465 if (scrtop_is_disptop) disptop = newscr;
466 scrtop = newscr;
467
468 if (botline == rows-1 )
469 for (i = 0; i < size; i++)
470 scrtop[i+scroll_size] = erase_char;
471
472 update_sbar();
473 fix_cpos;
474
475 if (botline != rows-1) {
476 /* This fastscroll only works for full window scrolls.
477 * If the caller wanted a partial one we have to reverse
478 * scroll the bottom of the screen.
479 */
480 scroll(botline-lines+1, rows-1, -lines, 0);
481 }
482 return ;
483 }
484
485 /* If we can't scroll by memory remapping do it physically.
486 * But rather than expensivly doing the scroll buffer just
487 * scroll the screen. All it means is that sometimes we choose
488 * to not add lines from a scroll region to the scroll buffer.
489 */
490
491 if (savelines <= 400) {
492 sbtop -= lines * (cols+1);
493 if (sbtop < text)
494 sbtop = text;
495 scroll_size += scroll_top - sbtop;
496 scroll_top = sbtop;
497
498 update_sbar();
499 }
500 } else {
501 /* Ho hum, expensive scroll required. */
502
503 sbtop -= lines * (cols+1);
504 if (sbtop < text)
505 sbtop = text;
506 scroll_size += scroll_top - sbtop;
507 scroll_top = sbtop;
508
509 update_sbar();
510 }
374330e2 511 }
512
513 if (scroll_size < 0) {
514 size += scroll_size;
515 scroll_size = 0;
516 }
517
518 if (lines > 0) {
519 if (scroll_size)
520 memmove (scroll_top, scroll_top + size, scroll_size*TSIZE);
521 for (i = 0; i < size; i++)
e14a5a13 522 scroll_top[i+scroll_size] = erase_char;
374330e2 523 if (selstart > scroll_top &&
524 selstart < scroll_top + size + scroll_size) {
525 selstart -= size;
526 if (selstart < scroll_top)
527 selstart = scroll_top;
528 }
529 if (selend > scroll_top &&
530 selend < scroll_top + size + scroll_size) {
531 selend -= size;
532 if (selend < scroll_top)
533 selend = scroll_top;
534 }
c9def1b8 535 if (scrtop_is_disptop)
536 disptop = scrtop;
537 else
538 if (disptop > scroll_top &&
539 disptop < scroll_top + size + scroll_size) {
540 disptop -= size;
541 if (disptop < scroll_top)
542 disptop = scroll_top;
543 }
374330e2 544 } else {
545 if (scroll_size)
546 memmove (scroll_top + size, scroll_top, scroll_size*TSIZE);
547 for (i = 0; i < size; i++)
e14a5a13 548 scroll_top[i] = erase_char;
374330e2 549 if (selstart > scroll_top &&
550 selstart < scroll_top + size + scroll_size) {
551 selstart += size;
552 if (selstart > scroll_top + size + scroll_size)
553 selstart = scroll_top + size + scroll_size;
554 }
555 if (selend > scroll_top &&
556 selend < scroll_top + size + scroll_size) {
557 selend += size;
558 if (selend > scroll_top + size + scroll_size)
559 selend = scroll_top + size + scroll_size;
560 }
c9def1b8 561 if (scrtop_is_disptop)
562 disptop = scrtop;
563 else if (disptop > scroll_top &&
564 disptop < scroll_top + size + scroll_size) {
565 disptop += size;
566 if (disptop > scroll_top + size + scroll_size)
567 disptop = scroll_top + size + scroll_size;
568 }
374330e2 569 }
374330e2 570}
571
572/*
573 * Move the cursor to a given position, clipping at boundaries. We
574 * may or may not want to clip at the scroll margin: marg_clip is 0
575 * not to, 1 to disallow _passing_ the margins, and 2 to disallow
576 * even _being_ outside the margins.
577 */
578static void move (int x, int y, int marg_clip) {
579 if (x < 0)
580 x = 0;
581 if (x >= cols)
582 x = cols-1;
583 if (marg_clip) {
584 if ((curs_y >= marg_t || marg_clip == 2) && y < marg_t)
585 y = marg_t;
586 if ((curs_y <= marg_b || marg_clip == 2) && y > marg_b)
587 y = marg_b;
588 }
589 if (y < 0)
590 y = 0;
591 if (y >= rows)
592 y = rows-1;
593 curs_x = x;
594 curs_y = y;
595 fix_cpos;
596 wrapnext = FALSE;
597}
598
599/*
600 * Save or restore the cursor and SGR mode.
601 */
602static void save_cursor(int save) {
603 if (save) {
604 save_x = curs_x;
605 save_y = curs_y;
606 save_attr = curr_attr;
607 save_cset = cset;
608 save_csattr = cset_attr[cset];
609 } else {
610 curs_x = save_x;
611 curs_y = save_y;
c9def1b8 612 /* Make sure the window hasn't shrunk since the save */
613 if (curs_x >= cols) curs_x = cols-1;
614 if (curs_y >= rows) curs_y = rows-1;
615
374330e2 616 curr_attr = save_attr;
617 cset = save_cset;
618 cset_attr[cset] = save_csattr;
619 fix_cpos;
e14a5a13 620 if (use_bce) erase_char = (' ' |(curr_attr&(ATTR_FGMASK|ATTR_BGMASK)));
374330e2 621 }
622}
623
624/*
625 * Erase a large portion of the screen: the whole screen, or the
626 * whole line, or parts thereof.
627 */
628static void erase_lots (int line_only, int from_begin, int to_end) {
629 unsigned long *startpos, *endpos;
630
631 if (line_only) {
632 startpos = cpos - curs_x;
c9def1b8 633 endpos = startpos + cols;
634 /* I've removed the +1 so that the Wide screen stuff is not
635 * removed when it shouldn't be.
636 */
374330e2 637 } else {
638 startpos = scrtop;
639 endpos = startpos + rows * (cols+1);
640 }
641 if (!from_begin)
642 startpos = cpos;
643 if (!to_end)
e14a5a13 644 endpos = cpos+1;
374330e2 645 check_selection (startpos, endpos);
e14a5a13 646
647 /* Clear screen also forces a full window redraw, just in case. */
648 if (startpos == scrtop && endpos == scrtop + rows * (cols+1))
649 term_invalidate();
650
374330e2 651 while (startpos < endpos)
e14a5a13 652 *startpos++ = erase_char;
374330e2 653}
654
655/*
656 * Insert or delete characters within the current line. n is +ve if
657 * insertion is desired, and -ve for deletion.
658 */
659static void insch (int n) {
660 int dir = (n < 0 ? -1 : +1);
661 int m;
662
663 n = (n < 0 ? -n : n);
664 if (n > cols - curs_x)
665 n = cols - curs_x;
666 m = cols - curs_x - n;
667 check_selection (cpos, cpos+n);
668 if (dir < 0) {
669 memmove (cpos, cpos+n, m*TSIZE);
670 while (n--)
e14a5a13 671 cpos[m++] = erase_char;
374330e2 672 } else {
673 memmove (cpos+n, cpos, m*TSIZE);
674 while (n--)
e14a5a13 675 cpos[n] = erase_char;
374330e2 676 }
677}
678
679/*
680 * Toggle terminal mode `mode' to state `state'. (`query' indicates
681 * whether the mode is a DEC private one or a normal one.)
682 */
683static void toggle_mode (int mode, int query, int state) {
684 if (query) switch (mode) {
685 case 1: /* application cursor keys */
686 app_cursor_keys = state;
687 break;
e14a5a13 688 case 2: /* VT52 mode */
689 vt52_mode = !state;
690 break;
374330e2 691 case 3: /* 80/132 columns */
692 deselect();
e14a5a13 693 request_resize (state ? 132 : 80, rows, 1);
694 reset_132 = state;
374330e2 695 break;
696 case 5: /* reverse video */
697 rvideo = state;
cabfd08c 698 seen_disp_event = TRUE;
e14a5a13 699 if (state) term_update();
374330e2 700 break;
701 case 6: /* DEC origin mode */
702 dec_om = state;
703 break;
704 case 7: /* auto wrap */
705 wrap = state;
706 break;
c9def1b8 707 case 8: /* auto key repeat */
708 repeat_off = !state;
709 break;
e14a5a13 710 case 25: /* enable/disable cursor */
ec55b220 711 compatibility2(OTHER,VT220);
e14a5a13 712 cursor_on = state;
713 seen_disp_event = TRUE;
714 break;
374330e2 715 case 47: /* alternate screen */
e14a5a13 716 compatibility(OTHER);
374330e2 717 deselect();
718 swap_screen (state);
719 disptop = scrtop;
720 break;
721 } else switch (mode) {
722 case 4: /* set insert mode */
e14a5a13 723 compatibility(VT102);
374330e2 724 insert = state;
725 break;
e14a5a13 726 case 12: /* set echo mode */
727 /*
728 * This may be very good in smcup and rmcup (or smkx & rmkx) if you
729 * have a long RTT and the telnet client/daemon doesn't understand
730 * linemode.
731 *
732 * DONT send TS_RECHO/TS_LECHO; the telnet daemon tries to fix the
733 * tty and _really_ confuses some programs.
734 */
ec55b220 735 compatibility2(OTHER,VT220);
e14a5a13 736 ldisc = (state? &ldisc_simple : &ldisc_term);
737 break;
c9def1b8 738 case 20: /* Return sends ... */
739 cr_lf_return = state;
740 break;
374330e2 741 }
742}
743
744/*
745 * Process an OSC sequence: set window title or icon name.
746 */
747static void do_osc(void) {
748 if (osc_w) {
749 while (osc_strlen--)
750 wordness[(unsigned char)osc_string[osc_strlen]] = esc_args[0];
751 } else {
752 osc_string[osc_strlen] = '\0';
753 switch (esc_args[0]) {
754 case 0:
755 case 1:
756 set_icon (osc_string);
757 if (esc_args[0] == 1)
758 break;
759 /* fall through: parameter 0 means set both */
760 case 2:
761 case 21:
762 set_title (osc_string);
763 break;
764 }
765 }
766}
767
768/*
769 * Remove everything currently in `inbuf' and stick it up on the
770 * in-memory display. There's a big state machine in here to
771 * process escape sequences...
772 */
773void term_out(void) {
c9def1b8 774 int c, inbuf_reap;
775
776static int beep_overload = 0;
777 int beep_count = 0;
778
779 for(inbuf_reap = 0; inbuf_reap < inbuf_head; inbuf_reap++)
780 {
781 c = inbuf[inbuf_reap];
374330e2 782
c9def1b8 783 /*
5fd04f07 784 * Optionally log the session traffic to a file. Useful for
785 * debugging and possibly also useful for actual logging.
786 */
e1c8e0ed 787 logtraffic((unsigned char)c, LGTYP_DEBUG);
788
e14a5a13 789 /* Note only VT220+ are 8-bit VT102 is seven bit, it shouldn't even
790 * be able to display 8-bit characters, but I'll let that go 'cause
791 * of i18n.
792 */
c9def1b8 793 if( ( (c&0x60) == 0 || c == '\177') &&
794 termstate < DO_CTRLS &&
e14a5a13 795 ( (c&0x80) == 0 || has_compat(VT220))) {
374330e2 796 switch (c) {
797 case '\005': /* terminal type query */
e14a5a13 798 /* Strictly speaking this is VT100 but a VT100 defaults to
799 * no response. Other terminals respond at their option.
800 *
801 * Don't put a CR in the default string as this tends to
802 * upset some weird software.
803 *
804 * An xterm returns "xterm" (5 characters)
805 */
806 compatibility(OTHER);
807 ldisc->send ("PuTTY", 5);
374330e2 808 break;
809 case '\007':
c9def1b8 810 beep_count++;
811 if(beep_count>6) beep_overload=1;
374330e2 812 disptop = scrtop;
374330e2 813 break;
814 case '\b':
c9def1b8 815 if (curs_x == 0 && curs_y == 0)
816 ;
817 else if (curs_x == 0 && curs_y > 0)
374330e2 818 curs_x = cols-1, curs_y--;
819 else if (wrapnext)
820 wrapnext = FALSE;
821 else
822 curs_x--;
823 fix_cpos;
cabfd08c 824 seen_disp_event = TRUE;
374330e2 825 break;
826 case '\016':
e14a5a13 827 compatibility(VT100);
374330e2 828 cset = 1;
829 break;
830 case '\017':
e14a5a13 831 compatibility(VT100);
374330e2 832 cset = 0;
833 break;
834 case '\033':
e14a5a13 835 if (vt52_mode)
836 termstate = VT52_ESC;
837 else {
838 compatibility(ANSIMIN);
839 termstate = SEEN_ESC;
840 }
374330e2 841 break;
842 case 0233:
e14a5a13 843 compatibility(VT220);
374330e2 844 termstate = SEEN_CSI;
845 esc_nargs = 1;
846 esc_args[0] = ARG_DEFAULT;
847 esc_query = FALSE;
848 break;
849 case 0235:
e14a5a13 850 compatibility(VT220);
374330e2 851 termstate = SEEN_OSC;
852 esc_args[0] = 0;
853 break;
854 case '\r':
855 curs_x = 0;
856 wrapnext = FALSE;
857 fix_cpos;
cabfd08c 858 seen_disp_event = TRUE;
c9def1b8 859 paste_hold = 0;
e1c8e0ed 860 logtraffic((unsigned char)c,LGTYP_ASCII);
374330e2 861 break;
862 case '\013':
863 case '\014':
e14a5a13 864 compatibility(VT100);
374330e2 865 case '\n':
866 if (curs_y == marg_b)
867 scroll (marg_t, marg_b, 1, TRUE);
868 else if (curs_y < rows-1)
869 curs_y++;
cabfd08c 870 if (cfg.lfhascr)
871 curs_x = 0;
374330e2 872 fix_cpos;
873 wrapnext = FALSE;
cabfd08c 874 seen_disp_event = 1;
c9def1b8 875 paste_hold = 0;
e1c8e0ed 876 logtraffic((unsigned char)c,LGTYP_ASCII);
374330e2 877 break;
878 case '\t':
374330e2 879 {
880 unsigned long *old_cpos = cpos;
c9def1b8 881 unsigned long *p = scrtop + curs_y * (cols+1) + cols;
882
883 do {
884 curs_x++;
885 } while (curs_x < cols-1 && !tabs[curs_x]);
886
887 if ((*p & LATTR_MODE) != LATTR_NORM)
888 {
889 if (curs_x >= cols/2)
890 curs_x = cols/2-1;
891 }
892 else
893 {
894 if (curs_x >= cols)
895 curs_x = cols-1;
896 }
897
374330e2 898 fix_cpos;
899 check_selection (old_cpos, cpos);
900 }
cabfd08c 901 seen_disp_event = TRUE;
374330e2 902 break;
1ec0fa4b 903 case '\177': /* Destructive backspace
ec55b220 904 This does nothing on a real VT100 */
905 compatibility(OTHER);
906 if (curs_x && !wrapnext) curs_x--;
907 wrapnext = FALSE;
908 fix_cpos;
909 *cpos = (' ' | curr_attr | ATTR_ASCII);
910 break;
cabfd08c 911 }
912 }
913 else switch (termstate) {
914 case TOPLEVEL:
8b811b12 915 /* Only graphic characters get this far, ctrls are stripped above */
1ec0fa4b 916 if (wrapnext && wrap) {
c9def1b8 917 cpos[1] |= ATTR_WRAPPED;
8b811b12 918 if (curs_y == marg_b)
919 scroll (marg_t, marg_b, 1, TRUE);
920 else if (curs_y < rows-1)
921 curs_y++;
922 curs_x = 0;
923 fix_cpos;
924 wrapnext = FALSE;
8b811b12 925 }
926 if (insert)
927 insch (1);
e14a5a13 928 if (selstate != NO_SELECTION)
929 check_selection (cpos, cpos+1);
930 switch (cset_attr[cset]) {
931 /* Linedraw characters are different from 'ESC ( B' only
932 * for a small range, for ones outside that range make sure
933 * we use the same font as well as the same encoding.
934 */
935 case ATTR_LINEDRW:
ec55b220 936 if (c<0x5f || c>0x7F)
e14a5a13 937 *cpos++ = xlat_tty2scr((unsigned char)c) | curr_attr |
938 ATTR_ASCII;
ec55b220 939 else if (c==0x5F)
940 *cpos++ = ' ' | curr_attr | ATTR_ASCII;
e14a5a13 941 else
942 *cpos++ = ((unsigned char)c) | curr_attr | ATTR_LINEDRW;
943 break;
ec55b220 944 case ATTR_GBCHR:
945 /* If UK-ASCII, make the '#' a LineDraw Pound */
946 if (c == '#') {
947 *cpos++ = '}' | curr_attr | ATTR_LINEDRW;
948 break;
949 }
950 /*FALLTHROUGH*/
e14a5a13 951 default:
e1c8e0ed 952 *cpos = xlat_tty2scr((unsigned char)c) | curr_attr |
e14a5a13 953 (c <= 0x7F ? cset_attr[cset] : ATTR_ASCII);
e1c8e0ed 954 logtraffic((unsigned char)c, LGTYP_ASCII);
955 cpos++;
e14a5a13 956 break;
957 }
8b811b12 958 curs_x++;
959 if (curs_x == cols) {
960 cpos--;
961 curs_x--;
1ec0fa4b 962 wrapnext = TRUE;
374330e2 963 }
8b811b12 964 seen_disp_event = 1;
374330e2 965 break;
cabfd08c 966
374330e2 967 case IGNORE_NEXT:
968 termstate = TOPLEVEL;
969 break;
970 case OSC_MAYBE_ST:
971 /*
972 * This state is virtually identical to SEEN_ESC, with the
973 * exception that we have an OSC sequence in the pipeline,
974 * and _if_ we see a backslash, we process it.
975 */
976 if (c == '\\') {
977 do_osc();
978 termstate = TOPLEVEL;
979 break;
980 }
981 /* else fall through */
982 case SEEN_ESC:
983 termstate = TOPLEVEL;
984 switch (c) {
374330e2 985 case ' ': /* some weird sequence? */
e14a5a13 986 compatibility(VT220);
374330e2 987 termstate = IGNORE_NEXT;
988 break;
989 case '[': /* enter CSI mode */
990 termstate = SEEN_CSI;
991 esc_nargs = 1;
992 esc_args[0] = ARG_DEFAULT;
993 esc_query = FALSE;
994 break;
995 case ']': /* xterm escape sequences */
e14a5a13 996 /* Compatibility is nasty here, xterm, linux, decterm yuk! */
997 compatibility(OTHER);
374330e2 998 termstate = SEEN_OSC;
999 esc_args[0] = 0;
1000 break;
1001 case '(': /* should set GL */
e14a5a13 1002 compatibility(VT100);
374330e2 1003 termstate = SET_GL;
1004 break;
1005 case ')': /* should set GR */
e14a5a13 1006 compatibility(VT100);
374330e2 1007 termstate = SET_GR;
1008 break;
1009 case '7': /* save cursor */
e14a5a13 1010 compatibility(VT100);
374330e2 1011 save_cursor (TRUE);
1012 break;
1013 case '8': /* restore cursor */
e14a5a13 1014 compatibility(VT100);
374330e2 1015 save_cursor (FALSE);
cabfd08c 1016 seen_disp_event = TRUE;
374330e2 1017 break;
1018 case '=':
e14a5a13 1019 compatibility(VT100);
374330e2 1020 app_keypad_keys = TRUE;
1021 break;
1022 case '>':
e14a5a13 1023 compatibility(VT100);
374330e2 1024 app_keypad_keys = FALSE;
1025 break;
1026 case 'D': /* exactly equivalent to LF */
e14a5a13 1027 compatibility(VT100);
374330e2 1028 if (curs_y == marg_b)
1029 scroll (marg_t, marg_b, 1, TRUE);
1030 else if (curs_y < rows-1)
1031 curs_y++;
1032 fix_cpos;
1033 wrapnext = FALSE;
cabfd08c 1034 seen_disp_event = TRUE;
374330e2 1035 break;
1036 case 'E': /* exactly equivalent to CR-LF */
e14a5a13 1037 compatibility(VT100);
374330e2 1038 curs_x = 0;
374330e2 1039 if (curs_y == marg_b)
1040 scroll (marg_t, marg_b, 1, TRUE);
1041 else if (curs_y < rows-1)
1042 curs_y++;
1043 fix_cpos;
1044 wrapnext = FALSE;
cabfd08c 1045 seen_disp_event = TRUE;
374330e2 1046 break;
1047 case 'M': /* reverse index - backwards LF */
e14a5a13 1048 compatibility(VT100);
374330e2 1049 if (curs_y == marg_t)
1050 scroll (marg_t, marg_b, -1, TRUE);
1051 else if (curs_y > 0)
1052 curs_y--;
1053 fix_cpos;
1054 wrapnext = FALSE;
cabfd08c 1055 seen_disp_event = TRUE;
374330e2 1056 break;
1057 case 'Z': /* terminal type query */
e14a5a13 1058 compatibility(VT100);
c9def1b8 1059 ldisc->send (id_string, strlen(id_string));
374330e2 1060 break;
1061 case 'c': /* restore power-on settings */
e14a5a13 1062 compatibility(VT100);
374330e2 1063 power_on();
e14a5a13 1064 if (reset_132) {
1065 request_resize (80, rows, 1);
1066 reset_132 = 0;
1067 }
374330e2 1068 fix_cpos;
1069 disptop = scrtop;
cabfd08c 1070 seen_disp_event = TRUE;
374330e2 1071 break;
1072 case '#': /* ESC # 8 fills screen with Es :-) */
e14a5a13 1073 compatibility(VT100);
374330e2 1074 termstate = SEEN_ESCHASH;
1075 break;
1076 case 'H': /* set a tab */
e14a5a13 1077 compatibility(VT100);
374330e2 1078 tabs[curs_x] = TRUE;
1079 break;
1080 }
1081 break;
1082 case SEEN_CSI:
1083 termstate = TOPLEVEL; /* default */
8b811b12 1084 if( isdigit(c) )
1085 {
374330e2 1086 if (esc_nargs <= ARGS_MAX) {
1087 if (esc_args[esc_nargs-1] == ARG_DEFAULT)
1088 esc_args[esc_nargs-1] = 0;
1089 esc_args[esc_nargs-1] =
1090 10 * esc_args[esc_nargs-1] + c - '0';
1091 }
1092 termstate = SEEN_CSI;
8b811b12 1093 }
1094 else if( c == ';' )
1095 {
374330e2 1096 if (++esc_nargs <= ARGS_MAX)
1097 esc_args[esc_nargs-1] = ARG_DEFAULT;
1098 termstate = SEEN_CSI;
8b811b12 1099 }
1100 else if( c < '@' )
1101 {
1102 if( esc_query ) esc_query = -1;
1103 else if( c == '?' ) esc_query = TRUE;
1104 else esc_query = c;
374330e2 1105 termstate = SEEN_CSI;
8b811b12 1106 }
1107 else switch (ANSI(c,esc_query)) {
374330e2 1108 case 'A': /* move up N lines */
1109 move (curs_x, curs_y - def(esc_args[0], 1), 1);
cabfd08c 1110 seen_disp_event = TRUE;
374330e2 1111 break;
e14a5a13 1112 case 'e': /* move down N lines */
1113 compatibility(ANSI);
1114 case 'B':
374330e2 1115 move (curs_x, curs_y + def(esc_args[0], 1), 1);
cabfd08c 1116 seen_disp_event = TRUE;
374330e2 1117 break;
e14a5a13 1118 case 'a': /* move right N cols */
1119 compatibility(ANSI);
1120 case 'C':
374330e2 1121 move (curs_x + def(esc_args[0], 1), curs_y, 1);
cabfd08c 1122 seen_disp_event = TRUE;
374330e2 1123 break;
1124 case 'D': /* move left N cols */
1125 move (curs_x - def(esc_args[0], 1), curs_y, 1);
cabfd08c 1126 seen_disp_event = TRUE;
374330e2 1127 break;
1128 case 'E': /* move down N lines and CR */
e14a5a13 1129 compatibility(ANSI);
374330e2 1130 move (0, curs_y + def(esc_args[0], 1), 1);
cabfd08c 1131 seen_disp_event = TRUE;
374330e2 1132 break;
1133 case 'F': /* move up N lines and CR */
e14a5a13 1134 compatibility(ANSI);
374330e2 1135 move (0, curs_y - def(esc_args[0], 1), 1);
cabfd08c 1136 seen_disp_event = TRUE;
374330e2 1137 break;
1138 case 'G': case '`': /* set horizontal posn */
e14a5a13 1139 compatibility(ANSI);
374330e2 1140 move (def(esc_args[0], 1) - 1, curs_y, 0);
cabfd08c 1141 seen_disp_event = TRUE;
374330e2 1142 break;
1143 case 'd': /* set vertical posn */
e14a5a13 1144 compatibility(ANSI);
374330e2 1145 move (curs_x, (dec_om ? marg_t : 0) + def(esc_args[0], 1) - 1,
1146 (dec_om ? 2 : 0));
cabfd08c 1147 seen_disp_event = TRUE;
374330e2 1148 break;
1149 case 'H': case 'f': /* set horz and vert posns at once */
1150 if (esc_nargs < 2)
1151 esc_args[1] = ARG_DEFAULT;
1152 move (def(esc_args[1], 1) - 1,
1153 (dec_om ? marg_t : 0) + def(esc_args[0], 1) - 1,
1154 (dec_om ? 2 : 0));
cabfd08c 1155 seen_disp_event = TRUE;
374330e2 1156 break;
1157 case 'J': /* erase screen or parts of it */
1158 {
1159 unsigned int i = def(esc_args[0], 0) + 1;
1160 if (i > 3)
1161 i = 0;
1162 erase_lots(FALSE, !!(i & 2), !!(i & 1));
1163 }
1164 disptop = scrtop;
cabfd08c 1165 seen_disp_event = TRUE;
374330e2 1166 break;
1167 case 'K': /* erase line or parts of it */
1168 {
1169 unsigned int i = def(esc_args[0], 0) + 1;
1170 if (i > 3)
1171 i = 0;
1172 erase_lots(TRUE, !!(i & 2), !!(i & 1));
1173 }
cabfd08c 1174 seen_disp_event = TRUE;
374330e2 1175 break;
1176 case 'L': /* insert lines */
e14a5a13 1177 compatibility(VT102);
374330e2 1178 if (curs_y <= marg_b)
1179 scroll (curs_y, marg_b, -def(esc_args[0], 1), FALSE);
cabfd08c 1180 seen_disp_event = TRUE;
374330e2 1181 break;
1182 case 'M': /* delete lines */
e14a5a13 1183 compatibility(VT102);
374330e2 1184 if (curs_y <= marg_b)
cabfd08c 1185 scroll (curs_y, marg_b, def(esc_args[0], 1), TRUE);
1186 seen_disp_event = TRUE;
374330e2 1187 break;
1188 case '@': /* insert chars */
e14a5a13 1189 /* XXX VTTEST says this is vt220, vt510 manual says vt102 */
1190 compatibility(VT102);
374330e2 1191 insch (def(esc_args[0], 1));
cabfd08c 1192 seen_disp_event = TRUE;
374330e2 1193 break;
1194 case 'P': /* delete chars */
e14a5a13 1195 compatibility(VT102);
374330e2 1196 insch (-def(esc_args[0], 1));
cabfd08c 1197 seen_disp_event = TRUE;
374330e2 1198 break;
1199 case 'c': /* terminal type query */
e14a5a13 1200 compatibility(VT100);
1201 /* This is the response for a VT102 */
c9def1b8 1202 ldisc->send (id_string, strlen(id_string));
374330e2 1203 break;
1204 case 'n': /* cursor position query */
1205 if (esc_args[0] == 6) {
1206 char buf[32];
1207 sprintf (buf, "\033[%d;%dR", curs_y + 1, curs_x + 1);
5bc238bb 1208 ldisc->send (buf, strlen(buf));
374330e2 1209 }
e14a5a13 1210 else if (esc_args[0] == 5) {
e14a5a13 1211 ldisc->send ("\033[0n", 4);
1212 }
374330e2 1213 break;
e14a5a13 1214 case 'h': /* toggle modes to high */
8b811b12 1215 case ANSI_QUE('h'):
e14a5a13 1216 compatibility(VT100);
1217 {
1218 int i;
1219 for (i=0; i<esc_nargs; i++)
1220 toggle_mode (esc_args[i], esc_query, TRUE);
1221 }
374330e2 1222 break;
e14a5a13 1223 case 'l': /* toggle modes to low */
8b811b12 1224 case ANSI_QUE('l'):
e14a5a13 1225 compatibility(VT100);
1226 {
1227 int i;
1228 for (i=0; i<esc_nargs; i++)
1229 toggle_mode (esc_args[i], esc_query, FALSE);
1230 }
374330e2 1231 break;
1232 case 'g': /* clear tabs */
e14a5a13 1233 compatibility(VT100);
374330e2 1234 if (esc_nargs == 1) {
1235 if (esc_args[0] == 0) {
1236 tabs[curs_x] = FALSE;
1237 } else if (esc_args[0] == 3) {
1238 int i;
1239 for (i = 0; i < cols; i++)
1240 tabs[i] = FALSE;
1241 }
1242 }
1243 break;
1244 case 'r': /* set scroll margins */
e14a5a13 1245 compatibility(VT100);
8b811b12 1246 if (esc_nargs <= 2) {
374330e2 1247 int top, bot;
7e394092 1248 top = def(esc_args[0], 1) - 1;
1249 bot = (esc_nargs <= 1 || esc_args[1] == 0 ? rows :
1250 def(esc_args[1], rows)) - 1;
374330e2 1251 if (bot >= rows)
1252 bot = rows-1;
7e394092 1253 /* VTTEST Bug 9 - if region is less than 2 lines
1254 * don't change region.
1255 */
83ea993b 1256 if (bot-top > 0) {
374330e2 1257 marg_t = top;
1258 marg_b = bot;
1259 curs_x = 0;
1260 /*
1261 * I used to think the cursor should be
1262 * placed at the top of the newly marginned
1263 * area. Apparently not: VMS TPU falls over
1264 * if so.
e14a5a13 1265 *
1266 * Well actually it should for Origin mode - RDB
374330e2 1267 */
e14a5a13 1268 curs_y = (dec_om ? marg_t : 0);
374330e2 1269 fix_cpos;
cabfd08c 1270 seen_disp_event = TRUE;
374330e2 1271 }
1272 }
1273 break;
1274 case 'm': /* set graphics rendition */
1275 {
e14a5a13 1276 /*
1277 * A VT100 without the AVO only had one attribute, either
1278 * underline or reverse video depending on the cursor type,
1279 * this was selected by CSI 7m.
1280 *
1281 * case 2:
1282 * This is DIM on the VT100-AVO and VT102
1283 * case 5:
1284 * This is BLINK on the VT100-AVO and VT102+
1285 * case 8:
1286 * This is INVIS on the VT100-AVO and VT102
1287 * case 21:
1288 * This like 22 disables BOLD, DIM and INVIS
1289 *
1290 * The ANSI colours appear on any terminal that has colour
1291 * (obviously) but the interaction between sgr0 and the
1292 * colours varies but is usually related to the background
1293 * colour erase item.
1294 * The interaction between colour attributes and the mono
1295 * ones is also very implementation dependent.
1296 *
1297 * The 39 and 49 attributes are likely to be unimplemented.
1298 */
374330e2 1299 int i;
1300 for (i=0; i<esc_nargs; i++) {
1301 switch (def(esc_args[i], 0)) {
1302 case 0: /* restore defaults */
1303 curr_attr = ATTR_DEFAULT; break;
1304 case 1: /* enable bold */
e14a5a13 1305 compatibility(VT100AVO);
374330e2 1306 curr_attr |= ATTR_BOLD; break;
374330e2 1307 case 21: /* (enable double underline) */
e14a5a13 1308 compatibility(OTHER);
1309 case 4: /* enable underline */
1310 compatibility(VT100AVO);
374330e2 1311 curr_attr |= ATTR_UNDER; break;
e14a5a13 1312 case 5: /* enable blink */
1313 compatibility(VT100AVO);
1314 curr_attr |= ATTR_BLINK; break;
374330e2 1315 case 7: /* enable reverse video */
1316 curr_attr |= ATTR_REVERSE; break;
1317 case 22: /* disable bold */
ec55b220 1318 compatibility2(OTHER,VT220);
374330e2 1319 curr_attr &= ~ATTR_BOLD; break;
1320 case 24: /* disable underline */
ec55b220 1321 compatibility2(OTHER,VT220);
374330e2 1322 curr_attr &= ~ATTR_UNDER; break;
e14a5a13 1323 case 25: /* disable blink */
ec55b220 1324 compatibility2(OTHER,VT220);
e14a5a13 1325 curr_attr &= ~ATTR_BLINK; break;
374330e2 1326 case 27: /* disable reverse video */
ec55b220 1327 compatibility2(OTHER,VT220);
374330e2 1328 curr_attr &= ~ATTR_REVERSE; break;
1329 case 30: case 31: case 32: case 33:
1330 case 34: case 35: case 36: case 37:
1331 /* foreground */
1332 curr_attr &= ~ATTR_FGMASK;
1333 curr_attr |= (esc_args[i] - 30) << ATTR_FGSHIFT;
1334 break;
1335 case 39: /* default-foreground */
1336 curr_attr &= ~ATTR_FGMASK;
1337 curr_attr |= ATTR_DEFFG;
1338 break;
1339 case 40: case 41: case 42: case 43:
1340 case 44: case 45: case 46: case 47:
1341 /* background */
1342 curr_attr &= ~ATTR_BGMASK;
1343 curr_attr |= (esc_args[i] - 40) << ATTR_BGSHIFT;
1344 break;
1345 case 49: /* default-background */
1346 curr_attr &= ~ATTR_BGMASK;
1347 curr_attr |= ATTR_DEFBG;
1348 break;
1349 }
1350 }
e14a5a13 1351 if (use_bce)
c9def1b8 1352 erase_char =
1353 (' '|
1354 (curr_attr&(ATTR_FGMASK|ATTR_BGMASK|ATTR_BLINK))
1355 );
374330e2 1356 }
1357 break;
1358 case 's': /* save cursor */
1359 save_cursor (TRUE);
1360 break;
1361 case 'u': /* restore cursor */
1362 save_cursor (FALSE);
cabfd08c 1363 seen_disp_event = TRUE;
374330e2 1364 break;
1365 case 't': /* set page size - ie window height */
e14a5a13 1366 /*
1367 * VT340/VT420 sequence DECSLPP, DEC only allows values
1368 * 24/25/36/48/72/144 other emulators (eg dtterm) use
1369 * illegal values (eg first arg 1..9) for window changing
1370 * and reports.
1371 */
1372 compatibility(VT340TEXT);
1373 if (esc_nargs<=1 && (esc_args[0]<1 || esc_args[0]>=24)) {
c9def1b8 1374 request_resize (cols, def(esc_args[0], 24), 0);
e14a5a13 1375 deselect();
1376 }
1377 break;
1378 case ANSI('|', '*'):
1379 /* VT420 sequence DECSNLS
1380 * Set number of lines on screen
1381 * VT420 uses VGA like hardware and can support any size in
1382 * reasonable range (24..49 AIUI) with no default specified.
1383 */
1384 compatibility(VT420);
c9def1b8 1385 if (esc_nargs==1 && esc_args[0]>0) {
1386 request_resize (cols, def(esc_args[0], cfg.height), 0);
e14a5a13 1387 deselect();
1388 }
1389 break;
1390 case ANSI('|', '$'):
1391 /* VT340/VT420 sequence DECSCPP
1392 * Set number of columns per page
1393 * Docs imply range is only 80 or 132, but I'll allow any.
1394 */
1395 compatibility(VT340TEXT);
1396 if (esc_nargs<=1) {
c9def1b8 1397 request_resize (def(esc_args[0], cfg.width), rows, 0);
e14a5a13 1398 deselect();
1399 }
374330e2 1400 break;
1401 case 'X': /* write N spaces w/o moving cursor */
e14a5a13 1402 /* XXX VTTEST says this is vt220, vt510 manual says vt100 */
c9def1b8 1403 compatibility(ANSIMIN);
374330e2 1404 {
1405 int n = def(esc_args[0], 1);
1406 unsigned long *p = cpos;
1407 if (n > cols - curs_x)
1408 n = cols - curs_x;
1409 check_selection (cpos, cpos+n);
1410 while (n--)
e14a5a13 1411 *p++ = erase_char;
cabfd08c 1412 seen_disp_event = TRUE;
374330e2 1413 }
1414 break;
1415 case 'x': /* report terminal characteristics */
e14a5a13 1416 compatibility(VT100);
374330e2 1417 {
1418 char buf[32];
1419 int i = def(esc_args[0], 0);
1420 if (i == 0 || i == 1) {
1421 strcpy (buf, "\033[2;1;1;112;112;1;0x");
1422 buf[2] += i;
5bc238bb 1423 ldisc->send (buf, 20);
374330e2 1424 }
1425 }
1426 break;
e14a5a13 1427 case ANSI('L','='):
1428 compatibility(OTHER);
1429 use_bce = (esc_args[0]<=0);
1430 erase_char = ERASE_CHAR;
1431 if (use_bce)
1432 erase_char = (' '|(curr_attr&(ATTR_FGMASK|ATTR_BGMASK)));
1433 break;
c9def1b8 1434 case ANSI('E','='):
1435 compatibility(OTHER);
1436 blink_is_real = (esc_args[0]>=1);
1437 break;
e14a5a13 1438 case ANSI('p','"'):
1439 /* Allow the host to make this emulator a 'perfect' VT102.
1440 * This first appeared in the VT220, but we do need to get
1441 * back to PuTTY mode so I won't check it.
1442 *
ec55b220 1443 * The arg in 40..42 are a PuTTY extension.
1444 * The 2nd arg, 8bit vs 7bit is not checked.
e14a5a13 1445 *
1446 * Setting VT102 mode should also change the Fkeys to
1447 * generate PF* codes as a real VT102 has no Fkeys.
1448 * The VT220 does this, F11..F13 become ESC,BS,LF other Fkeys
1449 * send nothing.
1450 *
1451 * Note ESC c will NOT change this!
1452 */
1453
ec55b220 1454 switch (esc_args[0]) {
1455 case 61: compatibility_level &= ~TM_VTXXX;
1456 compatibility_level |= TM_VT102; break;
1457 case 62: compatibility_level &= ~TM_VTXXX;
1458 compatibility_level |= TM_VT220; break;
1459
1460 default: if( esc_args[0] > 60 && esc_args[0] < 70 )
1461 compatibility_level |= TM_VTXXX;
1462 break;
1463
1464 case 40: compatibility_level &= TM_VTXXX; break;
1465 case 41: compatibility_level = TM_PUTTY; break;
1466 case 42: compatibility_level = TM_SCOANSI; break;
1467
1468 case ARG_DEFAULT:
1469 compatibility_level = TM_PUTTY; break;
1470 case 50: break;
1471 }
1472
1473 /* Change the response to CSI c */
1474 if (esc_args[0] == 50) {
1475 int i;
1476 char lbuf[64];
1477 strcpy(id_string, "\033[?");
1478 for (i=1; i<esc_nargs; i++) {
1479 if (i!=1) strcat(id_string, ";");
1480 sprintf(lbuf, "%d", esc_args[i]);
1481 strcat(id_string, lbuf);
1482 }
1483 strcat(id_string, "c");
1484 }
1485
1486#if 0
1487 /* Is this a good idea ?
1488 * Well we should do a soft reset at this point ...
1489 */
1490 if (!has_compat(VT420) && has_compat(VT100)) {
1491 if (reset_132) request_resize (132, 24, 1);
1492 else request_resize ( 80, 24, 1);
1493 }
1494#endif
e14a5a13 1495 break;
374330e2 1496 }
1497 break;
1498 case SET_GL:
1499 case SET_GR:
e14a5a13 1500 /* VT100 only here, checked above */
374330e2 1501 switch (c) {
1502 case 'A':
1503 cset_attr[termstate == SET_GL ? 0 : 1] = ATTR_GBCHR;
1504 break;
1505 case '0':
1506 cset_attr[termstate == SET_GL ? 0 : 1] = ATTR_LINEDRW;
1507 break;
e14a5a13 1508 case 'B':
374330e2 1509 default: /* specifically, 'B' */
1510 cset_attr[termstate == SET_GL ? 0 : 1] = ATTR_ASCII;
1511 break;
1512 }
e14a5a13 1513 if( !has_compat(VT220) || c != '%' )
8b811b12 1514 termstate = TOPLEVEL;
374330e2 1515 break;
1516 case SEEN_OSC:
1517 osc_w = FALSE;
1518 switch (c) {
374330e2 1519 case 'P': /* Linux palette sequence */
1520 termstate = SEEN_OSC_P;
1521 osc_strlen = 0;
1522 break;
1523 case 'R': /* Linux palette reset */
1524 palette_reset();
1525 term_invalidate();
1526 termstate = TOPLEVEL;
1527 break;
1528 case 'W': /* word-set */
1529 termstate = SEEN_OSC_W;
1530 osc_w = TRUE;
1531 break;
1532 case '0': case '1': case '2': case '3': case '4':
1533 case '5': case '6': case '7': case '8': case '9':
1534 esc_args[0] = 10 * esc_args[0] + c - '0';
1535 break;
1536 case 'L':
1537 /*
1538 * Grotty hack to support xterm and DECterm title
1539 * sequences concurrently.
1540 */
1541 if (esc_args[0] == 2) {
1542 esc_args[0] = 1;
1543 break;
1544 }
1545 /* else fall through */
1546 default:
1547 termstate = OSC_STRING;
1548 osc_strlen = 0;
1549 }
1550 break;
1551 case OSC_STRING:
8b811b12 1552 /*
1553 * This OSC stuff is EVIL. It takes just one character to get into
1554 * sysline mode and it's not initially obvious how to get out.
1555 * So I've added CR and LF as string aborts.
1556 * This shouldn't effect compatibility as I believe embedded
1557 * control characters are supposed to be interpreted (maybe?)
1558 * and they don't display anything useful anyway.
1559 *
1560 * -- RDB
1561 */
1562 if (c == '\n' || c == '\r') {
1563 termstate = TOPLEVEL;
1564 } else if (c == 0234 || c == '\007' ) {
374330e2 1565 /*
1566 * These characters terminate the string; ST and BEL
1567 * terminate the sequence and trigger instant
1568 * processing of it, whereas ESC goes back to SEEN_ESC
1569 * mode unless it is followed by \, in which case it is
1570 * synonymous with ST in the first place.
1571 */
1572 do_osc();
1573 termstate = TOPLEVEL;
1574 } else if (c == '\033')
1575 termstate = OSC_MAYBE_ST;
1576 else if (osc_strlen < OSC_STR_MAX)
1577 osc_string[osc_strlen++] = c;
1578 break;
1579 case SEEN_OSC_P:
1580 {
1581 int max = (osc_strlen == 0 ? 21 : 16);
1582 int val;
1583 if (c >= '0' && c <= '9')
1584 val = c - '0';
1585 else if (c >= 'A' && c <= 'A'+max-10)
1586 val = c - 'A' + 10;
1587 else if (c >= 'a' && c <= 'a'+max-10)
1588 val = c - 'a' + 10;
1589 else
1590 termstate = TOPLEVEL;
1591 osc_string[osc_strlen++] = val;
1592 if (osc_strlen >= 7) {
1593 palette_set (osc_string[0],
1594 osc_string[1] * 16 + osc_string[2],
1595 osc_string[3] * 16 + osc_string[4],
1596 osc_string[5] * 16 + osc_string[6]);
1597 term_invalidate();
1598 termstate = TOPLEVEL;
1599 }
1600 }
1601 break;
1602 case SEEN_OSC_W:
1603 switch (c) {
374330e2 1604 case '0': case '1': case '2': case '3': case '4':
1605 case '5': case '6': case '7': case '8': case '9':
1606 esc_args[0] = 10 * esc_args[0] + c - '0';
1607 break;
1608 default:
1609 termstate = OSC_STRING;
1610 osc_strlen = 0;
1611 }
1612 break;
1613 case SEEN_ESCHASH:
c9def1b8 1614 {
1615 unsigned long *p;
1616 unsigned long nlattr;
1617 int n;
1618
1619 switch (c) {
1620 case '8':
1621 p = scrtop;
1622 n = rows * (cols+1);
1623 while (n--)
1624 *p++ = ATTR_DEFAULT | 'E';
1625 disptop = scrtop;
1626 seen_disp_event = TRUE;
1627 check_selection (scrtop, scrtop + rows * (cols+1));
1628 break;
1629
1630 case '3': nlattr = LATTR_TOP; if(0) {
1631 case '4': nlattr = LATTR_BOT; } if(0) {
1632 case '5': nlattr = LATTR_NORM; } if(0) {
1633 case '6': nlattr = LATTR_WIDE; }
1634
1635 p = scrtop + curs_y * (cols+1) + cols;
1636 *p &= ~LATTR_MODE;
1637 *p |= nlattr;
1638 }
374330e2 1639 }
1640 termstate = TOPLEVEL;
1641 break;
e14a5a13 1642 case VT52_ESC:
1643 termstate = TOPLEVEL;
1644 seen_disp_event = TRUE;
1645 switch (c) {
1646 case 'A':
1647 move (curs_x, curs_y - 1, 1);
1648 break;
1649 case 'B':
1650 move (curs_x, curs_y + 1, 1);
1651 break;
1652 case 'C':
1653 move (curs_x + 1, curs_y, 1);
1654 break;
1655 case 'D':
1656 move (curs_x - 1, curs_y, 1);
1657 break;
1658 case 'F':
1659 cset_attr[cset=0] = ATTR_LINEDRW;
1660 break;
1661 case 'G':
1662 cset_attr[cset=0] = ATTR_ASCII;
1663 break;
1664 case 'H':
1665 move (0, 0, 0);
1666 break;
1667 case 'I':
1668 if (curs_y == 0)
1669 scroll (0, rows-1, -1, TRUE);
1670 else if (curs_y > 0)
1671 curs_y--;
1672 fix_cpos;
1673 wrapnext = FALSE;
1674 break;
1675 case 'J':
1676 erase_lots(FALSE, FALSE, TRUE);
1677 disptop = scrtop;
1678 break;
1679 case 'K':
1680 erase_lots(TRUE, FALSE, TRUE);
1681 break;
1682 case 'V':
1683 /* XXX Print cursor line */
1684 break;
1685 case 'W':
1686 /* XXX Start controller mode */
1687 break;
1688 case 'X':
1689 /* XXX Stop controller mode */
1690 break;
1691 case 'Y':
1692 termstate = VT52_Y1;
1693 break;
1694 case 'Z':
1695 ldisc->send ("\033/Z", 3);
1696 break;
1697 case '=':
ec55b220 1698 app_keypad_keys = TRUE;
e14a5a13 1699 break;
1700 case '>':
ec55b220 1701 app_keypad_keys = FALSE;
e14a5a13 1702 break;
1703 case '<':
1704 /* XXX This should switch to VT100 mode not current or default
1705 * VT mode. But this will only have effect in a VT220+
1706 * emulation.
1707 */
1708 vt52_mode = FALSE;
1709 break;
1710 case '^':
1711 /* XXX Enter auto print mode */
1712 break;
1713 case '_':
1714 /* XXX Exit auto print mode */
1715 break;
1716 case ']':
1717 /* XXX Print screen */
1718 break;
1719 }
1720 break;
1721 case VT52_Y1:
1722 termstate = VT52_Y2;
1723 move(curs_x, c-' ', 0);
1724 break;
1725 case VT52_Y2:
1726 termstate = TOPLEVEL;
1727 move(c-' ', curs_y, 0);
1728 break;
374330e2 1729 }
e14a5a13 1730 if (selstate != NO_SELECTION)
1731 check_selection (cpos, cpos+1);
374330e2 1732 }
c9def1b8 1733 inbuf_head = 0;
1734
1735 if (beep_overload)
1736 {
1737 if(!beep_count) beep_overload=0;
1738 }
1739 else if(beep_count && beep_count<5 && cfg.beep)
1740 beep(beep_count/3);
374330e2 1741}
1742
1743/*
1744 * Compare two lines to determine whether they are sufficiently
1745 * alike to scroll-optimise one to the other. Return the degree of
1746 * similarity.
1747 */
1748static int linecmp (unsigned long *a, unsigned long *b) {
1749 int i, n;
1750
1751 for (i=n=0; i < cols; i++)
1752 n += (*a++ == *b++);
1753 return n;
1754}
1755
1756/*
1757 * Given a context, update the window. Out of paranoia, we don't
1758 * allow WM_PAINT responses to do scrolling optimisations.
1759 */
ec8679e9 1760static void do_paint (Context ctx, int may_optimise){
374330e2 1761 int i, j, start, our_curs_y;
1762 unsigned long attr, rv, cursor;
1763 char ch[1024];
1764
e14a5a13 1765 if (cursor_on) {
1766 if (has_focus) {
217dceef 1767 if (blinker || !cfg.blink_cur)
1768 cursor = ATTR_ACTCURS;
1769 else
1770 cursor = 0;
e14a5a13 1771 }
1772 else
1773 cursor = ATTR_PASCURS;
4e30ff69 1774 if (wrapnext)
1775 cursor |= ATTR_RIGHTCURS;
e14a5a13 1776 }
1777 else cursor = 0;
374330e2 1778 rv = (rvideo ? ATTR_REVERSE : 0);
1779 our_curs_y = curs_y + (scrtop - disptop) / (cols+1);
1780
1781 for (i=0; i<rows; i++) {
1782 int idx = i*(cols+1);
c9def1b8 1783 int lattr = (disptop[idx+cols] & LATTR_MODE);
374330e2 1784 for (j=0; j<=cols; j++,idx++) {
1785 unsigned long *d = disptop+idx;
4e30ff69 1786 wanttext[idx] = lattr | (((*d &~ ATTR_WRAPPED) ^ rv
374330e2 1787 ^ (selstart <= d && d < selend ?
1788 ATTR_REVERSE : 0)) |
1789 (i==our_curs_y && j==curs_x ? cursor : 0));
c9def1b8 1790 if (blink_is_real) {
1791 if (has_focus && tblinker && (wanttext[idx]&ATTR_BLINK) )
1792 {
1793 wanttext[idx] &= ATTR_MASK;
1794 wanttext[idx] += ' ';
1795 }
1796 wanttext[idx] &= ~ATTR_BLINK;
1797 }
374330e2 1798 }
1799 }
1800
1801 /*
1802 * We would perform scrolling optimisations in here, if they
1803 * didn't have a nasty tendency to cause the whole sodding
1804 * program to hang for a second at speed-critical moments.
1805 * We'll leave it well alone...
1806 */
1807
1808 for (i=0; i<rows; i++) {
1809 int idx = i*(cols+1);
c9def1b8 1810 int lattr = (wanttext[idx+cols] & LATTR_MODE);
374330e2 1811 start = -1;
1812 for (j=0; j<=cols; j++,idx++) {
1813 unsigned long t = wanttext[idx];
1814 int needs_update = (j < cols && t != disptext[idx]);
1815 int keep_going = (start != -1 && needs_update &&
1816 (t & ATTR_MASK) == attr &&
1817 j-start < sizeof(ch));
1818 if (start != -1 && !keep_going) {
c9def1b8 1819 do_text (ctx, start, i, ch, j-start, attr, lattr);
374330e2 1820 start = -1;
1821 }
1822 if (needs_update) {
1823 if (start == -1) {
1824 start = j;
1825 attr = t & ATTR_MASK;
1826 }
1827 ch[j-start] = (char) (t & CHAR_MASK);
1828 }
1829 disptext[idx] = t;
1830 }
1831 }
1832}
1833
1834/*
e14a5a13 1835 * Flick the switch that says if blinking things should be shown or hidden.
1836 */
1837
1838void term_blink(int flg) {
1839static long last_blink = 0;
c9def1b8 1840static long last_tblink = 0;
e14a5a13 1841 long now, blink_diff;
1842
c9def1b8 1843 now = GetTickCount();
1844 blink_diff = now-last_tblink;
1845
1846 /* Make sure the text blinks no more than 2Hz */
1847 if (blink_diff<0 || blink_diff>450)
1848 {
1849 last_tblink = now;
1850 tblinker = !tblinker;
1851 }
1852
e14a5a13 1853 if (flg) {
1854 blinker = 1;
c9def1b8 1855 last_blink = now;
e14a5a13 1856 return;
1857 }
e14a5a13 1858
1859 blink_diff = now-last_blink;
1860
1861 /* Make sure the cursor blinks no more than 2Hz */
1862 if (blink_diff>=0 && blink_diff<450)
1863 return;
1864
1865 last_blink = now;
1866 blinker = !blinker;
1867}
1868
1869/*
374330e2 1870 * Invalidate the whole screen so it will be repainted in full.
1871 */
1872void term_invalidate(void) {
1873 int i;
1874
1875 for (i=0; i<rows*(cols+1); i++)
1876 disptext[i] = ATTR_INVALID;
1877}
1878
1879/*
1880 * Paint the window in response to a WM_PAINT message.
1881 */
1882void term_paint (Context ctx, int l, int t, int r, int b) {
1883 int i, j, left, top, right, bottom;
1884
1885 left = l / font_width;
1886 right = (r - 1) / font_width;
1887 top = t / font_height;
1888 bottom = (b - 1) / font_height;
e42ad027 1889 for (i = top; i <= bottom && i < rows ; i++)
c9def1b8 1890 {
1891 if ( (disptext[i*(cols+1)+cols]&LATTR_MODE) == LATTR_NORM)
1892 for (j = left; j <= right && j < cols ; j++)
1893 disptext[i*(cols+1)+j] = ATTR_INVALID;
1894 else
1895 for (j = left/2; j <= right/2+1 && j < cols ; j++)
1896 disptext[i*(cols+1)+j] = ATTR_INVALID;
1897 }
374330e2 1898
e14a5a13 1899 /* This should happen soon enough, also for some reason it sometimes
1900 * fails to actually do anything when re-sizing ... painting the wrong
1901 * window perhaps ?
374330e2 1902 do_paint (ctx, FALSE);
e14a5a13 1903 */
374330e2 1904}
1905
1906/*
1907 * Attempt to scroll the scrollback. The second parameter gives the
1908 * position we want to scroll to; the first is +1 to denote that
1909 * this position is relative to the beginning of the scrollback, -1
1910 * to denote it is relative to the end, and 0 to denote that it is
1911 * relative to the current position.
1912 */
1913void term_scroll (int rel, int where) {
1914 int n = where * (cols+1);
1915
1916 disptop = (rel < 0 ? scrtop :
1917 rel > 0 ? sbtop : disptop) + n;
1918 if (disptop < sbtop)
1919 disptop = sbtop;
1920 if (disptop > scrtop)
1921 disptop = scrtop;
1922 update_sbar();
1923 term_update();
1924}
1925
508a6084 1926static void clipme(unsigned long *top, unsigned long *bottom, char *workbuf) {
bc1235d4 1927 char *wbptr; /* where next char goes within workbuf */
1928 int wblen = 0; /* workbuf len */
1929 int buflen; /* amount of memory allocated to workbuf */
1930
1931 if ( workbuf != NULL ) { /* user supplied buffer? */
1932 buflen = -1; /* assume buffer passed in is big enough */
1933 wbptr = workbuf; /* start filling here */
1934 }
1935 else
1936 buflen = 0; /* No data is available yet */
1937
1938 while (top < bottom) {
1939 int nl = FALSE;
1940 unsigned long *lineend = top - (top-text) % (cols+1) + cols;
1941 unsigned long *nlpos = lineend;
1942
1943 if (!(*nlpos & ATTR_WRAPPED)) {
1944 while ((nlpos[-1] & CHAR_MASK) == 0x20 && nlpos > top)
1945 nlpos--;
1946 if (nlpos < bottom)
1947 nl = TRUE;
1948 }
1949 while (top < nlpos && top < bottom)
1950 {
1951#if 0
1952 /* VT Specials -> ISO8859-1 */
1953 static const char poorman2[] =
1954"* # HTFFCRLF\xB0 \xB1 NLVT+ + + + + - - - - - + + + + | <=>=PI!=\xA3 \xB7 ";
1955#endif
1956
1957 int ch = (*top & CHAR_MASK);
1958
1959#if 0
1960 if ((*top & ATTR_LINEDRW) && ch >= 0x60 && ch < 0x7F) {
1961 int x;
1962 *wbptr++ = poorman2[2*(ch-0x60)];
1963 if ( (x = poorman2[2*(ch-0x60)+1]) != ' ')
1964 *wbptr++ = x;
1965 } else
1966#endif
1967#if 0
1968 if ((*top & ATTR_GBCHR) && ch == '#')
1969 *wbptr++ = (unsigned char) 0xA3;
1970 else
1971#endif
1972 if ( wblen == buflen )
1973 {
1974 workbuf = srealloc(workbuf, buflen += 100);
1975 wbptr = workbuf + wblen;
1976 }
1977 wblen++;
1978 *wbptr++ = (unsigned char) ch;
1979 top++;
1980 }
1981 if (nl) {
1982 int i;
1983 for (i=0; i<sizeof(sel_nl); i++)
1984 {
1985 if ( wblen == buflen )
1986 {
1987 workbuf = srealloc(workbuf, buflen += 100);
1988 wbptr = workbuf + wblen;
1989 }
1990 wblen++;
1991 *wbptr++ = sel_nl[i];
1992 }
1993 }
1994 top = lineend + 1; /* start of next line */
1995 }
1996 write_clip (workbuf, wblen, FALSE); /* transfer to clipboard */
1997 if ( buflen > 0 ) /* indicates we allocated this buffer */
1998 sfree(workbuf);
1999
2000}
2001void term_copyall (void) {
2002 clipme(sbtop, cpos, NULL /* dynamic allocation */);
2003}
2004
374330e2 2005/*
2006 * Spread the selection outwards according to the selection mode.
2007 */
2008static unsigned long *sel_spread_half (unsigned long *p, int dir) {
2009 unsigned long *linestart, *lineend;
2010 int x;
2011 short wvalue;
2012
2013 x = (p - text) % (cols+1);
2014 linestart = p - x;
2015 lineend = linestart + cols;
2016
2017 switch (selmode) {
2018 case SM_CHAR:
2019 /*
2020 * In this mode, every character is a separate unit, except
2021 * for runs of spaces at the end of a non-wrapping line.
2022 */
2023 if (!(linestart[cols] & ATTR_WRAPPED)) {
2024 unsigned long *q = lineend;
2025 while (q > linestart && (q[-1] & CHAR_MASK) == 0x20)
2026 q--;
2027 if (q == lineend)
2028 q--;
2029 if (p >= q)
2030 p = (dir == -1 ? q : lineend - 1);
2031 }
2032 break;
2033 case SM_WORD:
2034 /*
2035 * In this mode, the units are maximal runs of characters
2036 * whose `wordness' has the same value.
2037 */
2038 wvalue = wordness[*p & CHAR_MASK];
2039 if (dir == +1) {
2040 while (p < lineend && wordness[p[1] & CHAR_MASK] == wvalue)
2041 p++;
2042 } else {
2043 while (p > linestart && wordness[p[-1] & CHAR_MASK] == wvalue)
2044 p--;
2045 }
2046 break;
2047 case SM_LINE:
2048 /*
2049 * In this mode, every line is a unit.
2050 */
2051 p = (dir == -1 ? linestart : lineend - 1);
2052 break;
2053 }
2054 return p;
2055}
2056
2057static void sel_spread (void) {
2058 selstart = sel_spread_half (selstart, -1);
2059 selend = sel_spread_half (selend - 1, +1) + 1;
2060}
2061
2062void term_mouse (Mouse_Button b, Mouse_Action a, int x, int y) {
37508af4 2063 unsigned long *selpoint;
2064
2065 if (y<0) y = 0;
2066 if (y>=rows) y = rows-1;
094ed2a6 2067 if (x<0) {
2068 if (y > 0) {
2069 x = cols-1;
2070 y--;
2071 } else
2072 x = 0;
2073 }
37508af4 2074 if (x>=cols) x = cols-1;
2075
c9def1b8 2076 selpoint = disptop + y * (cols+1);
2077 if ((selpoint[cols]&LATTR_MODE) != LATTR_NORM)
2078 selpoint += x/2;
2079 else
2080 selpoint += x;
374330e2 2081
2082 if (b == MB_SELECT && a == MA_CLICK) {
2083 deselect();
2084 selstate = ABOUT_TO;
2085 selanchor = selpoint;
2086 selmode = SM_CHAR;
2087 } else if (b == MB_SELECT && (a == MA_2CLK || a == MA_3CLK)) {
2088 deselect();
2089 selmode = (a == MA_2CLK ? SM_WORD : SM_LINE);
2090 selstate = DRAGGING;
2091 selstart = selanchor = selpoint;
2092 selend = selstart + 1;
2093 sel_spread();
2094 } else if ((b == MB_SELECT && a == MA_DRAG) ||
2095 (b == MB_EXTEND && a != MA_RELEASE)) {
2096 if (selstate == ABOUT_TO && selanchor == selpoint)
2097 return;
2098 if (b == MB_EXTEND && a != MA_DRAG && selstate == SELECTED) {
2099 if (selpoint-selstart < (selend-selstart)/2)
2100 selanchor = selend - 1;
2101 else
2102 selanchor = selstart;
2103 selstate = DRAGGING;
2104 }
2105 if (selstate != ABOUT_TO && selstate != DRAGGING)
2106 selanchor = selpoint;
2107 selstate = DRAGGING;
2108 if (selpoint < selanchor) {
2109 selstart = selpoint;
2110 selend = selanchor + 1;
2111 } else {
2112 selstart = selanchor;
2113 selend = selpoint + 1;
2114 }
2115 sel_spread();
2116 } else if ((b == MB_SELECT || b == MB_EXTEND) && a == MA_RELEASE) {
2117 if (selstate == DRAGGING) {
2118 /*
2119 * We've completed a selection. We now transfer the
2120 * data to the clipboard.
2121 */
bc1235d4 2122 clipme(selstart, selend, selspace);
374330e2 2123 selstate = SELECTED;
2124 } else
2125 selstate = NO_SELECTION;
2126 } else if (b == MB_PASTE && (a==MA_CLICK || a==MA_2CLK || a==MA_3CLK)) {
2127 char *data;
2128 int len;
2129
2130 get_clip((void **) &data, &len);
2131 if (data) {
2132 char *p, *q;
c9def1b8 2133
2134 if (paste_buffer) sfree(paste_buffer);
2135 paste_pos = paste_hold = paste_len = 0;
2136 paste_buffer = smalloc(len);
2137
374330e2 2138 p = q = data;
2139 while (p < data+len) {
2140 while (p < data+len &&
2141 !(p <= data+len-sizeof(sel_nl) &&
2142 !memcmp(p, sel_nl, sizeof(sel_nl))))
2143 p++;
14963b8f 2144
2145 {
2146 int i;
2147 unsigned char c;
2148 for(i=0;i<p-q;i++)
2149 {
2150 c=xlat_kbd2tty(q[i]);
c9def1b8 2151 paste_buffer[paste_len++] = c;
14963b8f 2152 }
2153 }
2154
374330e2 2155 if (p <= data+len-sizeof(sel_nl) &&
2156 !memcmp(p, sel_nl, sizeof(sel_nl))) {
c9def1b8 2157 paste_buffer[paste_len++] = '\r';
374330e2 2158 p += sizeof(sel_nl);
2159 }
2160 q = p;
2161 }
c9def1b8 2162
2163 /* Assume a small paste will be OK in one go. */
2164 if (paste_len<256) {
2165 ldisc->send (paste_buffer, paste_len);
2166 if (paste_buffer) sfree(paste_buffer);
2167 paste_buffer = 0;
2168 paste_pos = paste_hold = paste_len = 0;
2169 }
374330e2 2170 }
2171 get_clip(NULL, NULL);
2172 }
2173
2174 term_update();
2175}
2176
c9def1b8 2177void term_nopaste() {
2178 if(paste_len == 0) return;
2179 sfree(paste_buffer);
2180 paste_buffer = 0;
2181 paste_len = 0;
2182}
2183
2184void term_paste() {
8df7a775 2185 static long last_paste = 0;
c9def1b8 2186 long now, paste_diff;
2187
2188 if(paste_len == 0) return;
2189
2190 /* Don't wait forever to paste */
2191 if(paste_hold) {
2192 now = GetTickCount();
2193 paste_diff = now-last_paste;
2194 if (paste_diff>=0 && paste_diff<450)
2195 return;
2196 }
2197 paste_hold = 0;
2198
2199 while(paste_pos<paste_len)
2200 {
8df7a775 2201 int n = 0;
2202 while (n + paste_pos < paste_len) {
2203 if (paste_buffer[paste_pos + n++] == '\r')
2204 break;
2205 }
2206 ldisc->send (paste_buffer+paste_pos, n);
2207 paste_pos += n;
c9def1b8 2208
8df7a775 2209 if (paste_pos < paste_len) {
c9def1b8 2210 paste_hold = 1;
2211 return;
2212 }
2213 }
2214 sfree(paste_buffer);
2215 paste_buffer = 0;
2216 paste_len = 0;
2217}
2218
374330e2 2219static void deselect (void) {
2220 selstate = NO_SELECTION;
2221 selstart = selend = scrtop;
2222}
2223
2224void term_deselect (void) {
2225 deselect();
2226 term_update();
2227}
fe50e814 2228
2229/*
2230 * from_backend(), to get data from the backend for the terminal.
2231 */
2232void from_backend(int is_stderr, char *data, int len) {
2233 while (len--) {
2234 if (inbuf_head >= INBUF_SIZE)
2235 term_out();
2236 inbuf[inbuf_head++] = *data++;
2237 }
2238}
e1c8e0ed 2239
2240/*
2241 * Log session traffic.
2242 */
2243void logtraffic(unsigned char c, int logmode) {
2244 if (cfg.logtype > 0) {
2245 if (cfg.logtype == logmode) {
2246 /* deferred open file from pgm start? */
2247 if (!lgfp) logfopen();
2248 if (lgfp) fputc (c, lgfp);
2249 }
2250 }
2251}
2252
2253/* open log file append/overwrite mode */
2254void logfopen(void) {
2255 char buf[256];
2256 time_t t;
2257 struct tm *tm;
2258 char writemod[4];
2259
2260 if (!cfg.logtype)
2261 return;
2262 sprintf (writemod, "wb"); /* default to rewrite */
2263 lgfp = fopen(cfg.logfilename, "r"); /* file already present? */
2264 if (lgfp) {
2265 int i;
2266 fclose(lgfp);
2267 i = askappend(cfg.logfilename);
2268 if (i == 1)
2269 writemod[0] = 'a'; /* set append mode */
2270 else if (i == 0) { /* cancelled */
2271 lgfp = NULL;
e4b0ba16 2272 cfg.logtype = 0; /* disable logging */
e1c8e0ed 2273 return;
2274 }
2275 }
2276
2277 lgfp = fopen(cfg.logfilename, writemod);
2278 if (lgfp) { /* enter into event log */
2279 sprintf(buf, "%s session log (%s mode) to file : ",
2280 (writemod[0] == 'a') ? "Appending" : "Writing new",
2281 (cfg.logtype == LGTYP_ASCII ? "ASCII" :
2282 cfg.logtype == LGTYP_DEBUG ? "raw" : "<ukwn>") );
2283 /* Make sure we do not exceed the output buffer size */
2284 strncat (buf, cfg.logfilename, 128);
2285 buf[strlen(buf)] = '\0';
2286 logevent(buf);
2287
2288 /* --- write header line iinto log file */
2289 fputs ("=~=~=~=~=~=~=~=~=~=~=~= PuTTY log ", lgfp);
2290 time(&t);
2291 tm = localtime(&t);
2292 strftime(buf, 24, "%Y.%m.%d %H:%M:%S", tm);
2293 fputs (buf, lgfp);
2294 fputs (" =~=~=~=~=~=~=~=~=~=~=~=\r\n", lgfp);
2295 }
2296}
2297
2298void logfclose (void) {
2299 if (lgfp) { fclose(lgfp); lgfp = NULL; }
2300}
Local modifications for Simon Tatham's `PuTTY' SSH client and terminal emulator