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