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