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