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