projects / u / mdw / putty / blob
? search:


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