~mdw / sgt / putty / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Fix flaky scrollbar update when scrollback was reset to bottom.
[sgt/putty] / terminal.c
1 #include <windows.h>
2
3 #include <stdio.h>
4 #include <stdlib.h>
5 #include <ctype.h>
6
7 #include <time.h>
8 #include <assert.h>
9 #include "putty.h"
10 #include "tree234.h"
11
12 #define VT52_PLUS
13
14 #define CL_ANSIMIN 0x0001 /* Codes in all ANSI like terminals. */
15 #define CL_VT100 0x0002 /* VT100 */
16 #define CL_VT100AVO 0x0004 /* VT100 +AVO; 132x24 (not 132x14) & attrs */
17 #define CL_VT102 0x0008 /* VT102 */
18 #define CL_VT220 0x0010 /* VT220 */
19 #define CL_VT320 0x0020 /* VT320 */
20 #define CL_VT420 0x0040 /* VT420 */
21 #define CL_VT510 0x0080 /* VT510, NB VT510 includes ANSI */
22 #define CL_VT340TEXT 0x0100 /* VT340 extensions that appear in the VT420 */
23 #define CL_SCOANSI 0x1000 /* SCOANSI not in ANSIMIN. */
24 #define CL_ANSI 0x2000 /* ANSI ECMA-48 not in the VT100..VT420 */
25 #define CL_OTHER 0x4000 /* Others, Xterm, linux, putty, dunno, etc */
26
27 #define TM_VT100 (CL_ANSIMIN|CL_VT100)
28 #define TM_VT100AVO (TM_VT100|CL_VT100AVO)
29 #define TM_VT102 (TM_VT100AVO|CL_VT102)
30 #define TM_VT220 (TM_VT102|CL_VT220)
31 #define TM_VTXXX (TM_VT220|CL_VT340TEXT|CL_VT510|CL_VT420|CL_VT320)
32 #define TM_SCOANSI (CL_ANSIMIN|CL_SCOANSI)
33
34 #define TM_PUTTY (0xFFFF)
35
36 #define compatibility(x) \
37 if ( ((CL_##x)&compatibility_level) == 0 ) { \
38 termstate=TOPLEVEL; \
39 break; \
40 }
41 #define compatibility2(x,y) \
42 if ( ((CL_##x|CL_##y)&compatibility_level) == 0 ) { \
43 termstate=TOPLEVEL; \
44 break; \
45 }
46
47 #define has_compat(x) ( ((CL_##x)&compatibility_level) != 0 )
48
49 static int compatibility_level = TM_PUTTY;
50
51 static tree234 *scrollback; /* lines scrolled off top of screen */
52 static tree234 *screen; /* lines on primary screen */
53 static tree234 *alt_screen; /* lines on alternate screen */
54 static int disptop; /* distance scrolled back (0 or -ve) */
55
56 static unsigned long *cpos; /* cursor position (convenience) */
57
58 static unsigned long *disptext; /* buffer of text on real screen */
59 static unsigned long *dispcurs; /* location of cursor on real screen */
60 static unsigned long curstype; /* type of cursor on real screen */
61
62 #define VBELL_TIMEOUT 100 /* millisecond len of visual bell */
63
64 struct beeptime {
65 struct beeptime *next;
66 long ticks;
67 };
68 static struct beeptime *beephead, *beeptail;
69 int nbeeps;
70 int beep_overloaded;
71 long lastbeep;
72
73 #define TSIZE (sizeof(unsigned long))
74 #define fix_cpos do { cpos = lineptr(curs.y) + curs.x; } while(0)
75
76 static unsigned long curr_attr, save_attr;
77 static unsigned long erase_char = ERASE_CHAR;
78
79 typedef struct {
80 int y, x;
81 } pos;
82 #define poslt(p1,p2) ( (p1).y < (p2).y || ( (p1).y == (p2).y && (p1).x < (p2).x ) )
83 #define posle(p1,p2) ( (p1).y < (p2).y || ( (p1).y == (p2).y && (p1).x <= (p2).x ) )
84 #define poseq(p1,p2) ( (p1).y == (p2).y && (p1).x == (p2).x )
85 #define posdiff(p1,p2) ( ((p1).y - (p2).y) * (cols+1) + (p1).x - (p2).x )
86 #define incpos(p) ( (p).x == cols ? ((p).x = 0, (p).y++, 1) : ((p).x++, 0) )
87 #define decpos(p) ( (p).x == 0 ? ((p).x = cols, (p).y--, 1) : ((p).x--, 0) )
88
89 static pos curs; /* cursor */
90 static pos savecurs; /* saved cursor position */
91 static int marg_t, marg_b; /* scroll margins */
92 static int dec_om; /* DEC origin mode flag */
93 static int wrap, wrapnext; /* wrap flags */
94 static int insert; /* insert-mode flag */
95 static int cset; /* 0 or 1: which char set */
96 static int save_cset, save_csattr; /* saved with cursor position */
97 static int save_utf; /* saved with cursor position */
98 static int rvideo; /* global reverse video flag */
99 static int rvbell_timeout; /* for ESC[?5hESC[?5l vbell */
100 static int cursor_on; /* cursor enabled flag */
101 static int reset_132; /* Flag ESC c resets to 80 cols */
102 static int use_bce; /* Use Background coloured erase */
103 static int blinker; /* When blinking is the cursor on ? */
104 static int tblinker; /* When the blinking text is on */
105 static int blink_is_real; /* Actually blink blinking text */
106 static int term_echoing; /* Does terminal want local echo? */
107 static int term_editing; /* Does terminal want local edit? */
108 static int sco_acs, save_sco_acs; /* CSI 10,11,12m -> OEM charset */
109 static int vt52_bold; /* Force bold on non-bold colours */
110 static int utf_state; /* Is there a pending UTF-8 character */
111 static int utf_char; /* and what is it so far. */
112 static int utf_size; /* The size of the UTF character. */
113
114 static int xterm_mouse; /* send mouse messages to app */
115
116 static unsigned long cset_attr[2];
117
118 /*
119 * Saved settings on the alternate screen.
120 */
121 static int alt_x, alt_y, alt_om, alt_wrap, alt_wnext, alt_ins, alt_cset, alt_sco_acs, alt_utf;
122 static int alt_t, alt_b;
123 static int alt_which;
124
125 #define ARGS_MAX 32 /* max # of esc sequence arguments */
126 #define ARG_DEFAULT 0 /* if an arg isn't specified */
127 #define def(a,d) ( (a) == ARG_DEFAULT ? (d) : (a) )
128 static int esc_args[ARGS_MAX];
129 static int esc_nargs;
130 static int esc_query;
131 #define ANSI(x,y) ((x)+((y)<<8))
132 #define ANSI_QUE(x) ANSI(x,TRUE)
133
134 #define OSC_STR_MAX 2048
135 static int osc_strlen;
136 static char osc_string[OSC_STR_MAX + 1];
137 static int osc_w;
138
139 static char id_string[1024] = "\033[?6c";
140
141 static unsigned char *tabs;
142
143 static enum {
144 TOPLEVEL,
145 SEEN_ESC,
146 SEEN_CSI,
147 SEEN_OSC,
148 SEEN_OSC_W,
149
150 DO_CTRLS,
151
152 SEEN_OSC_P,
153 OSC_STRING, OSC_MAYBE_ST,
154 VT52_ESC,
155 VT52_Y1,
156 VT52_Y2,
157 VT52_FG,
158 VT52_BG
159 } termstate;
160
161 static enum {
162 NO_SELECTION, ABOUT_TO, DRAGGING, SELECTED
163 } selstate;
164 static enum {
165 SM_CHAR, SM_WORD, SM_LINE
166 } selmode;
167 static pos selstart, selend, selanchor;
168
169 static short wordness[256] = {
170 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
171 0, 0, 0, 0, 0, 0, 0, 0, /* 01 */
172 0, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
173 2, 2, 1, 1, 1, 1, 1, 1, /* 23 */
174 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
175 2, 2, 2, 1, 1, 1, 1, 2, /* 45 */
176 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
177 2, 2, 2, 1, 1, 1, 1, 1, /* 67 */
178 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
179 1, 1, 1, 1, 1, 1, 1, 1, /* 89 */
180 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
181 1, 1, 1, 1, 1, 1, 1, 1, /* AB */
182 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1,
183 2, 2, 2, 2, 2, 2, 2, 2, /* CD */
184 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1,
185 2, 2, 2, 2, 2, 2, 2, 2, /* EF */
186 };
187
188 #define sel_nl_sz (sizeof(sel_nl)/sizeof(wchar_t))
189 static wchar_t sel_nl[] = SEL_NL;
190 static wchar_t *paste_buffer = 0;
191 static int paste_len, paste_pos, paste_hold;
192
193 /*
194 * Internal prototypes.
195 */
196 static void do_paint(Context, int);
197 static void erase_lots(int, int, int);
198 static void swap_screen(int);
199 static void update_sbar(void);
200 static void deselect(void);
201 /* log session to file stuff ... */
202 static FILE *lgfp = NULL;
203 static void logtraffic(unsigned char c, int logmode);
204 static void xlatlognam(char *d, char *s, char *hostname, struct tm *tm);
205
206 /*
207 * Resize a line to make it `cols' columns wide.
208 */
209 unsigned long *resizeline(unsigned long *line, int cols)
210 {
211 int i, oldlen;
212 unsigned long lineattrs;
213
214 if (line[0] != (unsigned long)cols) {
215 /*
216 * This line is the wrong length, which probably means it
217 * hasn't been accessed since a resize. Resize it now.
218 */
219 oldlen = line[0];
220 lineattrs = line[oldlen + 1];
221 line = srealloc(line, TSIZE * (2 + cols));
222 line[0] = cols;
223 for (i = oldlen; i < cols; i++)
224 line[i + 1] = ERASE_CHAR;
225 line[cols + 1] = lineattrs & LATTR_MODE;
226 }
227
228 return line;
229 }
230
231 /*
232 * Retrieve a line of the screen or of the scrollback, according to
233 * whether the y coordinate is non-negative or negative
234 * (respectively).
235 */
236 unsigned long *lineptr(int y, int lineno)
237 {
238 unsigned long *line, *newline;
239 tree234 *whichtree;
240 int treeindex;
241
242 if (y >= 0) {
243 whichtree = screen;
244 treeindex = y;
245 } else {
246 whichtree = scrollback;
247 treeindex = y + count234(scrollback);
248 }
249 line = index234(whichtree, treeindex);
250
251 /* We assume that we don't screw up and retrieve something out of range. */
252 assert(line != NULL);
253
254 newline = resizeline(line, cols);
255 if (newline != line) {
256 delpos234(whichtree, treeindex);
257 addpos234(whichtree, newline, treeindex);
258 line = newline;
259 }
260
261 return line + 1;
262 }
263
264 #define lineptr(x) lineptr(x,__LINE__)
265 /*
266 * Set up power-on settings for the terminal.
267 */
268 static void power_on(void)
269 {
270 curs.x = curs.y = alt_x = alt_y = savecurs.x = savecurs.y = 0;
271 alt_t = marg_t = 0;
272 if (rows != -1)
273 alt_b = marg_b = rows - 1;
274 else
275 alt_b = marg_b = 0;
276 if (cols != -1) {
277 int i;
278 for (i = 0; i < cols; i++)
279 tabs[i] = (i % 8 == 0 ? TRUE : FALSE);
280 }
281 alt_om = dec_om = cfg.dec_om;
282 alt_wnext = wrapnext = alt_ins = insert = FALSE;
283 alt_wrap = wrap = cfg.wrap_mode;
284 alt_cset = cset = 0;
285 alt_utf = utf = 0;
286 alt_sco_acs = sco_acs = 0;
287 cset_attr[0] = cset_attr[1] = ATTR_ASCII;
288 rvideo = 0;
289 in_vbell = FALSE;
290 cursor_on = 1;
291 big_cursor = 0;
292 save_attr = curr_attr = ATTR_DEFAULT;
293 term_editing = term_echoing = FALSE;
294 ldisc_send(NULL, 0); /* cause ldisc to notice changes */
295 app_cursor_keys = cfg.app_cursor;
296 app_keypad_keys = cfg.app_keypad;
297 use_bce = cfg.bce;
298 blink_is_real = cfg.blinktext;
299 erase_char = ERASE_CHAR;
300 alt_which = 0;
301 {
302 int i;
303 for (i = 0; i < 256; i++)
304 wordness[i] = cfg.wordness[i];
305 }
306 if (screen) {
307 swap_screen(1);
308 erase_lots(FALSE, TRUE, TRUE);
309 swap_screen(0);
310 erase_lots(FALSE, TRUE, TRUE);
311 }
312 }
313
314 /*
315 * Force a screen update.
316 */
317 void term_update(void)
318 {
319 Context ctx;
320 ctx = get_ctx();
321 if (ctx) {
322 int need_sbar_update = seen_disp_event;
323 if ((seen_key_event && (cfg.scroll_on_key)) ||
324 (seen_disp_event && (cfg.scroll_on_disp))) {
325 disptop = 0; /* return to main screen */
326 seen_disp_event = seen_key_event = 0;
327 need_sbar_update = TRUE;
328 }
329 if (need_sbar_update)
330 update_sbar();
331 do_paint(ctx, TRUE);
332 sys_cursor(curs.x, curs.y - disptop);
333 free_ctx(ctx);
334 }
335 }
336
337 /*
338 * Same as power_on(), but an external function.
339 */
340 void term_pwron(void)
341 {
342 power_on();
343 fix_cpos;
344 disptop = 0;
345 deselect();
346 term_update();
347 }
348
349 /*
350 * Clear the scrollback.
351 */
352 void term_clrsb(void)
353 {
354 unsigned long *line;
355 disptop = 0;
356 while ((line = delpos234(scrollback, 0)) != NULL) {
357 sfree(line);
358 }
359 update_sbar();
360 }
361
362 /*
363 * Initialise the terminal.
364 */
365 void term_init(void)
366 {
367 screen = alt_screen = scrollback = NULL;
368 disptop = 0;
369 disptext = dispcurs = NULL;
370 tabs = NULL;
371 deselect();
372 rows = cols = -1;
373 power_on();
374 beephead = beeptail = NULL;
375 nbeeps = 0;
376 lastbeep = FALSE;
377 beep_overloaded = FALSE;
378 }
379
380 /*
381 * Set up the terminal for a given size.
382 */
383 void term_size(int newrows, int newcols, int newsavelines)
384 {
385 tree234 *newalt;
386 unsigned long *newdisp, *line;
387 int i, j;
388 int sblen;
389 int save_alt_which = alt_which;
390
391 if (newrows == rows && newcols == cols && newsavelines == savelines)
392 return; /* nothing to do */
393
394 deselect();
395 swap_screen(0);
396
397 alt_t = marg_t = 0;
398 alt_b = marg_b = newrows - 1;
399
400 if (rows == -1) {
401 scrollback = newtree234(NULL);
402 screen = newtree234(NULL);
403 rows = 0;
404 }
405
406 /*
407 * Resize the screen and scrollback. We only need to shift
408 * lines around within our data structures, because lineptr()
409 * will take care of resizing each individual line if
410 * necessary. So:
411 *
412 * - If the new screen and the old screen differ in length, we
413 * must shunt some lines in from the scrollback or out to
414 * the scrollback.
415 *
416 * - If doing that fails to provide us with enough material to
417 * fill the new screen (i.e. the number of rows needed in
418 * the new screen exceeds the total number in the previous
419 * screen+scrollback), we must invent some blank lines to
420 * cover the gap.
421 *
422 * - Then, if the new scrollback length is less than the
423 * amount of scrollback we actually have, we must throw some
424 * away.
425 */
426 sblen = count234(scrollback);
427 /* Do this loop to expand the screen if newrows > rows */
428 for (i = rows; i < newrows; i++) {
429 if (sblen > 0) {
430 line = delpos234(scrollback, --sblen);
431 } else {
432 line = smalloc(TSIZE * (newcols + 2));
433 line[0] = newcols;
434 for (j = 0; j <= newcols; j++)
435 line[j + 1] = ERASE_CHAR;
436 }
437 addpos234(screen, line, 0);
438 }
439 /* Do this loop to shrink the screen if newrows < rows */
440 for (i = newrows; i < rows; i++) {
441 line = delpos234(screen, 0);
442 addpos234(scrollback, line, sblen++);
443 }
444 assert(count234(screen) == newrows);
445 while (sblen > newsavelines) {
446 line = delpos234(scrollback, 0);
447 sfree(line);
448 sblen--;
449 }
450 assert(count234(scrollback) <= newsavelines);
451 disptop = 0;
452
453 newdisp = smalloc(newrows * (newcols + 1) * TSIZE);
454 for (i = 0; i < newrows * (newcols + 1); i++)
455 newdisp[i] = ATTR_INVALID;
456 sfree(disptext);
457 disptext = newdisp;
458 dispcurs = NULL;
459
460 newalt = newtree234(NULL);
461 for (i = 0; i < newrows; i++) {
462 line = smalloc(TSIZE * (newcols + 2));
463 line[0] = newcols;
464 for (j = 0; j <= newcols; j++)
465 line[j + 1] = erase_char;
466 addpos234(newalt, line, i);
467 }
468 if (alt_screen) {
469 while (NULL != (line = delpos234(alt_screen, 0)))
470 sfree(line);
471 freetree234(alt_screen);
472 }
473 alt_screen = newalt;
474
475 tabs = srealloc(tabs, newcols * sizeof(*tabs));
476 {
477 int i;
478 for (i = (cols > 0 ? cols : 0); i < newcols; i++)
479 tabs[i] = (i % 8 == 0 ? TRUE : FALSE);
480 }
481
482 if (rows > 0)
483 curs.y += newrows - rows;
484 if (curs.y < 0)
485 curs.y = 0;
486 if (curs.y >= newrows)
487 curs.y = newrows - 1;
488 if (curs.x >= newcols)
489 curs.x = newcols - 1;
490 alt_x = alt_y = 0;
491 wrapnext = alt_wnext = FALSE;
492
493 rows = newrows;
494 cols = newcols;
495 savelines = newsavelines;
496 fix_cpos;
497
498 swap_screen(save_alt_which);
499
500 update_sbar();
501 term_update();
502 back->size();
503 }
504
505 /*
506 * Swap screens.
507 */
508 static void swap_screen(int which)
509 {
510 int t;
511 tree234 *ttr;
512
513 if (which == alt_which)
514 return;
515
516 alt_which = which;
517
518 ttr = alt_screen;
519 alt_screen = screen;
520 screen = ttr;
521 t = curs.x;
522 curs.x = alt_x;
523 alt_x = t;
524 t = curs.y;
525 curs.y = alt_y;
526 alt_y = t;
527 t = marg_t;
528 marg_t = alt_t;
529 alt_t = t;
530 t = marg_b;
531 marg_b = alt_b;
532 alt_b = t;
533 t = dec_om;
534 dec_om = alt_om;
535 alt_om = t;
536 t = wrap;
537 wrap = alt_wrap;
538 alt_wrap = t;
539 t = wrapnext;
540 wrapnext = alt_wnext;
541 alt_wnext = t;
542 t = insert;
543 insert = alt_ins;
544 alt_ins = t;
545 t = cset;
546 cset = alt_cset;
547 alt_cset = t;
548 t = utf;
549 utf = alt_utf;
550 alt_utf = t;
551 t = sco_acs;
552 sco_acs = alt_sco_acs;
553 alt_sco_acs = t;
554
555 fix_cpos;
556 }
557
558 /*
559 * Update the scroll bar.
560 */
561 static void update_sbar(void)
562 {
563 int nscroll;
564
565 nscroll = count234(scrollback);
566
567 set_sbar(nscroll + rows, nscroll + disptop, rows);
568 }
569
570 /*
571 * Check whether the region bounded by the two pointers intersects
572 * the scroll region, and de-select the on-screen selection if so.
573 */
574 static void check_selection(pos from, pos to)
575 {
576 if (poslt(from, selend) && poslt(selstart, to))
577 deselect();
578 }
579
580 /*
581 * Scroll the screen. (`lines' is +ve for scrolling forward, -ve
582 * for backward.) `sb' is TRUE if the scrolling is permitted to
583 * affect the scrollback buffer.
584 *
585 * NB this function invalidates all pointers into lines of the
586 * screen data structures. In particular, you MUST call fix_cpos
587 * after calling scroll() and before doing anything else that
588 * uses the cpos shortcut pointer.
589 */
590 static void scroll(int topline, int botline, int lines, int sb)
591 {
592 unsigned long *line, *line2;
593 int i, seltop;
594
595 if (topline != 0 || alt_which != 0)
596 sb = FALSE;
597
598 if (lines < 0) {
599 while (lines < 0) {
600 line = delpos234(screen, botline);
601 line = resizeline(line, cols);
602 for (i = 0; i < cols; i++)
603 line[i + 1] = erase_char;
604 line[cols + 1] = 0;
605 addpos234(screen, line, topline);
606
607 if (selstart.y >= topline && selstart.y <= botline) {
608 selstart.y++;
609 if (selstart.y > botline) {
610 selstart.y = botline;
611 selstart.x = 0;
612 }
613 }
614 if (selend.y >= topline && selend.y <= botline) {
615 selend.y++;
616 if (selend.y > botline) {
617 selend.y = botline;
618 selend.x = 0;
619 }
620 }
621
622 lines++;
623 }
624 } else {
625 while (lines > 0) {
626 line = delpos234(screen, topline);
627 if (sb && savelines > 0) {
628 int sblen = count234(scrollback);
629 /*
630 * We must add this line to the scrollback. We'll
631 * remove a line from the top of the scrollback to
632 * replace it, or allocate a new one if the
633 * scrollback isn't full.
634 */
635 if (sblen == savelines) {
636 sblen--, line2 = delpos234(scrollback, 0);
637 } else {
638 line2 = smalloc(TSIZE * (cols + 2));
639 line2[0] = cols;
640 }
641 addpos234(scrollback, line, sblen);
642 line = line2;
643
644 /*
645 * If the user is currently looking at part of the
646 * scrollback, and they haven't enabled any options
647 * that are going to reset the scrollback as a
648 * result of this movement, then the chances are
649 * they'd like to keep looking at the same line. So
650 * we move their viewpoint at the same rate as the
651 * scroll, at least until their viewpoint hits the
652 * top end of the scrollback buffer, at which point
653 * we don't have the choice any more.
654 *
655 * Thanks to Jan Holmen Holsten for the idea and
656 * initial implementation.
657 */
658 if (disptop > -savelines && disptop < 0)
659 disptop--;
660 }
661 line = resizeline(line, cols);
662 for (i = 0; i < cols; i++)
663 line[i + 1] = erase_char;
664 line[cols + 1] = 0;
665 addpos234(screen, line, botline);
666
667 /*
668 * If the selection endpoints move into the scrollback,
669 * we keep them moving until they hit the top. However,
670 * of course, if the line _hasn't_ moved into the
671 * scrollback then we don't do this, and cut them off
672 * at the top of the scroll region.
673 *
674 * This applies to selstart and selend (for an existing
675 * selection), and also selanchor (for one being
676 * selected as we speak).
677 */
678 seltop = sb ? -savelines : 0;
679
680 if (selstart.y >= seltop && selstart.y <= botline) {
681 selstart.y--;
682 if (selstart.y < seltop) {
683 selstart.y = seltop;
684 selstart.x = 0;
685 }
686 }
687 if (selend.y >= seltop && selend.y <= botline) {
688 selend.y--;
689 if (selend.y < seltop) {
690 selend.y = seltop;
691 selend.x = 0;
692 }
693 }
694 if (selanchor.y >= seltop && selanchor.y <= botline) {
695 selanchor.y--;
696 if (selanchor.y < seltop) {
697 selanchor.y = seltop;
698 selanchor.x = 0;
699 }
700 }
701
702 lines--;
703 }
704 }
705 }
706
707 /*
708 * Move the cursor to a given position, clipping at boundaries. We
709 * may or may not want to clip at the scroll margin: marg_clip is 0
710 * not to, 1 to disallow _passing_ the margins, and 2 to disallow
711 * even _being_ outside the margins.
712 */
713 static void move(int x, int y, int marg_clip)
714 {
715 if (x < 0)
716 x = 0;
717 if (x >= cols)
718 x = cols - 1;
719 if (marg_clip) {
720 if ((curs.y >= marg_t || marg_clip == 2) && y < marg_t)
721 y = marg_t;
722 if ((curs.y <= marg_b || marg_clip == 2) && y > marg_b)
723 y = marg_b;
724 }
725 if (y < 0)
726 y = 0;
727 if (y >= rows)
728 y = rows - 1;
729 curs.x = x;
730 curs.y = y;
731 fix_cpos;
732 wrapnext = FALSE;
733 }
734
735 /*
736 * Save or restore the cursor and SGR mode.
737 */
738 static void save_cursor(int save)
739 {
740 if (save) {
741 savecurs = curs;
742 save_attr = curr_attr;
743 save_cset = cset;
744 save_utf = utf;
745 save_csattr = cset_attr[cset];
746 save_sco_acs = sco_acs;
747 } else {
748 curs = savecurs;
749 /* Make sure the window hasn't shrunk since the save */
750 if (curs.x >= cols)
751 curs.x = cols - 1;
752 if (curs.y >= rows)
753 curs.y = rows - 1;
754
755 curr_attr = save_attr;
756 cset = save_cset;
757 utf = save_utf;
758 cset_attr[cset] = save_csattr;
759 sco_acs = save_sco_acs;
760 fix_cpos;
761 if (use_bce)
762 erase_char = (' ' | ATTR_ASCII |
763 (curr_attr & (ATTR_FGMASK | ATTR_BGMASK)));
764 }
765 }
766
767 /*
768 * Erase a large portion of the screen: the whole screen, or the
769 * whole line, or parts thereof.
770 */
771 static void erase_lots(int line_only, int from_begin, int to_end)
772 {
773 pos start, end;
774 int erase_lattr;
775 unsigned long *ldata;
776
777 if (line_only) {
778 start.y = curs.y;
779 start.x = 0;
780 end.y = curs.y + 1;
781 end.x = 0;
782 erase_lattr = FALSE;
783 } else {
784 start.y = 0;
785 start.x = 0;
786 end.y = rows;
787 end.x = 0;
788 erase_lattr = TRUE;
789 }
790 if (!from_begin) {
791 start = curs;
792 }
793 if (!to_end) {
794 end = curs;
795 incpos(end);
796 }
797 check_selection(start, end);
798
799 /* Clear screen also forces a full window redraw, just in case. */
800 if (start.y == 0 && start.x == 0 && end.y == rows)
801 term_invalidate();
802
803 ldata = lineptr(start.y);
804 while (poslt(start, end)) {
805 if (start.x == cols && !erase_lattr)
806 ldata[start.x] &= ~LATTR_WRAPPED;
807 else
808 ldata[start.x] = erase_char;
809 if (incpos(start) && start.y < rows)
810 ldata = lineptr(start.y);
811 }
812 }
813
814 /*
815 * Insert or delete characters within the current line. n is +ve if
816 * insertion is desired, and -ve for deletion.
817 */
818 static void insch(int n)
819 {
820 int dir = (n < 0 ? -1 : +1);
821 int m;
822 pos cursplus;
823 unsigned long *ldata;
824
825 n = (n < 0 ? -n : n);
826 if (n > cols - curs.x)
827 n = cols - curs.x;
828 m = cols - curs.x - n;
829 cursplus.y = curs.y;
830 cursplus.x = curs.x + n;
831 check_selection(curs, cursplus);
832 ldata = lineptr(curs.y);
833 if (dir < 0) {
834 memmove(ldata + curs.x, ldata + curs.x + n, m * TSIZE);
835 while (n--)
836 ldata[curs.x + m++] = erase_char;
837 } else {
838 memmove(ldata + curs.x + n, ldata + curs.x, m * TSIZE);
839 while (n--)
840 ldata[curs.x + n] = erase_char;
841 }
842 }
843
844 /*
845 * Toggle terminal mode `mode' to state `state'. (`query' indicates
846 * whether the mode is a DEC private one or a normal one.)
847 */
848 static void toggle_mode(int mode, int query, int state)
849 {
850 long ticks;
851
852 if (query)
853 switch (mode) {
854 case 1: /* application cursor keys */
855 app_cursor_keys = state;
856 break;
857 case 2: /* VT52 mode */
858 vt52_mode = !state;
859 if (vt52_mode) {
860 blink_is_real = FALSE;
861 vt52_bold = FALSE;
862 } else {
863 blink_is_real = cfg.blinktext;
864 }
865 break;
866 case 3: /* 80/132 columns */
867 deselect();
868 request_resize(state ? 132 : 80, rows);
869 reset_132 = state;
870 break;
871 case 5: /* reverse video */
872 /*
873 * Toggle reverse video. If we receive an OFF within the
874 * visual bell timeout period after an ON, we trigger an
875 * effective visual bell, so that ESC[?5hESC[?5l will
876 * always be an actually _visible_ visual bell.
877 */
878 ticks = GetTickCount();
879 if (rvideo && !state && /* we're turning it off */
880 ticks < rvbell_timeout) { /* and it's not long since it was turned on */
881 in_vbell = TRUE; /* we may clear rvideo but we set in_vbell */
882 if (vbell_timeout < rvbell_timeout) /* don't move vbell end forward */
883 vbell_timeout = rvbell_timeout; /* vbell end is at least then */
884 } else if (!rvideo && state) {
885 /* This is an ON, so we notice the time and save it. */
886 rvbell_timeout = ticks + VBELL_TIMEOUT;
887 }
888 rvideo = state;
889 seen_disp_event = TRUE;
890 if (state)
891 term_update();
892 break;
893 case 6: /* DEC origin mode */
894 dec_om = state;
895 break;
896 case 7: /* auto wrap */
897 wrap = state;
898 break;
899 case 8: /* auto key repeat */
900 repeat_off = !state;
901 break;
902 case 10: /* set local edit mode */
903 term_editing = state;
904 ldisc_send(NULL, 0); /* cause ldisc to notice changes */
905 break;
906 case 25: /* enable/disable cursor */
907 compatibility2(OTHER, VT220);
908 cursor_on = state;
909 seen_disp_event = TRUE;
910 break;
911 case 47: /* alternate screen */
912 compatibility(OTHER);
913 deselect();
914 swap_screen(state);
915 disptop = 0;
916 break;
917 case 1000: /* xterm mouse 1 */
918 xterm_mouse = state ? 1 : 0;
919 set_raw_mouse_mode(state);
920 break;
921 case 1002: /* xterm mouse 2 */
922 xterm_mouse = state ? 2 : 0;
923 set_raw_mouse_mode(state);
924 break;
925 } else
926 switch (mode) {
927 case 4: /* set insert mode */
928 compatibility(VT102);
929 insert = state;
930 break;
931 case 12: /* set echo mode */
932 term_echoing = !state;
933 ldisc_send(NULL, 0); /* cause ldisc to notice changes */
934 break;
935 case 20: /* Return sends ... */
936 cr_lf_return = state;
937 break;
938 case 34: /* Make cursor BIG */
939 compatibility2(OTHER, VT220);
940 big_cursor = !state;
941 }
942 }
943
944 /*
945 * Process an OSC sequence: set window title or icon name.
946 */
947 static void do_osc(void)
948 {
949 if (osc_w) {
950 while (osc_strlen--)
951 wordness[(unsigned char) osc_string[osc_strlen]] = esc_args[0];
952 } else {
953 osc_string[osc_strlen] = '\0';
954 switch (esc_args[0]) {
955 case 0:
956 case 1:
957 set_icon(osc_string);
958 if (esc_args[0] == 1)
959 break;
960 /* fall through: parameter 0 means set both */
961 case 2:
962 case 21:
963 set_title(osc_string);
964 break;
965 }
966 }
967 }
968
969 /*
970 * Remove everything currently in `inbuf' and stick it up on the
971 * in-memory display. There's a big state machine in here to
972 * process escape sequences...
973 */
974 void term_out(void)
975 {
976 int c, inbuf_reap;
977
978 /*
979 * Optionally log the session traffic to a file. Useful for
980 * debugging and possibly also useful for actual logging.
981 */
982 if (cfg.logtype == LGTYP_DEBUG)
983 for (inbuf_reap = 0; inbuf_reap < inbuf_head; inbuf_reap++) {
984 logtraffic((unsigned char) inbuf[inbuf_reap], LGTYP_DEBUG);
985 }
986
987 for (inbuf_reap = 0; inbuf_reap < inbuf_head; inbuf_reap++) {
988 c = inbuf[inbuf_reap];
989
990 /* Note only VT220+ are 8-bit VT102 is seven bit, it shouldn't even
991 * be able to display 8-bit characters, but I'll let that go 'cause
992 * of i18n.
993 */
994
995 /* First see about all those translations. */
996 if (termstate == TOPLEVEL) {
997 if (in_utf)
998 switch (utf_state) {
999 case 0:
1000 if (c < 0x80) {
1001 /* UTF-8 must be stateless so we ignore iso2022. */
1002 if (unitab_ctrl[c] != 0xFF)
1003 c = unitab_ctrl[c];
1004 else c = ((unsigned char)c) | ATTR_ASCII;
1005 break;
1006 } else if ((c & 0xe0) == 0xc0) {
1007 utf_size = utf_state = 1;
1008 utf_char = (c & 0x1f);
1009 } else if ((c & 0xf0) == 0xe0) {
1010 utf_size = utf_state = 2;
1011 utf_char = (c & 0x0f);
1012 } else if ((c & 0xf8) == 0xf0) {
1013 utf_size = utf_state = 3;
1014 utf_char = (c & 0x07);
1015 } else if ((c & 0xfc) == 0xf8) {
1016 utf_size = utf_state = 4;
1017 utf_char = (c & 0x03);
1018 } else if ((c & 0xfe) == 0xfc) {
1019 utf_size = utf_state = 5;
1020 utf_char = (c & 0x01);
1021 } else {
1022 c = UCSERR;
1023 break;
1024 }
1025 continue;
1026 case 1:
1027 case 2:
1028 case 3:
1029 case 4:
1030 case 5:
1031 if ((c & 0xC0) != 0x80) {
1032 inbuf_reap--;
1033 c = UCSERR;
1034 utf_state = 0;
1035 break;
1036 }
1037 utf_char = (utf_char << 6) | (c & 0x3f);
1038 if (--utf_state)
1039 continue;
1040
1041 c = utf_char;
1042
1043 /* Is somebody trying to be evil! */
1044 if (c < 0x80 ||
1045 (c < 0x800 && utf_size >= 2) ||
1046 (c < 0x10000 && utf_size >= 3) ||
1047 (c < 0x200000 && utf_size >= 4) ||
1048 (c < 0x4000000 && utf_size >= 5))
1049 c = UCSERR;
1050
1051 /* Unicode line separator and paragraph separator are CR-LF */
1052 if (c == 0x2028 || c == 0x2029)
1053 c = 0x85;
1054
1055 /* High controls are probably a Baaad idea too. */
1056 if (c < 0xA0)
1057 c = 0xFFFD;
1058
1059 /* The UTF-16 surrogates are not nice either. */
1060 /* The standard give the option of decoding these:
1061 * I don't want to! */
1062 if (c >= 0xD800 && c < 0xE000)
1063 c = UCSERR;
1064
1065 /* ISO 10646 characters now limited to UTF-16 range. */
1066 if (c > 0x10FFFF)
1067 c = UCSERR;
1068
1069 /* This is currently a TagPhobic application.. */
1070 if (c >= 0xE0000 && c <= 0xE007F)
1071 continue;
1072
1073 /* U+FEFF is best seen as a null. */
1074 if (c == 0xFEFF)
1075 continue;
1076 /* But U+FFFE is an error. */
1077 if (c == 0xFFFE || c == 0xFFFF)
1078 c = UCSERR;
1079
1080 /* Oops this is a 16bit implementation */
1081 if (c >= 0x10000)
1082 c = 0xFFFD;
1083 break;
1084 }
1085 /* Are we in the nasty ACS mode? Note: no sco in utf mode. */
1086 else if(sco_acs &&
1087 (c!='\033' && c!='\n' && c!='\r' && c!='\b'))
1088 {
1089 if (sco_acs == 2) c ^= 0x80;
1090 c |= ATTR_SCOACS;
1091 } else {
1092 switch (cset_attr[cset]) {
1093 /*
1094 * Linedraw characters are different from 'ESC ( B'
1095 * only for a small range. For ones outside that
1096 * range, make sure we use the same font as well as
1097 * the same encoding.
1098 */
1099 case ATTR_LINEDRW:
1100 if (unitab_ctrl[c] != 0xFF)
1101 c = unitab_ctrl[c];
1102 else
1103 c = ((unsigned char) c) | ATTR_LINEDRW;
1104 break;
1105
1106 case ATTR_GBCHR:
1107 /* If UK-ASCII, make the '#' a LineDraw Pound */
1108 if (c == '#') {
1109 c = '}' | ATTR_LINEDRW;
1110 break;
1111 }
1112 /*FALLTHROUGH*/ case ATTR_ASCII:
1113 if (unitab_ctrl[c] != 0xFF)
1114 c = unitab_ctrl[c];
1115 else
1116 c = ((unsigned char) c) | ATTR_ASCII;
1117 break;
1118 case ATTR_SCOACS:
1119 if (c>=' ') c = ((unsigned char)c) | ATTR_SCOACS;
1120 break;
1121 }
1122 }
1123 }
1124
1125 /* How about C1 controls ? */
1126 if ((c & -32) == 0x80 && termstate < DO_CTRLS && !vt52_mode &&
1127 has_compat(VT220)) {
1128 termstate = SEEN_ESC;
1129 esc_query = FALSE;
1130 c = '@' + (c & 0x1F);
1131 }
1132
1133 /* Or the GL control. */
1134 if (c == '\177' && termstate < DO_CTRLS && has_compat(OTHER)) {
1135 if (curs.x && !wrapnext)
1136 curs.x--;
1137 wrapnext = FALSE;
1138 fix_cpos;
1139 *cpos = (' ' | curr_attr | ATTR_ASCII);
1140 } else
1141 /* Or normal C0 controls. */
1142 if ((c & -32) == 0 && termstate < DO_CTRLS) {
1143 switch (c) {
1144 case '\005': /* terminal type query */
1145 /* Strictly speaking this is VT100 but a VT100 defaults to
1146 * no response. Other terminals respond at their option.
1147 *
1148 * Don't put a CR in the default string as this tends to
1149 * upset some weird software.
1150 *
1151 * An xterm returns "xterm" (5 characters)
1152 */
1153 compatibility(ANSIMIN);
1154 {
1155 char abuf[256], *s, *d;
1156 int state = 0;
1157 for (s = cfg.answerback, d = abuf; *s; s++) {
1158 if (state) {
1159 if (*s >= 'a' && *s <= 'z')
1160 *d++ = (*s - ('a' - 1));
1161 else if ((*s >= '@' && *s <= '_') ||
1162 *s == '?' || (*s & 0x80))
1163 *d++ = ('@' ^ *s);
1164 else if (*s == '~')
1165 *d++ = '^';
1166 state = 0;
1167 } else if (*s == '^') {
1168 state = 1;
1169 } else
1170 *d++ = *s;
1171 }
1172 lpage_send(CP_ACP, abuf, d - abuf);
1173 }
1174 break;
1175 case '\007':
1176 {
1177 struct beeptime *newbeep;
1178 long ticks;
1179
1180 ticks = GetTickCount();
1181
1182 if (!beep_overloaded) {
1183 newbeep = smalloc(sizeof(struct beeptime));
1184 newbeep->ticks = ticks;
1185 newbeep->next = NULL;
1186 if (!beephead)
1187 beephead = newbeep;
1188 else
1189 beeptail->next = newbeep;
1190 beeptail = newbeep;
1191 nbeeps++;
1192 }
1193
1194 /*
1195 * Throw out any beeps that happened more than
1196 * t seconds ago.
1197 */
1198 while (beephead &&
1199 beephead->ticks < ticks - cfg.bellovl_t) {
1200 struct beeptime *tmp = beephead;
1201 beephead = tmp->next;
1202 sfree(tmp);
1203 if (!beephead)
1204 beeptail = NULL;
1205 nbeeps--;
1206 }
1207
1208 if (cfg.bellovl && beep_overloaded &&
1209 ticks - lastbeep >= cfg.bellovl_s) {
1210 /*
1211 * If we're currently overloaded and the
1212 * last beep was more than s seconds ago,
1213 * leave overload mode.
1214 */
1215 beep_overloaded = FALSE;
1216 } else if (cfg.bellovl && !beep_overloaded &&
1217 nbeeps >= cfg.bellovl_n) {
1218 /*
1219 * Now, if we have n or more beeps
1220 * remaining in the queue, go into overload
1221 * mode.
1222 */
1223 beep_overloaded = TRUE;
1224 }
1225 lastbeep = ticks;
1226
1227 /*
1228 * Perform an actual beep if we're not overloaded.
1229 */
1230 if (!cfg.bellovl || !beep_overloaded) {
1231 beep(cfg.beep);
1232 if (cfg.beep == BELL_VISUAL) {
1233 in_vbell = TRUE;
1234 vbell_timeout = ticks + VBELL_TIMEOUT;
1235 term_update();
1236 }
1237 }
1238 disptop = 0;
1239 }
1240 break;
1241 case '\b':
1242 if (curs.x == 0 && (curs.y == 0 || wrap == 0));
1243 else if (curs.x == 0 && curs.y > 0)
1244 curs.x = cols - 1, curs.y--;
1245 else if (wrapnext)
1246 wrapnext = FALSE;
1247 else
1248 curs.x--;
1249 fix_cpos;
1250 seen_disp_event = TRUE;
1251 break;
1252 case '\016':
1253 compatibility(VT100);
1254 cset = 1;
1255 break;
1256 case '\017':
1257 compatibility(VT100);
1258 cset = 0;
1259 break;
1260 case '\033':
1261 if (vt52_mode)
1262 termstate = VT52_ESC;
1263 else {
1264 compatibility(ANSIMIN);
1265 termstate = SEEN_ESC;
1266 esc_query = FALSE;
1267 }
1268 break;
1269 case '\r':
1270 curs.x = 0;
1271 wrapnext = FALSE;
1272 fix_cpos;
1273 seen_disp_event = TRUE;
1274 paste_hold = 0;
1275 logtraffic((unsigned char) c, LGTYP_ASCII);
1276 break;
1277 case '\014':
1278 if (has_compat(SCOANSI)) {
1279 move(0, 0, 0);
1280 erase_lots(FALSE, FALSE, TRUE);
1281 disptop = 0;
1282 wrapnext = FALSE;
1283 seen_disp_event = 1;
1284 break;
1285 }
1286 case '\013':
1287 compatibility(VT100);
1288 case '\n':
1289 if (curs.y == marg_b)
1290 scroll(marg_t, marg_b, 1, TRUE);
1291 else if (curs.y < rows - 1)
1292 curs.y++;
1293 if (cfg.lfhascr)
1294 curs.x = 0;
1295 fix_cpos;
1296 wrapnext = FALSE;
1297 seen_disp_event = 1;
1298 paste_hold = 0;
1299 logtraffic((unsigned char) c, LGTYP_ASCII);
1300 break;
1301 case '\t':
1302 {
1303 pos old_curs = curs;
1304 unsigned long *ldata = lineptr(curs.y);
1305
1306 do {
1307 curs.x++;
1308 } while (curs.x < cols - 1 && !tabs[curs.x]);
1309
1310 if ((ldata[cols] & LATTR_MODE) != LATTR_NORM) {
1311 if (curs.x >= cols / 2)
1312 curs.x = cols / 2 - 1;
1313 } else {
1314 if (curs.x >= cols)
1315 curs.x = cols - 1;
1316 }
1317
1318 fix_cpos;
1319 check_selection(old_curs, curs);
1320 }
1321 seen_disp_event = TRUE;
1322 break;
1323 }
1324 } else
1325 switch (termstate) {
1326 case TOPLEVEL:
1327 /* Only graphic characters get this far, ctrls are stripped above */
1328 if (wrapnext && wrap) {
1329 cpos[1] |= LATTR_WRAPPED;
1330 if (curs.y == marg_b)
1331 scroll(marg_t, marg_b, 1, TRUE);
1332 else if (curs.y < rows - 1)
1333 curs.y++;
1334 curs.x = 0;
1335 fix_cpos;
1336 wrapnext = FALSE;
1337 }
1338 if (insert)
1339 insch(1);
1340 if (selstate != NO_SELECTION) {
1341 pos cursplus = curs;
1342 incpos(cursplus);
1343 check_selection(curs, cursplus);
1344 }
1345 if ((c & CSET_MASK) == ATTR_ASCII || (c & CSET_MASK) == 0)
1346 logtraffic((unsigned char) c, LGTYP_ASCII);
1347 {
1348 extern int wcwidth(wchar_t ucs);
1349 int width = 0;
1350 if (DIRECT_CHAR(c))
1351 width = 1;
1352 if (!width)
1353 width = wcwidth((wchar_t) c);
1354 switch (width) {
1355 case 2:
1356 *cpos++ = c | curr_attr;
1357 if (++curs.x == cols) {
1358 *cpos |= LATTR_WRAPPED;
1359 if (curs.y == marg_b)
1360 scroll(marg_t, marg_b, 1, TRUE);
1361 else if (curs.y < rows - 1)
1362 curs.y++;
1363 curs.x = 0;
1364 fix_cpos;
1365 }
1366 *cpos++ = UCSWIDE | curr_attr;
1367 break;
1368 case 1:
1369 *cpos++ = c | curr_attr;
1370 break;
1371 default:
1372 continue;
1373 }
1374 }
1375 curs.x++;
1376 if (curs.x == cols) {
1377 cpos--;
1378 curs.x--;
1379 wrapnext = TRUE;
1380 if (wrap && vt52_mode) {
1381 cpos[1] |= LATTR_WRAPPED;
1382 if (curs.y == marg_b)
1383 scroll(marg_t, marg_b, 1, TRUE);
1384 else if (curs.y < rows - 1)
1385 curs.y++;
1386 curs.x = 0;
1387 fix_cpos;
1388 wrapnext = FALSE;
1389 }
1390 }
1391 seen_disp_event = 1;
1392 break;
1393
1394 case OSC_MAYBE_ST:
1395 /*
1396 * This state is virtually identical to SEEN_ESC, with the
1397 * exception that we have an OSC sequence in the pipeline,
1398 * and _if_ we see a backslash, we process it.
1399 */
1400 if (c == '\\') {
1401 do_osc();
1402 termstate = TOPLEVEL;
1403 break;
1404 }
1405 /* else fall through */
1406 case SEEN_ESC:
1407 if (c >= ' ' && c <= '/') {
1408 if (esc_query)
1409 esc_query = -1;
1410 else
1411 esc_query = c;
1412 break;
1413 }
1414 termstate = TOPLEVEL;
1415 switch (ANSI(c, esc_query)) {
1416 case '[': /* enter CSI mode */
1417 termstate = SEEN_CSI;
1418 esc_nargs = 1;
1419 esc_args[0] = ARG_DEFAULT;
1420 esc_query = FALSE;
1421 break;
1422 case ']': /* xterm escape sequences */
1423 /* Compatibility is nasty here, xterm, linux, decterm yuk! */
1424 compatibility(OTHER);
1425 termstate = SEEN_OSC;
1426 esc_args[0] = 0;
1427 break;
1428 case '7': /* save cursor */
1429 compatibility(VT100);
1430 save_cursor(TRUE);
1431 break;
1432 case '8': /* restore cursor */
1433 compatibility(VT100);
1434 save_cursor(FALSE);
1435 seen_disp_event = TRUE;
1436 break;
1437 case '=':
1438 compatibility(VT100);
1439 app_keypad_keys = TRUE;
1440 break;
1441 case '>':
1442 compatibility(VT100);
1443 app_keypad_keys = FALSE;
1444 break;
1445 case 'D': /* exactly equivalent to LF */
1446 compatibility(VT100);
1447 if (curs.y == marg_b)
1448 scroll(marg_t, marg_b, 1, TRUE);
1449 else if (curs.y < rows - 1)
1450 curs.y++;
1451 fix_cpos;
1452 wrapnext = FALSE;
1453 seen_disp_event = TRUE;
1454 break;
1455 case 'E': /* exactly equivalent to CR-LF */
1456 compatibility(VT100);
1457 curs.x = 0;
1458 if (curs.y == marg_b)
1459 scroll(marg_t, marg_b, 1, TRUE);
1460 else if (curs.y < rows - 1)
1461 curs.y++;
1462 fix_cpos;
1463 wrapnext = FALSE;
1464 seen_disp_event = TRUE;
1465 break;
1466 case 'M': /* reverse index - backwards LF */
1467 compatibility(VT100);
1468 if (curs.y == marg_t)
1469 scroll(marg_t, marg_b, -1, TRUE);
1470 else if (curs.y > 0)
1471 curs.y--;
1472 fix_cpos;
1473 wrapnext = FALSE;
1474 seen_disp_event = TRUE;
1475 break;
1476 case 'Z': /* terminal type query */
1477 compatibility(VT100);
1478 ldisc_send(id_string, strlen(id_string));
1479 break;
1480 case 'c': /* restore power-on settings */
1481 compatibility(VT100);
1482 power_on();
1483 if (reset_132) {
1484 request_resize(80, rows);
1485 reset_132 = 0;
1486 }
1487 fix_cpos;
1488 disptop = 0;
1489 seen_disp_event = TRUE;
1490 break;
1491 case 'H': /* set a tab */
1492 compatibility(VT100);
1493 tabs[curs.x] = TRUE;
1494 break;
1495
1496 case ANSI('8', '#'): /* ESC # 8 fills screen with Es :-) */
1497 compatibility(VT100);
1498 {
1499 unsigned long *ldata;
1500 int i, j;
1501 pos scrtop, scrbot;
1502
1503 for (i = 0; i < rows; i++) {
1504 ldata = lineptr(i);
1505 for (j = 0; j < cols; j++)
1506 ldata[j] = ATTR_DEFAULT | 'E';
1507 ldata[cols] = 0;
1508 }
1509 disptop = 0;
1510 seen_disp_event = TRUE;
1511 scrtop.x = scrtop.y = 0;
1512 scrbot.x = 0;
1513 scrbot.y = rows;
1514 check_selection(scrtop, scrbot);
1515 }
1516 break;
1517
1518 case ANSI('3', '#'):
1519 case ANSI('4', '#'):
1520 case ANSI('5', '#'):
1521 case ANSI('6', '#'):
1522 compatibility(VT100);
1523 {
1524 unsigned long nlattr;
1525 unsigned long *ldata;
1526 switch (ANSI(c, esc_query)) {
1527 case ANSI('3', '#'):
1528 nlattr = LATTR_TOP;
1529 break;
1530 case ANSI('4', '#'):
1531 nlattr = LATTR_BOT;
1532 break;
1533 case ANSI('5', '#'):
1534 nlattr = LATTR_NORM;
1535 break;
1536 default: /* spiritually case ANSI('6', '#'): */
1537 nlattr = LATTR_WIDE;
1538 break;
1539 }
1540 ldata = lineptr(curs.y);
1541 ldata[cols] &= ~LATTR_MODE;
1542 ldata[cols] |= nlattr;
1543 }
1544 break;
1545
1546 case ANSI('A', '('):
1547 compatibility(VT100);
1548 cset_attr[0] = ATTR_GBCHR;
1549 break;
1550 case ANSI('B', '('):
1551 compatibility(VT100);
1552 cset_attr[0] = ATTR_ASCII;
1553 break;
1554 case ANSI('0', '('):
1555 compatibility(VT100);
1556 cset_attr[0] = ATTR_LINEDRW;
1557 break;
1558 case ANSI('U', '('):
1559 compatibility(OTHER);
1560 cset_attr[0] = ATTR_SCOACS;
1561 break;
1562
1563 case ANSI('A', ')'):
1564 compatibility(VT100);
1565 cset_attr[1] = ATTR_GBCHR;
1566 break;
1567 case ANSI('B', ')'):
1568 compatibility(VT100);
1569 cset_attr[1] = ATTR_ASCII;
1570 break;
1571 case ANSI('0', ')'):
1572 compatibility(VT100);
1573 cset_attr[1] = ATTR_LINEDRW;
1574 break;
1575 case ANSI('U', ')'):
1576 compatibility(OTHER);
1577 cset_attr[1] = ATTR_SCOACS;
1578 break;
1579
1580 case ANSI('8', '%'): /* Old Linux code */
1581 case ANSI('G', '%'):
1582 compatibility(OTHER);
1583 utf = 1;
1584 break;
1585 case ANSI('@', '%'):
1586 compatibility(OTHER);
1587 utf = 0;
1588 break;
1589 }
1590 break;
1591 case SEEN_CSI:
1592 termstate = TOPLEVEL; /* default */
1593 if (isdigit(c)) {
1594 if (esc_nargs <= ARGS_MAX) {
1595 if (esc_args[esc_nargs - 1] == ARG_DEFAULT)
1596 esc_args[esc_nargs - 1] = 0;
1597 esc_args[esc_nargs - 1] =
1598 10 * esc_args[esc_nargs - 1] + c - '0';
1599 }
1600 termstate = SEEN_CSI;
1601 } else if (c == ';') {
1602 if (++esc_nargs <= ARGS_MAX)
1603 esc_args[esc_nargs - 1] = ARG_DEFAULT;
1604 termstate = SEEN_CSI;
1605 } else if (c < '@') {
1606 if (esc_query)
1607 esc_query = -1;
1608 else if (c == '?')
1609 esc_query = TRUE;
1610 else
1611 esc_query = c;
1612 termstate = SEEN_CSI;
1613 } else
1614 switch (ANSI(c, esc_query)) {
1615 case 'A': /* move up N lines */
1616 move(curs.x, curs.y - def(esc_args[0], 1), 1);
1617 seen_disp_event = TRUE;
1618 break;
1619 case 'e': /* move down N lines */
1620 compatibility(ANSI);
1621 /* FALLTHROUGH */
1622 case 'B':
1623 move(curs.x, curs.y + def(esc_args[0], 1), 1);
1624 seen_disp_event = TRUE;
1625 break;
1626 case ANSI('c', '>'): /* report xterm version */
1627 compatibility(OTHER);
1628 /* this reports xterm version 136 so that VIM can
1629 use the drag messages from the mouse reporting */
1630 ldisc_send("\033[>0;136;0c", 11);
1631 break;
1632 case 'a': /* move right N cols */
1633 compatibility(ANSI);
1634 /* FALLTHROUGH */
1635 case 'C':
1636 move(curs.x + def(esc_args[0], 1), curs.y, 1);
1637 seen_disp_event = TRUE;
1638 break;
1639 case 'D': /* move left N cols */
1640 move(curs.x - def(esc_args[0], 1), curs.y, 1);
1641 seen_disp_event = TRUE;
1642 break;
1643 case 'E': /* move down N lines and CR */
1644 compatibility(ANSI);
1645 move(0, curs.y + def(esc_args[0], 1), 1);
1646 seen_disp_event = TRUE;
1647 break;
1648 case 'F': /* move up N lines and CR */
1649 compatibility(ANSI);
1650 move(0, curs.y - def(esc_args[0], 1), 1);
1651 seen_disp_event = TRUE;
1652 break;
1653 case 'G':
1654 case '`': /* set horizontal posn */
1655 compatibility(ANSI);
1656 move(def(esc_args[0], 1) - 1, curs.y, 0);
1657 seen_disp_event = TRUE;
1658 break;
1659 case 'd': /* set vertical posn */
1660 compatibility(ANSI);
1661 move(curs.x,
1662 (dec_om ? marg_t : 0) + def(esc_args[0],
1663 1) - 1,
1664 (dec_om ? 2 : 0));
1665 seen_disp_event = TRUE;
1666 break;
1667 case 'H':
1668 case 'f': /* set horz and vert posns at once */
1669 if (esc_nargs < 2)
1670 esc_args[1] = ARG_DEFAULT;
1671 move(def(esc_args[1], 1) - 1,
1672 (dec_om ? marg_t : 0) + def(esc_args[0],
1673 1) - 1,
1674 (dec_om ? 2 : 0));
1675 seen_disp_event = TRUE;
1676 break;
1677 case 'J': /* erase screen or parts of it */
1678 {
1679 unsigned int i = def(esc_args[0], 0) + 1;
1680 if (i > 3)
1681 i = 0;
1682 erase_lots(FALSE, !!(i & 2), !!(i & 1));
1683 }
1684 disptop = 0;
1685 seen_disp_event = TRUE;
1686 break;
1687 case 'K': /* erase line or parts of it */
1688 {
1689 unsigned int i = def(esc_args[0], 0) + 1;
1690 if (i > 3)
1691 i = 0;
1692 erase_lots(TRUE, !!(i & 2), !!(i & 1));
1693 }
1694 seen_disp_event = TRUE;
1695 break;
1696 case 'L': /* insert lines */
1697 compatibility(VT102);
1698 if (curs.y <= marg_b)
1699 scroll(curs.y, marg_b, -def(esc_args[0], 1),
1700 FALSE);
1701 fix_cpos;
1702 seen_disp_event = TRUE;
1703 break;
1704 case 'M': /* delete lines */
1705 compatibility(VT102);
1706 if (curs.y <= marg_b)
1707 scroll(curs.y, marg_b, def(esc_args[0], 1),
1708 TRUE);
1709 fix_cpos;
1710 seen_disp_event = TRUE;
1711 break;
1712 case '@': /* insert chars */
1713 /* XXX VTTEST says this is vt220, vt510 manual says vt102 */
1714 compatibility(VT102);
1715 insch(def(esc_args[0], 1));
1716 seen_disp_event = TRUE;
1717 break;
1718 case 'P': /* delete chars */
1719 compatibility(VT102);
1720 insch(-def(esc_args[0], 1));
1721 seen_disp_event = TRUE;
1722 break;
1723 case 'c': /* terminal type query */
1724 compatibility(VT100);
1725 /* This is the response for a VT102 */
1726 ldisc_send(id_string, strlen(id_string));
1727 break;
1728 case 'n': /* cursor position query */
1729 if (esc_args[0] == 6) {
1730 char buf[32];
1731 sprintf(buf, "\033[%d;%dR", curs.y + 1,
1732 curs.x + 1);
1733 ldisc_send(buf, strlen(buf));
1734 } else if (esc_args[0] == 5) {
1735 ldisc_send("\033[0n", 4);
1736 }
1737 break;
1738 case 'h': /* toggle modes to high */
1739 case ANSI_QUE('h'):
1740 compatibility(VT100);
1741 {
1742 int i;
1743 for (i = 0; i < esc_nargs; i++)
1744 toggle_mode(esc_args[i], esc_query, TRUE);
1745 }
1746 break;
1747 case 'l': /* toggle modes to low */
1748 case ANSI_QUE('l'):
1749 compatibility(VT100);
1750 {
1751 int i;
1752 for (i = 0; i < esc_nargs; i++)
1753 toggle_mode(esc_args[i], esc_query, FALSE);
1754 }
1755 break;
1756 case 'g': /* clear tabs */
1757 compatibility(VT100);
1758 if (esc_nargs == 1) {
1759 if (esc_args[0] == 0) {
1760 tabs[curs.x] = FALSE;
1761 } else if (esc_args[0] == 3) {
1762 int i;
1763 for (i = 0; i < cols; i++)
1764 tabs[i] = FALSE;
1765 }
1766 }
1767 break;
1768 case 'r': /* set scroll margins */
1769 compatibility(VT100);
1770 if (esc_nargs <= 2) {
1771 int top, bot;
1772 top = def(esc_args[0], 1) - 1;
1773 bot = (esc_nargs <= 1
1774 || esc_args[1] ==
1775 0 ? rows : def(esc_args[1], rows)) - 1;
1776 if (bot >= rows)
1777 bot = rows - 1;
1778 /* VTTEST Bug 9 - if region is less than 2 lines
1779 * don't change region.
1780 */
1781 if (bot - top > 0) {
1782 marg_t = top;
1783 marg_b = bot;
1784 curs.x = 0;
1785 /*
1786 * I used to think the cursor should be
1787 * placed at the top of the newly marginned
1788 * area. Apparently not: VMS TPU falls over
1789 * if so.
1790 *
1791 * Well actually it should for Origin mode - RDB
1792 */
1793 curs.y = (dec_om ? marg_t : 0);
1794 fix_cpos;
1795 seen_disp_event = TRUE;
1796 }
1797 }
1798 break;
1799 case 'm': /* set graphics rendition */
1800 {
1801 /*
1802 * A VT100 without the AVO only had one attribute, either
1803 * underline or reverse video depending on the cursor type,
1804 * this was selected by CSI 7m.
1805 *
1806 * case 2:
1807 * This is sometimes DIM, eg on the GIGI and Linux
1808 * case 8:
1809 * This is sometimes INVIS various ANSI.
1810 * case 21:
1811 * This like 22 disables BOLD, DIM and INVIS
1812 *
1813 * The ANSI colours appear on any terminal that has colour
1814 * (obviously) but the interaction between sgr0 and the
1815 * colours varies but is usually related to the background
1816 * colour erase item.
1817 * The interaction between colour attributes and the mono
1818 * ones is also very implementation dependent.
1819 *
1820 * The 39 and 49 attributes are likely to be unimplemented.
1821 */
1822 int i;
1823 for (i = 0; i < esc_nargs; i++) {
1824 switch (def(esc_args[i], 0)) {
1825 case 0: /* restore defaults */
1826 curr_attr = ATTR_DEFAULT;
1827 break;
1828 case 1: /* enable bold */
1829 compatibility(VT100AVO);
1830 curr_attr |= ATTR_BOLD;
1831 break;
1832 case 21: /* (enable double underline) */
1833 compatibility(OTHER);
1834 case 4: /* enable underline */
1835 compatibility(VT100AVO);
1836 curr_attr |= ATTR_UNDER;
1837 break;
1838 case 5: /* enable blink */
1839 compatibility(VT100AVO);
1840 curr_attr |= ATTR_BLINK;
1841 break;
1842 case 7: /* enable reverse video */
1843 curr_attr |= ATTR_REVERSE;
1844 break;
1845 case 10: /* SCO acs off */
1846 compatibility(SCOANSI);
1847 sco_acs = 0; break;
1848 case 11: /* SCO acs on */
1849 compatibility(SCOANSI);
1850 sco_acs = 1; break;
1851 case 12: /* SCO acs on flipped */
1852 compatibility(SCOANSI);
1853 sco_acs = 2; break;
1854 case 22: /* disable bold */
1855 compatibility2(OTHER, VT220);
1856 curr_attr &= ~ATTR_BOLD;
1857 break;
1858 case 24: /* disable underline */
1859 compatibility2(OTHER, VT220);
1860 curr_attr &= ~ATTR_UNDER;
1861 break;
1862 case 25: /* disable blink */
1863 compatibility2(OTHER, VT220);
1864 curr_attr &= ~ATTR_BLINK;
1865 break;
1866 case 27: /* disable reverse video */
1867 compatibility2(OTHER, VT220);
1868 curr_attr &= ~ATTR_REVERSE;
1869 break;
1870 case 30:
1871 case 31:
1872 case 32:
1873 case 33:
1874 case 34:
1875 case 35:
1876 case 36:
1877 case 37:
1878 /* foreground */
1879 curr_attr &= ~ATTR_FGMASK;
1880 curr_attr |=
1881 (esc_args[i] - 30) << ATTR_FGSHIFT;
1882 break;
1883 case 39: /* default-foreground */
1884 curr_attr &= ~ATTR_FGMASK;
1885 curr_attr |= ATTR_DEFFG;
1886 break;
1887 case 40:
1888 case 41:
1889 case 42:
1890 case 43:
1891 case 44:
1892 case 45:
1893 case 46:
1894 case 47:
1895 /* background */
1896 curr_attr &= ~ATTR_BGMASK;
1897 curr_attr |=
1898 (esc_args[i] - 40) << ATTR_BGSHIFT;
1899 break;
1900 case 49: /* default-background */
1901 curr_attr &= ~ATTR_BGMASK;
1902 curr_attr |= ATTR_DEFBG;
1903 break;
1904 }
1905 }
1906 if (use_bce)
1907 erase_char = (' ' | ATTR_ASCII |
1908 (curr_attr &
1909 (ATTR_FGMASK | ATTR_BGMASK)));
1910 }
1911 break;
1912 case 's': /* save cursor */
1913 save_cursor(TRUE);
1914 break;
1915 case 'u': /* restore cursor */
1916 save_cursor(FALSE);
1917 seen_disp_event = TRUE;
1918 break;
1919 case 't': /* set page size - ie window height */
1920 /*
1921 * VT340/VT420 sequence DECSLPP, DEC only allows values
1922 * 24/25/36/48/72/144 other emulators (eg dtterm) use
1923 * illegal values (eg first arg 1..9) for window changing
1924 * and reports.
1925 */
1926 compatibility(VT340TEXT);
1927 if (esc_nargs <= 1
1928 && (esc_args[0] < 1 || esc_args[0] >= 24)) {
1929 request_resize(cols, def(esc_args[0], 24));
1930 deselect();
1931 }
1932 break;
1933 case 'S':
1934 compatibility(SCOANSI);
1935 scroll(marg_t, marg_b, def(esc_args[0], 1), TRUE);
1936 fix_cpos;
1937 wrapnext = FALSE;
1938 seen_disp_event = TRUE;
1939 break;
1940 case 'T':
1941 compatibility(SCOANSI);
1942 scroll(marg_t, marg_b, -def(esc_args[0], 1), TRUE);
1943 fix_cpos;
1944 wrapnext = FALSE;
1945 seen_disp_event = TRUE;
1946 break;
1947 case ANSI('|', '*'):
1948 /* VT420 sequence DECSNLS
1949 * Set number of lines on screen
1950 * VT420 uses VGA like hardware and can support any size in
1951 * reasonable range (24..49 AIUI) with no default specified.
1952 */
1953 compatibility(VT420);
1954 if (esc_nargs == 1 && esc_args[0] > 0) {
1955 request_resize(cols, def(esc_args[0], cfg.height));
1956 deselect();
1957 }
1958 break;
1959 case ANSI('|', '$'):
1960 /* VT340/VT420 sequence DECSCPP
1961 * Set number of columns per page
1962 * Docs imply range is only 80 or 132, but I'll allow any.
1963 */
1964 compatibility(VT340TEXT);
1965 if (esc_nargs <= 1) {
1966 request_resize(def(esc_args[0], cfg.width), rows);
1967 deselect();
1968 }
1969 break;
1970 case 'X': /* write N spaces w/o moving cursor */
1971 /* XXX VTTEST says this is vt220, vt510 manual says vt100 */
1972 compatibility(ANSIMIN);
1973 {
1974 int n = def(esc_args[0], 1);
1975 pos cursplus;
1976 unsigned long *p = cpos;
1977 if (n > cols - curs.x)
1978 n = cols - curs.x;
1979 cursplus = curs;
1980 cursplus.x += n;
1981 check_selection(curs, cursplus);
1982 while (n--)
1983 *p++ = erase_char;
1984 seen_disp_event = TRUE;
1985 }
1986 break;
1987 case 'x': /* report terminal characteristics */
1988 compatibility(VT100);
1989 {
1990 char buf[32];
1991 int i = def(esc_args[0], 0);
1992 if (i == 0 || i == 1) {
1993 strcpy(buf, "\033[2;1;1;112;112;1;0x");
1994 buf[2] += i;
1995 ldisc_send(buf, 20);
1996 }
1997 }
1998 break;
1999 case 'Z': /* BackTab for xterm */
2000 compatibility(OTHER);
2001 {
2002 int i = def(esc_args[0], 1);
2003 pos old_curs = curs;
2004
2005 for(;i>0 && curs.x>0; i--) {
2006 do {
2007 curs.x--;
2008 } while (curs.x >0 && !tabs[curs.x]);
2009 }
2010 fix_cpos;
2011 check_selection(old_curs, curs);
2012 }
2013 break;
2014 case ANSI('L', '='):
2015 compatibility(OTHER);
2016 use_bce = (esc_args[0] <= 0);
2017 erase_char = ERASE_CHAR;
2018 if (use_bce)
2019 erase_char = (' ' | ATTR_ASCII |
2020 (curr_attr &
2021 (ATTR_FGMASK | ATTR_BGMASK)));
2022 break;
2023 case ANSI('E', '='):
2024 compatibility(OTHER);
2025 blink_is_real = (esc_args[0] >= 1);
2026 break;
2027 case ANSI('p', '"'):
2028 /* Allow the host to make this emulator a 'perfect' VT102.
2029 * This first appeared in the VT220, but we do need to get
2030 * back to PuTTY mode so I won't check it.
2031 *
2032 * The arg in 40..42,50 are a PuTTY extension.
2033 * The 2nd arg, 8bit vs 7bit is not checked.
2034 *
2035 * Setting VT102 mode should also change the Fkeys to
2036 * generate PF* codes as a real VT102 has no Fkeys.
2037 * The VT220 does this, F11..F13 become ESC,BS,LF other Fkeys
2038 * send nothing.
2039 *
2040 * Note ESC c will NOT change this!
2041 */
2042
2043 switch (esc_args[0]) {
2044 case 61:
2045 compatibility_level &= ~TM_VTXXX;
2046 compatibility_level |= TM_VT102;
2047 break;
2048 case 62:
2049 compatibility_level &= ~TM_VTXXX;
2050 compatibility_level |= TM_VT220;
2051 break;
2052
2053 default:
2054 if (esc_args[0] > 60 && esc_args[0] < 70)
2055 compatibility_level |= TM_VTXXX;
2056 break;
2057
2058 case 40:
2059 compatibility_level &= TM_VTXXX;
2060 break;
2061 case 41:
2062 compatibility_level = TM_PUTTY;
2063 break;
2064 case 42:
2065 compatibility_level = TM_SCOANSI;
2066 break;
2067
2068 case ARG_DEFAULT:
2069 compatibility_level = TM_PUTTY;
2070 break;
2071 case 50:
2072 break;
2073 }
2074
2075 /* Change the response to CSI c */
2076 if (esc_args[0] == 50) {
2077 int i;
2078 char lbuf[64];
2079 strcpy(id_string, "\033[?");
2080 for (i = 1; i < esc_nargs; i++) {
2081 if (i != 1)
2082 strcat(id_string, ";");
2083 sprintf(lbuf, "%d", esc_args[i]);
2084 strcat(id_string, lbuf);
2085 }
2086 strcat(id_string, "c");
2087 }
2088 #if 0
2089 /* Is this a good idea ?
2090 * Well we should do a soft reset at this point ...
2091 */
2092 if (!has_compat(VT420) && has_compat(VT100)) {
2093 if (reset_132)
2094 request_resize(132, 24);
2095 else
2096 request_resize(80, 24);
2097 }
2098 #endif
2099 break;
2100 }
2101 break;
2102 case SEEN_OSC:
2103 osc_w = FALSE;
2104 switch (c) {
2105 case 'P': /* Linux palette sequence */
2106 termstate = SEEN_OSC_P;
2107 osc_strlen = 0;
2108 break;
2109 case 'R': /* Linux palette reset */
2110 palette_reset();
2111 term_invalidate();
2112 termstate = TOPLEVEL;
2113 break;
2114 case 'W': /* word-set */
2115 termstate = SEEN_OSC_W;
2116 osc_w = TRUE;
2117 break;
2118 case '0':
2119 case '1':
2120 case '2':
2121 case '3':
2122 case '4':
2123 case '5':
2124 case '6':
2125 case '7':
2126 case '8':
2127 case '9':
2128 esc_args[0] = 10 * esc_args[0] + c - '0';
2129 break;
2130 case 'L':
2131 /*
2132 * Grotty hack to support xterm and DECterm title
2133 * sequences concurrently.
2134 */
2135 if (esc_args[0] == 2) {
2136 esc_args[0] = 1;
2137 break;
2138 }
2139 /* else fall through */
2140 default:
2141 termstate = OSC_STRING;
2142 osc_strlen = 0;
2143 }
2144 break;
2145 case OSC_STRING:
2146 /*
2147 * This OSC stuff is EVIL. It takes just one character to get into
2148 * sysline mode and it's not initially obvious how to get out.
2149 * So I've added CR and LF as string aborts.
2150 * This shouldn't effect compatibility as I believe embedded
2151 * control characters are supposed to be interpreted (maybe?)
2152 * and they don't display anything useful anyway.
2153 *
2154 * -- RDB
2155 */
2156 if (c == '\n' || c == '\r') {
2157 termstate = TOPLEVEL;
2158 } else if (c == 0234 || c == '\007') {
2159 /*
2160 * These characters terminate the string; ST and BEL
2161 * terminate the sequence and trigger instant
2162 * processing of it, whereas ESC goes back to SEEN_ESC
2163 * mode unless it is followed by \, in which case it is
2164 * synonymous with ST in the first place.
2165 */
2166 do_osc();
2167 termstate = TOPLEVEL;
2168 } else if (c == '\033')
2169 termstate = OSC_MAYBE_ST;
2170 else if (osc_strlen < OSC_STR_MAX)
2171 osc_string[osc_strlen++] = c;
2172 break;
2173 case SEEN_OSC_P:
2174 {
2175 int max = (osc_strlen == 0 ? 21 : 16);
2176 int val;
2177 if (c >= '0' && c <= '9')
2178 val = c - '0';
2179 else if (c >= 'A' && c <= 'A' + max - 10)
2180 val = c - 'A' + 10;
2181 else if (c >= 'a' && c <= 'a' + max - 10)
2182 val = c - 'a' + 10;
2183 else {
2184 termstate = TOPLEVEL;
2185 break;
2186 }
2187 osc_string[osc_strlen++] = val;
2188 if (osc_strlen >= 7) {
2189 palette_set(osc_string[0],
2190 osc_string[1] * 16 + osc_string[2],
2191 osc_string[3] * 16 + osc_string[4],
2192 osc_string[5] * 16 + osc_string[6]);
2193 term_invalidate();
2194 termstate = TOPLEVEL;
2195 }
2196 }
2197 break;
2198 case SEEN_OSC_W:
2199 switch (c) {
2200 case '0':
2201 case '1':
2202 case '2':
2203 case '3':
2204 case '4':
2205 case '5':
2206 case '6':
2207 case '7':
2208 case '8':
2209 case '9':
2210 esc_args[0] = 10 * esc_args[0] + c - '0';
2211 break;
2212 default:
2213 termstate = OSC_STRING;
2214 osc_strlen = 0;
2215 }
2216 break;
2217 case VT52_ESC:
2218 termstate = TOPLEVEL;
2219 seen_disp_event = TRUE;
2220 switch (c) {
2221 case 'A':
2222 move(curs.x, curs.y - 1, 1);
2223 break;
2224 case 'B':
2225 move(curs.x, curs.y + 1, 1);
2226 break;
2227 case 'C':
2228 move(curs.x + 1, curs.y, 1);
2229 break;
2230 case 'D':
2231 move(curs.x - 1, curs.y, 1);
2232 break;
2233 /*
2234 * From the VT100 Manual
2235 * NOTE: The special graphics characters in the VT100
2236 * are different from those in the VT52
2237 *
2238 * From VT102 manual:
2239 * 137 _ Blank - Same
2240 * 140 ` Reserved - Humm.
2241 * 141 a Solid rectangle - Similar
2242 * 142 b 1/ - Top half of fraction for the
2243 * 143 c 3/ - subscript numbers below.
2244 * 144 d 5/
2245 * 145 e 7/
2246 * 146 f Degrees - Same
2247 * 147 g Plus or minus - Same
2248 * 150 h Right arrow
2249 * 151 i Ellipsis (dots)
2250 * 152 j Divide by
2251 * 153 k Down arrow
2252 * 154 l Bar at scan 0
2253 * 155 m Bar at scan 1
2254 * 156 n Bar at scan 2
2255 * 157 o Bar at scan 3 - Similar
2256 * 160 p Bar at scan 4 - Similar
2257 * 161 q Bar at scan 5 - Similar
2258 * 162 r Bar at scan 6 - Same
2259 * 163 s Bar at scan 7 - Similar
2260 * 164 t Subscript 0
2261 * 165 u Subscript 1
2262 * 166 v Subscript 2
2263 * 167 w Subscript 3
2264 * 170 x Subscript 4
2265 * 171 y Subscript 5
2266 * 172 z Subscript 6
2267 * 173 { Subscript 7
2268 * 174 | Subscript 8
2269 * 175 } Subscript 9
2270 * 176 ~ Paragraph
2271 *
2272 */
2273 case 'F':
2274 cset_attr[cset = 0] = ATTR_LINEDRW;
2275 break;
2276 case 'G':
2277 cset_attr[cset = 0] = ATTR_ASCII;
2278 break;
2279 case 'H':
2280 move(0, 0, 0);
2281 break;
2282 case 'I':
2283 if (curs.y == 0)
2284 scroll(0, rows - 1, -1, TRUE);
2285 else if (curs.y > 0)
2286 curs.y--;
2287 fix_cpos;
2288 wrapnext = FALSE;
2289 break;
2290 case 'J':
2291 erase_lots(FALSE, FALSE, TRUE);
2292 disptop = 0;
2293 break;
2294 case 'K':
2295 erase_lots(TRUE, FALSE, TRUE);
2296 break;
2297 #if 0
2298 case 'V':
2299 /* XXX Print cursor line */
2300 break;
2301 case 'W':
2302 /* XXX Start controller mode */
2303 break;
2304 case 'X':
2305 /* XXX Stop controller mode */
2306 break;
2307 #endif
2308 case 'Y':
2309 termstate = VT52_Y1;
2310 break;
2311 case 'Z':
2312 ldisc_send("\033/Z", 3);
2313 break;
2314 case '=':
2315 app_keypad_keys = TRUE;
2316 break;
2317 case '>':
2318 app_keypad_keys = FALSE;
2319 break;
2320 case '<':
2321 /* XXX This should switch to VT100 mode not current or default
2322 * VT mode. But this will only have effect in a VT220+
2323 * emulation.
2324 */
2325 vt52_mode = FALSE;
2326 blink_is_real = cfg.blinktext;
2327 break;
2328 #if 0
2329 case '^':
2330 /* XXX Enter auto print mode */
2331 break;
2332 case '_':
2333 /* XXX Exit auto print mode */
2334 break;
2335 case ']':
2336 /* XXX Print screen */
2337 break;
2338 #endif
2339
2340 #ifdef VT52_PLUS
2341 case 'E':
2342 /* compatibility(ATARI) */
2343 move(0, 0, 0);
2344 erase_lots(FALSE, FALSE, TRUE);
2345 disptop = 0;
2346 break;
2347 case 'L':
2348 /* compatibility(ATARI) */
2349 if (curs.y <= marg_b)
2350 scroll(curs.y, marg_b, -1, FALSE);
2351 break;
2352 case 'M':
2353 /* compatibility(ATARI) */
2354 if (curs.y <= marg_b)
2355 scroll(curs.y, marg_b, 1, TRUE);
2356 break;
2357 case 'b':
2358 /* compatibility(ATARI) */
2359 termstate = VT52_FG;
2360 break;
2361 case 'c':
2362 /* compatibility(ATARI) */
2363 termstate = VT52_BG;
2364 break;
2365 case 'd':
2366 /* compatibility(ATARI) */
2367 erase_lots(FALSE, TRUE, FALSE);
2368 disptop = 0;
2369 break;
2370 case 'e':
2371 /* compatibility(ATARI) */
2372 cursor_on = TRUE;
2373 break;
2374 case 'f':
2375 /* compatibility(ATARI) */
2376 cursor_on = FALSE;
2377 break;
2378 /* case 'j': Save cursor position - broken on ST */
2379 /* case 'k': Restore cursor position */
2380 case 'l':
2381 /* compatibility(ATARI) */
2382 erase_lots(TRUE, TRUE, TRUE);
2383 curs.x = 0;
2384 wrapnext = FALSE;
2385 fix_cpos;
2386 break;
2387 case 'o':
2388 /* compatibility(ATARI) */
2389 erase_lots(TRUE, TRUE, FALSE);
2390 break;
2391 case 'p':
2392 /* compatibility(ATARI) */
2393 curr_attr |= ATTR_REVERSE;
2394 break;
2395 case 'q':
2396 /* compatibility(ATARI) */
2397 curr_attr &= ~ATTR_REVERSE;
2398 break;
2399 case 'v': /* wrap Autowrap on - Wyse style */
2400 /* compatibility(ATARI) */
2401 wrap = 1;
2402 break;
2403 case 'w': /* Autowrap off */
2404 /* compatibility(ATARI) */
2405 wrap = 0;
2406 break;
2407
2408 case 'R':
2409 /* compatibility(OTHER) */
2410 vt52_bold = FALSE;
2411 curr_attr = ATTR_DEFAULT;
2412 if (use_bce)
2413 erase_char = (' ' | ATTR_ASCII |
2414 (curr_attr &
2415 (ATTR_FGMASK | ATTR_BGMASK)));
2416 break;
2417 case 'S':
2418 /* compatibility(VI50) */
2419 curr_attr |= ATTR_UNDER;
2420 break;
2421 case 'W':
2422 /* compatibility(VI50) */
2423 curr_attr &= ~ATTR_UNDER;
2424 break;
2425 case 'U':
2426 /* compatibility(VI50) */
2427 vt52_bold = TRUE;
2428 curr_attr |= ATTR_BOLD;
2429 break;
2430 case 'T':
2431 /* compatibility(VI50) */
2432 vt52_bold = FALSE;
2433 curr_attr &= ~ATTR_BOLD;
2434 break;
2435 #endif
2436 }
2437 break;
2438 case VT52_Y1:
2439 termstate = VT52_Y2;
2440 move(curs.x, c - ' ', 0);
2441 break;
2442 case VT52_Y2:
2443 termstate = TOPLEVEL;
2444 move(c - ' ', curs.y, 0);
2445 break;
2446
2447 #ifdef VT52_PLUS
2448 case VT52_FG:
2449 termstate = TOPLEVEL;
2450 curr_attr &= ~ATTR_FGMASK;
2451 curr_attr &= ~ATTR_BOLD;
2452 curr_attr |= (c & 0x7) << ATTR_FGSHIFT;
2453 if ((c & 0x8) || vt52_bold)
2454 curr_attr |= ATTR_BOLD;
2455
2456 if (use_bce)
2457 erase_char = (' ' | ATTR_ASCII |
2458 (curr_attr & (ATTR_FGMASK | ATTR_BGMASK)));
2459 break;
2460 case VT52_BG:
2461 termstate = TOPLEVEL;
2462 curr_attr &= ~ATTR_BGMASK;
2463 curr_attr &= ~ATTR_BLINK;
2464 curr_attr |= (c & 0x7) << ATTR_BGSHIFT;
2465
2466 /* Note: bold background */
2467 if (c & 0x8)
2468 curr_attr |= ATTR_BLINK;
2469
2470 if (use_bce)
2471 erase_char = (' ' | ATTR_ASCII |
2472 (curr_attr & (ATTR_FGMASK | ATTR_BGMASK)));
2473 break;
2474 #endif
2475 default: break; /* placate gcc warning about enum use */
2476 }
2477 if (selstate != NO_SELECTION) {
2478 pos cursplus = curs;
2479 incpos(cursplus);
2480 check_selection(curs, cursplus);
2481 }
2482 }
2483 inbuf_head = 0;
2484 }
2485
2486 #if 0
2487 /*
2488 * Compare two lines to determine whether they are sufficiently
2489 * alike to scroll-optimise one to the other. Return the degree of
2490 * similarity.
2491 */
2492 static int linecmp(unsigned long *a, unsigned long *b)
2493 {
2494 int i, n;
2495
2496 for (i = n = 0; i < cols; i++)
2497 n += (*a++ == *b++);
2498 return n;
2499 }
2500 #endif
2501
2502 /*
2503 * Given a context, update the window. Out of paranoia, we don't
2504 * allow WM_PAINT responses to do scrolling optimisations.
2505 */
2506 static void do_paint(Context ctx, int may_optimise)
2507 {
2508 int i, j, our_curs_y;
2509 unsigned long rv, cursor;
2510 pos scrpos;
2511 char ch[1024];
2512 long cursor_background = ERASE_CHAR;
2513 long ticks;
2514
2515 /*
2516 * Check the visual bell state.
2517 */
2518 if (in_vbell) {
2519 ticks = GetTickCount();
2520 if (ticks - vbell_timeout >= 0)
2521 in_vbell = FALSE;
2522 }
2523
2524 rv = (!rvideo ^ !in_vbell ? ATTR_REVERSE : 0);
2525
2526 /* Depends on:
2527 * screen array, disptop, scrtop,
2528 * selection, rv,
2529 * cfg.blinkpc, blink_is_real, tblinker,
2530 * curs.y, curs.x, blinker, cfg.blink_cur, cursor_on, has_focus, wrapnext
2531 */
2532
2533 /* Has the cursor position or type changed ? */
2534 if (cursor_on) {
2535 if (has_focus) {
2536 if (blinker || !cfg.blink_cur)
2537 cursor = TATTR_ACTCURS;
2538 else
2539 cursor = 0;
2540 } else
2541 cursor = TATTR_PASCURS;
2542 if (wrapnext)
2543 cursor |= TATTR_RIGHTCURS;
2544 } else
2545 cursor = 0;
2546 our_curs_y = curs.y - disptop;
2547
2548 if (dispcurs && (curstype != cursor ||
2549 dispcurs !=
2550 disptext + our_curs_y * (cols + 1) + curs.x)) {
2551 if (dispcurs > disptext &&
2552 (*dispcurs & (CHAR_MASK | CSET_MASK)) == UCSWIDE)
2553 dispcurs[-1] |= ATTR_INVALID;
2554 if ( (dispcurs[1] & (CHAR_MASK | CSET_MASK)) == UCSWIDE)
2555 dispcurs[1] |= ATTR_INVALID;
2556 *dispcurs |= ATTR_INVALID;
2557 curstype = 0;
2558 }
2559 dispcurs = NULL;
2560
2561 /* The normal screen data */
2562 for (i = 0; i < rows; i++) {
2563 unsigned long *ldata;
2564 int lattr;
2565 int idx, dirty_line, dirty_run;
2566 unsigned long attr = 0;
2567 int updated_line = 0;
2568 int start = 0;
2569 int ccount = 0;
2570 int last_run_dirty = 0;
2571
2572 scrpos.y = i + disptop;
2573 ldata = lineptr(scrpos.y);
2574 lattr = (ldata[cols] & LATTR_MODE);
2575
2576 idx = i * (cols + 1);
2577 dirty_run = dirty_line = (ldata[cols] != disptext[idx + cols]);
2578 disptext[idx + cols] = ldata[cols];
2579
2580 for (j = 0; j < cols; j++, idx++) {
2581 unsigned long tattr, tchar;
2582 unsigned long *d = ldata + j;
2583 int break_run;
2584 scrpos.x = j;
2585
2586 tchar = (*d & (CHAR_MASK | CSET_MASK));
2587 tattr = (*d & (ATTR_MASK ^ CSET_MASK));
2588 switch (tchar & CSET_MASK) {
2589 case ATTR_ASCII:
2590 tchar = unitab_line[tchar & 0xFF];
2591 break;
2592 case ATTR_LINEDRW:
2593 tchar = unitab_xterm[tchar & 0xFF];
2594 break;
2595 case ATTR_SCOACS:
2596 tchar = unitab_scoacs[tchar&0xFF];
2597 break;
2598 }
2599 tattr |= (tchar & CSET_MASK);
2600 tchar &= CHAR_MASK;
2601 if ((d[1] & (CHAR_MASK | CSET_MASK)) == UCSWIDE)
2602 tattr |= ATTR_WIDE;
2603
2604 /* Video reversing things */
2605 tattr = (tattr ^ rv
2606 ^ (posle(selstart, scrpos) &&
2607 poslt(scrpos, selend) ? ATTR_REVERSE : 0));
2608
2609 /* 'Real' blinking ? */
2610 if (blink_is_real && (tattr & ATTR_BLINK)) {
2611 if (has_focus && tblinker) {
2612 tchar = ' ';
2613 tattr &= ~CSET_MASK;
2614 tattr |= ATTR_ACP;
2615 }
2616 tattr &= ~ATTR_BLINK;
2617 }
2618
2619 /*
2620 * Check the font we'll _probably_ be using to see if
2621 * the character is wide when we don't want it to be.
2622 */
2623 if ((tchar | tattr) != (disptext[idx]& ~ATTR_NARROW)) {
2624 if ((tattr & ATTR_WIDE) == 0 &&
2625 CharWidth(ctx, (tchar | tattr) & 0xFFFF) == 2)
2626 tattr |= ATTR_NARROW;
2627 } else if (disptext[idx]&ATTR_NARROW)
2628 tattr |= ATTR_NARROW;
2629
2630 /* Cursor here ? Save the 'background' */
2631 if (i == our_curs_y && j == curs.x) {
2632 cursor_background = tattr | tchar;
2633 dispcurs = disptext + idx;
2634 }
2635
2636 if ((disptext[idx] ^ tattr) & ATTR_WIDE)
2637 dirty_line = TRUE;
2638
2639 break_run = (tattr != attr || j - start >= sizeof(ch));
2640
2641 /* Special hack for VT100 Linedraw glyphs */
2642 if ((attr & CSET_MASK) == 0x2300 && tchar >= 0xBA
2643 && tchar <= 0xBD) break_run = TRUE;
2644
2645 if (!dbcs_screenfont && !dirty_line) {
2646 if ((tchar | tattr) == disptext[idx])
2647 break_run = TRUE;
2648 else if (!dirty_run && ccount == 1)
2649 break_run = TRUE;
2650 }
2651
2652 if (break_run) {
2653 if ((dirty_run || last_run_dirty) && ccount > 0) {
2654 do_text(ctx, start, i, ch, ccount, attr, lattr);
2655 updated_line = 1;
2656 }
2657 start = j;
2658 ccount = 0;
2659 attr = tattr;
2660 if (dbcs_screenfont)
2661 last_run_dirty = dirty_run;
2662 dirty_run = dirty_line;
2663 }
2664
2665 if ((tchar | tattr) != disptext[idx])
2666 dirty_run = TRUE;
2667 ch[ccount++] = (char) tchar;
2668 disptext[idx] = tchar | tattr;
2669
2670 /* If it's a wide char step along to the next one. */
2671 if (tattr & ATTR_WIDE) {
2672 if (++j < cols) {
2673 idx++;
2674 d++;
2675 /* Cursor is here ? Ouch! */
2676 if (i == our_curs_y && j == curs.x) {
2677 cursor_background = *d;
2678 dispcurs = disptext + idx;
2679 }
2680 if (disptext[idx] != *d)
2681 dirty_run = TRUE;
2682 disptext[idx] = *d;
2683 }
2684 }
2685 }
2686 if (dirty_run && ccount > 0) {
2687 do_text(ctx, start, i, ch, ccount, attr, lattr);
2688 updated_line = 1;
2689 }
2690
2691 /* Cursor on this line ? (and changed) */
2692 if (i == our_curs_y && (curstype != cursor || updated_line)) {
2693 ch[0] = (char) (cursor_background & CHAR_MASK);
2694 attr = (cursor_background & ATTR_MASK) | cursor;
2695 do_cursor(ctx, curs.x, i, ch, 1, attr, lattr);
2696 curstype = cursor;
2697 }
2698 }
2699 }
2700
2701 /*
2702 * Flick the switch that says if blinking things should be shown or hidden.
2703 */
2704
2705 void term_blink(int flg)
2706 {
2707 static long last_blink = 0;
2708 static long last_tblink = 0;
2709 long now, blink_diff;
2710
2711 now = GetTickCount();
2712 blink_diff = now - last_tblink;
2713
2714 /* Make sure the text blinks no more than 2Hz */
2715 if (blink_diff < 0 || blink_diff > 450) {
2716 last_tblink = now;
2717 tblinker = !tblinker;
2718 }
2719
2720 if (flg) {
2721 blinker = 1;
2722 last_blink = now;
2723 return;
2724 }
2725
2726 blink_diff = now - last_blink;
2727
2728 /* Make sure the cursor blinks no faster than GetCaretBlinkTime() */
2729 if (blink_diff >= 0 && blink_diff < (long) GetCaretBlinkTime())
2730 return;
2731
2732 last_blink = now;
2733 blinker = !blinker;
2734 }
2735
2736 /*
2737 * Invalidate the whole screen so it will be repainted in full.
2738 */
2739 void term_invalidate(void)
2740 {
2741 int i;
2742
2743 for (i = 0; i < rows * (cols + 1); i++)
2744 disptext[i] = ATTR_INVALID;
2745 }
2746
2747 /*
2748 * Paint the window in response to a WM_PAINT message.
2749 */
2750 void term_paint(Context ctx, int left, int top, int right, int bottom)
2751 {
2752 int i, j;
2753 if (left < 0) left = 0;
2754 if (top < 0) top = 0;
2755 if (right >= cols) right = cols-1;
2756 if (bottom >= rows) bottom = rows-1;
2757
2758 for (i = top; i <= bottom && i < rows; i++) {
2759 if ((disptext[i * (cols + 1) + cols] & LATTR_MODE) == LATTR_NORM)
2760 for (j = left; j <= right && j < cols; j++)
2761 disptext[i * (cols + 1) + j] = ATTR_INVALID;
2762 else
2763 for (j = left / 2; j <= right / 2 + 1 && j < cols; j++)
2764 disptext[i * (cols + 1) + j] = ATTR_INVALID;
2765 }
2766
2767 /* This should happen soon enough, also for some reason it sometimes
2768 * fails to actually do anything when re-sizing ... painting the wrong
2769 * window perhaps ?
2770 */
2771 if (alt_pressed)
2772 do_paint (ctx, FALSE);
2773 }
2774
2775 /*
2776 * Attempt to scroll the scrollback. The second parameter gives the
2777 * position we want to scroll to; the first is +1 to denote that
2778 * this position is relative to the beginning of the scrollback, -1
2779 * to denote it is relative to the end, and 0 to denote that it is
2780 * relative to the current position.
2781 */
2782 void term_scroll(int rel, int where)
2783 {
2784 int sbtop = -count234(scrollback);
2785
2786 disptop = (rel < 0 ? 0 : rel > 0 ? sbtop : disptop) + where;
2787 if (disptop < sbtop)
2788 disptop = sbtop;
2789 if (disptop > 0)
2790 disptop = 0;
2791 update_sbar();
2792 term_update();
2793 }
2794
2795 static void clipme(pos top, pos bottom)
2796 {
2797 wchar_t *workbuf;
2798 wchar_t *wbptr; /* where next char goes within workbuf */
2799 int wblen = 0; /* workbuf len */
2800 int buflen; /* amount of memory allocated to workbuf */
2801
2802 buflen = 5120; /* Default size */
2803 workbuf = smalloc(buflen * sizeof(wchar_t));
2804 wbptr = workbuf; /* start filling here */
2805
2806 while (poslt(top, bottom)) {
2807 int nl = FALSE;
2808 unsigned long *ldata = lineptr(top.y);
2809 pos nlpos;
2810
2811 nlpos.y = top.y;
2812 nlpos.x = cols;
2813
2814 if (!(ldata[cols] & LATTR_WRAPPED)) {
2815 while (((ldata[nlpos.x - 1] & 0xFF) == 0x20 ||
2816 (DIRECT_CHAR(ldata[nlpos.x - 1]) &&
2817 (ldata[nlpos.x - 1] & CHAR_MASK) == 0x20))
2818 && poslt(top, nlpos))
2819 decpos(nlpos);
2820 if (poslt(nlpos, bottom))
2821 nl = TRUE;
2822 }
2823 while (poslt(top, bottom) && poslt(top, nlpos)) {
2824 #if 0
2825 char cbuf[16], *p;
2826 sprintf(cbuf, "<U+%04x>", (ldata[top.x] & 0xFFFF));
2827 #else
2828 wchar_t cbuf[16], *p;
2829 int uc = (ldata[top.x] & 0xFFFF);
2830 int set, c;
2831
2832 if (uc == UCSWIDE) {
2833 top.x++;
2834 continue;
2835 }
2836
2837 switch (uc & CSET_MASK) {
2838 case ATTR_LINEDRW:
2839 if (!cfg.rawcnp) {
2840 uc = unitab_xterm[uc & 0xFF];
2841 break;
2842 }
2843 case ATTR_ASCII:
2844 uc = unitab_line[uc & 0xFF];
2845 break;
2846 case ATTR_SCOACS:
2847 uc = unitab_scoacs[uc&0xFF];
2848 break;
2849 }
2850 switch (uc & CSET_MASK) {
2851 case ATTR_ACP:
2852 uc = unitab_font[uc & 0xFF];
2853 break;
2854 case ATTR_OEMCP:
2855 uc = unitab_oemcp[uc & 0xFF];
2856 break;
2857 }
2858
2859 set = (uc & CSET_MASK);
2860 c = (uc & CHAR_MASK);
2861 cbuf[0] = uc;
2862 cbuf[1] = 0;
2863
2864 if (DIRECT_FONT(uc)) {
2865 if (c >= ' ' && c != 0x7F) {
2866 unsigned char buf[4];
2867 WCHAR wbuf[4];
2868 int rv;
2869 if (IsDBCSLeadByteEx(font_codepage, (BYTE) c)) {
2870 buf[0] = c;
2871 buf[1] = (unsigned char) ldata[top.x + 1];
2872 rv = MultiByteToWideChar(font_codepage,
2873 0, buf, 2, wbuf, 4);
2874 top.x++;
2875 } else {
2876 buf[0] = c;
2877 rv = MultiByteToWideChar(font_codepage,
2878 0, buf, 1, wbuf, 4);
2879 }
2880
2881 if (rv > 0) {
2882 memcpy(cbuf, wbuf, rv * sizeof(wchar_t));
2883 cbuf[rv] = 0;
2884 }
2885 }
2886 }
2887 #endif
2888
2889 for (p = cbuf; *p; p++) {
2890 /* Enough overhead for trailing NL and nul */
2891 if (wblen >= buflen - 16) {
2892 workbuf =
2893 srealloc(workbuf,
2894 sizeof(wchar_t) * (buflen += 100));
2895 wbptr = workbuf + wblen;
2896 }
2897 wblen++;
2898 *wbptr++ = *p;
2899 }
2900 top.x++;
2901 }
2902 if (nl) {
2903 int i;
2904 for (i = 0; i < sel_nl_sz; i++) {
2905 wblen++;
2906 *wbptr++ = sel_nl[i];
2907 }
2908 }
2909 top.y++;
2910 top.x = 0;
2911 }
2912 wblen++;
2913 *wbptr++ = 0;
2914 write_clip(workbuf, wblen, FALSE); /* transfer to clipboard */
2915 if (buflen > 0) /* indicates we allocated this buffer */
2916 sfree(workbuf);
2917 }
2918
2919 void term_copyall(void)
2920 {
2921 pos top;
2922 top.y = -count234(scrollback);
2923 top.x = 0;
2924 clipme(top, curs);
2925 }
2926
2927 /*
2928 * The wordness array is mainly for deciding the disposition of the US-ASCII
2929 * characters.
2930 */
2931 static int wordtype(int uc)
2932 {
2933 static struct {
2934 int start, end, ctype;
2935 } *wptr, ucs_words[] = {
2936 {
2937 128, 160, 0}, {
2938 161, 191, 1}, {
2939 215, 215, 1}, {
2940 247, 247, 1}, {
2941 0x037e, 0x037e, 1}, /* Greek question mark */
2942 {
2943 0x0387, 0x0387, 1}, /* Greek ano teleia */
2944 {
2945 0x055a, 0x055f, 1}, /* Armenian punctuation */
2946 {
2947 0x0589, 0x0589, 1}, /* Armenian full stop */
2948 {
2949 0x0700, 0x070d, 1}, /* Syriac punctuation */
2950 {
2951 0x104a, 0x104f, 1}, /* Myanmar punctuation */
2952 {
2953 0x10fb, 0x10fb, 1}, /* Georgian punctuation */
2954 {
2955 0x1361, 0x1368, 1}, /* Ethiopic punctuation */
2956 {
2957 0x166d, 0x166e, 1}, /* Canadian Syl. punctuation */
2958 {
2959 0x17d4, 0x17dc, 1}, /* Khmer punctuation */
2960 {
2961 0x1800, 0x180a, 1}, /* Mongolian punctuation */
2962 {
2963 0x2000, 0x200a, 0}, /* Various spaces */
2964 {
2965 0x2070, 0x207f, 2}, /* superscript */
2966 {
2967 0x2080, 0x208f, 2}, /* subscript */
2968 {
2969 0x200b, 0x27ff, 1}, /* punctuation and symbols */
2970 {
2971 0x3000, 0x3000, 0}, /* ideographic space */
2972 {
2973 0x3001, 0x3020, 1}, /* ideographic punctuation */
2974 {
2975 0x303f, 0x309f, 3}, /* Hiragana */
2976 {
2977 0x30a0, 0x30ff, 3}, /* Katakana */
2978 {
2979 0x3300, 0x9fff, 3}, /* CJK Ideographs */
2980 {
2981 0xac00, 0xd7a3, 3}, /* Hangul Syllables */
2982 {
2983 0xf900, 0xfaff, 3}, /* CJK Ideographs */
2984 {
2985 0xfe30, 0xfe6b, 1}, /* punctuation forms */
2986 {
2987 0xff00, 0xff0f, 1}, /* half/fullwidth ASCII */
2988 {
2989 0xff1a, 0xff20, 1}, /* half/fullwidth ASCII */
2990 {
2991 0xff3b, 0xff40, 1}, /* half/fullwidth ASCII */
2992 {
2993 0xff5b, 0xff64, 1}, /* half/fullwidth ASCII */
2994 {
2995 0xfff0, 0xffff, 0}, /* half/fullwidth ASCII */
2996 {
2997 0, 0, 0}
2998 };
2999
3000 uc &= (CSET_MASK | CHAR_MASK);
3001
3002 switch (uc & CSET_MASK) {
3003 case ATTR_LINEDRW:
3004 uc = unitab_xterm[uc & 0xFF];
3005 break;
3006 case ATTR_ASCII:
3007 uc = unitab_line[uc & 0xFF];
3008 break;
3009 case ATTR_SCOACS:
3010 uc = unitab_scoacs[uc&0xFF];
3011 break;
3012 }
3013 switch (uc & CSET_MASK) {
3014 case ATTR_ACP:
3015 uc = unitab_font[uc & 0xFF];
3016 break;
3017 case ATTR_OEMCP:
3018 uc = unitab_oemcp[uc & 0xFF];
3019 break;
3020 }
3021
3022 /* For DBCS font's I can't do anything usefull. Even this will sometimes
3023 * fail as there's such a thing as a double width space. :-(
3024 */
3025 if (dbcs_screenfont && font_codepage == line_codepage)
3026 return (uc != ' ');
3027
3028 if (uc < 0x80)
3029 return wordness[uc];
3030
3031 for (wptr = ucs_words; wptr->start; wptr++) {
3032 if (uc >= wptr->start && uc <= wptr->end)
3033 return wptr->ctype;
3034 }
3035
3036 return 2;
3037 }
3038
3039 /*
3040 * Spread the selection outwards according to the selection mode.
3041 */
3042 static pos sel_spread_half(pos p, int dir)
3043 {
3044 unsigned long *ldata;
3045 short wvalue;
3046
3047 ldata = lineptr(p.y);
3048
3049 switch (selmode) {
3050 case SM_CHAR:
3051 /*
3052 * In this mode, every character is a separate unit, except
3053 * for runs of spaces at the end of a non-wrapping line.
3054 */
3055 if (!(ldata[cols] & LATTR_WRAPPED)) {
3056 unsigned long *q = ldata + cols;
3057 while (q > ldata && (q[-1] & CHAR_MASK) == 0x20)
3058 q--;
3059 if (q == ldata + cols)
3060 q--;
3061 if (p.x >= q - ldata)
3062 p.x = (dir == -1 ? q - ldata : cols - 1);
3063 }
3064 break;
3065 case SM_WORD:
3066 /*
3067 * In this mode, the units are maximal runs of characters
3068 * whose `wordness' has the same value.
3069 */
3070 wvalue = wordtype(ldata[p.x]);
3071 if (dir == +1) {
3072 while (p.x < cols && wordtype(ldata[p.x + 1]) == wvalue)
3073 p.x++;
3074 } else {
3075 while (p.x > 0 && wordtype(ldata[p.x - 1]) == wvalue)
3076 p.x--;
3077 }
3078 break;
3079 case SM_LINE:
3080 /*
3081 * In this mode, every line is a unit.
3082 */
3083 p.x = (dir == -1 ? 0 : cols - 1);
3084 break;
3085 }
3086 return p;
3087 }
3088
3089 static void sel_spread(void)
3090 {
3091 selstart = sel_spread_half(selstart, -1);
3092 decpos(selend);
3093 selend = sel_spread_half(selend, +1);
3094 incpos(selend);
3095 }
3096
3097 void term_do_paste(void)
3098 {
3099 wchar_t *data;
3100 int len;
3101
3102 get_clip(&data, &len);
3103 if (data) {
3104 wchar_t *p, *q;
3105
3106 if (paste_buffer)
3107 sfree(paste_buffer);
3108 paste_pos = paste_hold = paste_len = 0;
3109 paste_buffer = smalloc(len * sizeof(wchar_t));
3110
3111 p = q = data;
3112 while (p < data + len) {
3113 while (p < data + len &&
3114 !(p <= data + len - sel_nl_sz &&
3115 !memcmp(p, sel_nl, sizeof(sel_nl))))
3116 p++;
3117
3118 {
3119 int i;
3120 for (i = 0; i < p - q; i++) {
3121 paste_buffer[paste_len++] = q[i];
3122 }
3123 }
3124
3125 if (p <= data + len - sel_nl_sz &&
3126 !memcmp(p, sel_nl, sizeof(sel_nl))) {
3127 paste_buffer[paste_len++] = '\r';
3128 p += sel_nl_sz;
3129 }
3130 q = p;
3131 }
3132
3133 /* Assume a small paste will be OK in one go. */
3134 if (paste_len < 256) {
3135 luni_send(paste_buffer, paste_len);
3136 if (paste_buffer)
3137 sfree(paste_buffer);
3138 paste_buffer = 0;
3139 paste_pos = paste_hold = paste_len = 0;
3140 }
3141 }
3142 get_clip(NULL, NULL);
3143 }
3144
3145 void term_mouse(Mouse_Button b, Mouse_Action a, int x, int y,
3146 int shift, int ctrl)
3147 {
3148 pos selpoint;
3149 unsigned long *ldata;
3150 int raw_mouse = xterm_mouse && !(cfg.mouse_override && shift);
3151
3152 if (y < 0) {
3153 y = 0;
3154 if (a == MA_DRAG && !raw_mouse)
3155 term_scroll(0, -1);
3156 }
3157 if (y >= rows) {
3158 y = rows - 1;
3159 if (a == MA_DRAG && !raw_mouse)
3160 term_scroll(0, +1);
3161 }
3162 if (x < 0) {
3163 if (y > 0) {
3164 x = cols - 1;
3165 y--;
3166 } else
3167 x = 0;
3168 }
3169 if (x >= cols)
3170 x = cols - 1;
3171
3172 selpoint.y = y + disptop;
3173 selpoint.x = x;
3174 ldata = lineptr(selpoint.y);
3175 if ((ldata[cols] & LATTR_MODE) != LATTR_NORM)
3176 selpoint.x /= 2;
3177
3178 if (raw_mouse) {
3179 int encstate = 0, r, c;
3180 char abuf[16];
3181 static int is_down = 0;
3182
3183 switch (b) {
3184 case MBT_LEFT:
3185 encstate = 0x20; /* left button down */
3186 break;
3187 case MBT_MIDDLE:
3188 encstate = 0x21;
3189 break;
3190 case MBT_RIGHT:
3191 encstate = 0x22;
3192 break;
3193 case MBT_WHEEL_UP:
3194 encstate = 0x60;
3195 break;
3196 case MBT_WHEEL_DOWN:
3197 encstate = 0x61;
3198 break;
3199 default: break; /* placate gcc warning about enum use */
3200 }
3201 switch (a) {
3202 case MA_DRAG:
3203 if (xterm_mouse == 1)
3204 return;
3205 encstate += 0x20;
3206 break;
3207 case MA_RELEASE:
3208 encstate = 0x23;
3209 is_down = 0;
3210 break;
3211 case MA_CLICK:
3212 if (is_down == b)
3213 return;
3214 is_down = b;
3215 break;
3216 default: break; /* placate gcc warning about enum use */
3217 }
3218 if (shift)
3219 encstate += 0x04;
3220 if (ctrl)
3221 encstate += 0x10;
3222 r = y + 33;
3223 c = x + 33;
3224
3225 sprintf(abuf, "\033[M%c%c%c", encstate, c, r);
3226 ldisc_send(abuf, 6);
3227 return;
3228 }
3229
3230 b = translate_button(b);
3231
3232 if (b == MBT_SELECT && a == MA_CLICK) {
3233 deselect();
3234 selstate = ABOUT_TO;
3235 selanchor = selpoint;
3236 selmode = SM_CHAR;
3237 } else if (b == MBT_SELECT && (a == MA_2CLK || a == MA_3CLK)) {
3238 deselect();
3239 selmode = (a == MA_2CLK ? SM_WORD : SM_LINE);
3240 selstate = DRAGGING;
3241 selstart = selanchor = selpoint;
3242 selend = selstart;
3243 incpos(selend);
3244 sel_spread();
3245 } else if ((b == MBT_SELECT && a == MA_DRAG) ||
3246 (b == MBT_EXTEND && a != MA_RELEASE)) {
3247 if (selstate == ABOUT_TO && poseq(selanchor, selpoint))
3248 return;
3249 if (b == MBT_EXTEND && a != MA_DRAG && selstate == SELECTED) {
3250 if (posdiff(selpoint, selstart) <
3251 posdiff(selend, selstart) / 2) {
3252 selanchor = selend;
3253 decpos(selanchor);
3254 } else {
3255 selanchor = selstart;
3256 }
3257 selstate = DRAGGING;
3258 }
3259 if (selstate != ABOUT_TO && selstate != DRAGGING)
3260 selanchor = selpoint;
3261 selstate = DRAGGING;
3262 if (poslt(selpoint, selanchor)) {
3263 selstart = selpoint;
3264 selend = selanchor;
3265 incpos(selend);
3266 } else {
3267 selstart = selanchor;
3268 selend = selpoint;
3269 incpos(selend);
3270 }
3271 sel_spread();
3272 } else if ((b == MBT_SELECT || b == MBT_EXTEND) && a == MA_RELEASE) {
3273 if (selstate == DRAGGING) {
3274 /*
3275 * We've completed a selection. We now transfer the
3276 * data to the clipboard.
3277 */
3278 clipme(selstart, selend);
3279 selstate = SELECTED;
3280 } else
3281 selstate = NO_SELECTION;
3282 } else if (b == MBT_PASTE
3283 && (a == MA_CLICK || a == MA_2CLK || a == MA_3CLK)) {
3284 term_do_paste();
3285 }
3286
3287 term_update();
3288 }
3289
3290 void term_nopaste()
3291 {
3292 if (paste_len == 0)
3293 return;
3294 sfree(paste_buffer);
3295 paste_buffer = 0;
3296 paste_len = 0;
3297 }
3298
3299 void term_paste()
3300 {
3301 static long last_paste = 0;
3302 long now, paste_diff;
3303
3304 if (paste_len == 0)
3305 return;
3306
3307 /* Don't wait forever to paste */
3308 if (paste_hold) {
3309 now = GetTickCount();
3310 paste_diff = now - last_paste;
3311 if (paste_diff >= 0 && paste_diff < 450)
3312 return;
3313 }
3314 paste_hold = 0;
3315
3316 while (paste_pos < paste_len) {
3317 int n = 0;
3318 while (n + paste_pos < paste_len) {
3319 if (paste_buffer[paste_pos + n++] == '\r')
3320 break;
3321 }
3322 luni_send(paste_buffer + paste_pos, n);
3323 paste_pos += n;
3324
3325 if (paste_pos < paste_len) {
3326 paste_hold = 1;
3327 return;
3328 }
3329 }
3330 sfree(paste_buffer);
3331 paste_buffer = 0;
3332 paste_len = 0;
3333 }
3334
3335 static void deselect(void)
3336 {
3337 selstate = NO_SELECTION;
3338 selstart.x = selstart.y = selend.x = selend.y = 0;
3339 }
3340
3341 void term_deselect(void)
3342 {
3343 deselect();
3344 term_update();
3345 }
3346
3347 int term_ldisc(int option)
3348 {
3349 if (option == LD_ECHO)
3350 return term_echoing;
3351 if (option == LD_EDIT)
3352 return term_editing;
3353 return FALSE;
3354 }
3355
3356 /*
3357 * from_backend(), to get data from the backend for the terminal.
3358 */
3359 int from_backend(int is_stderr, char *data, int len)
3360 {
3361 while (len--) {
3362 if (inbuf_head >= INBUF_SIZE)
3363 term_out();
3364 inbuf[inbuf_head++] = *data++;
3365 }
3366
3367 /*
3368 * We process all stdout/stderr data immediately we receive it,
3369 * and don't return until it's all gone. Therefore, there's no
3370 * reason at all to return anything other than zero from this
3371 * function.
3372 *
3373 * This is a slightly suboptimal way to deal with SSH2 - in
3374 * principle, the window mechanism would allow us to continue
3375 * to accept data on forwarded ports and X connections even
3376 * while the terminal processing was going slowly - but we
3377 * can't do the 100% right thing without moving the terminal
3378 * processing into a separate thread, and that might hurt
3379 * portability. So we manage stdout buffering the old SSH1 way:
3380 * if the terminal processing goes slowly, the whole SSH
3381 * connection stops accepting data until it's ready.
3382 *
3383 * In practice, I can't imagine this causing serious trouble.
3384 */
3385 return 0;
3386 }
3387
3388 /*
3389 * Log session traffic.
3390 */
3391 void logtraffic(unsigned char c, int logmode)
3392 {
3393 if (cfg.logtype > 0) {
3394 if (cfg.logtype == logmode) {
3395 /* deferred open file from pgm start? */
3396 if (!lgfp)
3397 logfopen();
3398 if (lgfp)
3399 fputc(c, lgfp);
3400 }
3401 }
3402 }
3403
3404 void settimstr(char *ta, int no_sec);
3405 char *subslfcode(char *dest, char *src, char *dstrt);
3406 char *stpncpy(char *dst, const char *src, size_t maxlen);
3407 char timdatbuf[20];
3408 char currlogfilename[FILENAME_MAX];
3409
3410 /* open log file append/overwrite mode */
3411 void logfopen(void)
3412 {
3413 char buf[256];
3414 time_t t;
3415 struct tm tm;
3416 char writemod[4];
3417
3418 if (!cfg.logtype)
3419 return;
3420 sprintf(writemod, "wb"); /* default to rewrite */
3421
3422 time(&t);
3423 tm = *localtime(&t);
3424
3425 /* substitute special codes in file name */
3426 xlatlognam(currlogfilename,cfg.logfilename,cfg.host, &tm);
3427
3428 lgfp = fopen(currlogfilename, "r"); /* file already present? */
3429 if (lgfp) {
3430 int i;
3431 fclose(lgfp);
3432 i = askappend(currlogfilename);
3433 if (i == 1)
3434 writemod[0] = 'a'; /* set append mode */
3435 else if (i == 0) { /* cancelled */
3436 lgfp = NULL;
3437 cfg.logtype = 0; /* disable logging */
3438 return;
3439 }
3440 }
3441
3442 lgfp = fopen(currlogfilename, writemod);
3443 if (lgfp) { /* enter into event log */
3444 sprintf(buf, "%s session log (%s mode) to file : ",
3445 (writemod[0] == 'a') ? "Appending" : "Writing new",
3446 (cfg.logtype == LGTYP_ASCII ? "ASCII" :
3447 cfg.logtype == LGTYP_DEBUG ? "raw" : "<ukwn>"));
3448 /* Make sure we do not exceed the output buffer size */
3449 strncat(buf, currlogfilename, 128);
3450 buf[strlen(buf)] = '\0';
3451 logevent(buf);
3452
3453 /* --- write header line into log file */
3454 fputs("=~=~=~=~=~=~=~=~=~=~=~= PuTTY log ", lgfp);
3455 strftime(buf, 24, "%Y.%m.%d %H:%M:%S", &tm);
3456 fputs(buf, lgfp);
3457 fputs(" =~=~=~=~=~=~=~=~=~=~=~=\r\n", lgfp);
3458 }
3459 }
3460
3461 void logfclose(void)
3462 {
3463 if (lgfp) {
3464 fclose(lgfp);
3465 lgfp = NULL;
3466 }
3467 }
3468
3469 /*
3470 * translate format codes into time/date strings
3471 * and insert them into log file name
3472 *
3473 * "&Y":YYYY "&m":MM "&d":DD "&T":hhmm "&h":<hostname> "&&":&
3474 */
3475 static void xlatlognam(char *d, char *s, char *hostname, struct tm *tm) {
3476 char buf[10], *bufp;
3477 int size;
3478 char *ds = d; /* save start pos. */
3479 int len = FILENAME_MAX-1;
3480
3481 while (*s) {
3482 /* Let (bufp, len) be the string to append. */
3483 bufp = buf; /* don't usually override this */
3484 if (*s == '&') {
3485 char c;
3486 s++;
3487 if (*s) switch (c = *s++, tolower(c)) {
3488 case 'y':
3489 size = strftime(buf, sizeof(buf), "%Y", tm);
3490 break;
3491 case 'm':
3492 size = strftime(buf, sizeof(buf), "%m", tm);
3493 break;
3494 case 'd':
3495 size = strftime(buf, sizeof(buf), "%d", tm);
3496 break;
3497 case 't':
3498 size = strftime(buf, sizeof(buf), "%H%M%S", tm);
3499 break;
3500 case 'h':
3501 bufp = hostname;
3502 size = strlen(bufp);
3503 break;
3504 default:
3505 buf[0] = '&';
3506 size = 1;
3507 if (c != '&')
3508 buf[size++] = c;
3509 }
3510 } else {
3511 buf[0] = *s++;
3512 size = 1;
3513 }
3514 if (size > len)
3515 size = len;
3516 memcpy(d, bufp, size);
3517 d += size;
3518 len -= size;
3519 }
3520 *d = '\0';
3521 }
Simon Tatham's PuTTY GUI SSH client; import of svn://svn.tartarus.org/sgt/putty