OSDN Git Service

Add support for MLSD responses from some broken hosts.
[ffftp/ffftp.git] / putty / TERMINAL.C
1 /*\r
2  * Terminal emulator.\r
3  */\r
4 \r
5 #include <stdio.h>\r
6 #include <stdlib.h>\r
7 #include <ctype.h>\r
8 \r
9 #include <time.h>\r
10 #include <assert.h>\r
11 #include "putty.h"\r
12 #include "terminal.h"\r
13 \r
14 #define poslt(p1,p2) ( (p1).y < (p2).y || ( (p1).y == (p2).y && (p1).x < (p2).x ) )\r
15 #define posle(p1,p2) ( (p1).y < (p2).y || ( (p1).y == (p2).y && (p1).x <= (p2).x ) )\r
16 #define poseq(p1,p2) ( (p1).y == (p2).y && (p1).x == (p2).x )\r
17 #define posdiff(p1,p2) ( ((p1).y - (p2).y) * (term->cols+1) + (p1).x - (p2).x )\r
18 \r
19 /* Product-order comparisons for rectangular block selection. */\r
20 #define posPlt(p1,p2) ( (p1).y <= (p2).y && (p1).x < (p2).x )\r
21 #define posPle(p1,p2) ( (p1).y <= (p2).y && (p1).x <= (p2).x )\r
22 \r
23 #define incpos(p) ( (p).x == term->cols ? ((p).x = 0, (p).y++, 1) : ((p).x++, 0) )\r
24 #define decpos(p) ( (p).x == 0 ? ((p).x = term->cols, (p).y--, 1) : ((p).x--, 0) )\r
25 \r
26 #define VT52_PLUS\r
27 \r
28 #define CL_ANSIMIN      0x0001         /* Codes in all ANSI like terminals. */\r
29 #define CL_VT100        0x0002         /* VT100 */\r
30 #define CL_VT100AVO     0x0004         /* VT100 +AVO; 132x24 (not 132x14) & attrs */\r
31 #define CL_VT102        0x0008         /* VT102 */\r
32 #define CL_VT220        0x0010         /* VT220 */\r
33 #define CL_VT320        0x0020         /* VT320 */\r
34 #define CL_VT420        0x0040         /* VT420 */\r
35 #define CL_VT510        0x0080         /* VT510, NB VT510 includes ANSI */\r
36 #define CL_VT340TEXT    0x0100         /* VT340 extensions that appear in the VT420 */\r
37 #define CL_SCOANSI      0x1000         /* SCOANSI not in ANSIMIN. */\r
38 #define CL_ANSI         0x2000         /* ANSI ECMA-48 not in the VT100..VT420 */\r
39 #define CL_OTHER        0x4000         /* Others, Xterm, linux, putty, dunno, etc */\r
40 \r
41 #define TM_VT100        (CL_ANSIMIN|CL_VT100)\r
42 #define TM_VT100AVO     (TM_VT100|CL_VT100AVO)\r
43 #define TM_VT102        (TM_VT100AVO|CL_VT102)\r
44 #define TM_VT220        (TM_VT102|CL_VT220)\r
45 #define TM_VTXXX        (TM_VT220|CL_VT340TEXT|CL_VT510|CL_VT420|CL_VT320)\r
46 #define TM_SCOANSI      (CL_ANSIMIN|CL_SCOANSI)\r
47 \r
48 #define TM_PUTTY        (0xFFFF)\r
49 \r
50 #define UPDATE_DELAY    ((TICKSPERSEC+49)/50)/* ticks to defer window update */\r
51 #define TBLINK_DELAY    ((TICKSPERSEC*9+19)/20)/* ticks between text blinks*/\r
52 #define CBLINK_DELAY    (CURSORBLINK) /* ticks between cursor blinks */\r
53 #define VBELL_DELAY     (VBELL_TIMEOUT) /* visual bell timeout in ticks */\r
54 \r
55 #define compatibility(x) \\r
56     if ( ((CL_##x)&term->compatibility_level) == 0 ) {  \\r
57        term->termstate=TOPLEVEL;                        \\r
58        break;                                           \\r
59     }\r
60 #define compatibility2(x,y) \\r
61     if ( ((CL_##x|CL_##y)&term->compatibility_level) == 0 ) { \\r
62        term->termstate=TOPLEVEL;                        \\r
63        break;                                           \\r
64     }\r
65 \r
66 #define has_compat(x) ( ((CL_##x)&term->compatibility_level) != 0 )\r
67 \r
68 char *EMPTY_WINDOW_TITLE = "";\r
69 \r
70 const char sco2ansicolour[] = { 0, 4, 2, 6, 1, 5, 3, 7 };\r
71 \r
72 #define sel_nl_sz  (sizeof(sel_nl)/sizeof(wchar_t))\r
73 const wchar_t sel_nl[] = SEL_NL;\r
74 \r
75 /*\r
76  * Fetch the character at a particular position in a line array,\r
77  * for purposes of `wordtype'. The reason this isn't just a simple\r
78  * array reference is that if the character we find is UCSWIDE,\r
79  * then we must look one space further to the left.\r
80  */\r
81 #define UCSGET(a, x) \\r
82     ( (x)>0 && (a)[(x)].chr == UCSWIDE ? (a)[(x)-1].chr : (a)[(x)].chr )\r
83 \r
84 /*\r
85  * Detect the various aliases of U+0020 SPACE.\r
86  */\r
87 #define IS_SPACE_CHR(chr) \\r
88         ((chr) == 0x20 || (DIRECT_CHAR(chr) && ((chr) & 0xFF) == 0x20))\r
89 \r
90 /*\r
91  * Spot magic CSETs.\r
92  */\r
93 #define CSET_OF(chr) (DIRECT_CHAR(chr)||DIRECT_FONT(chr) ? (chr)&CSET_MASK : 0)\r
94 \r
95 /*\r
96  * Internal prototypes.\r
97  */\r
98 static void resizeline(Terminal *, termline *, int);\r
99 static termline *lineptr(Terminal *, int, int, int);\r
100 static void unlineptr(termline *);\r
101 static void do_paint(Terminal *, Context, int);\r
102 static void erase_lots(Terminal *, int, int, int);\r
103 static int find_last_nonempty_line(Terminal *, tree234 *);\r
104 static void swap_screen(Terminal *, int, int, int);\r
105 static void update_sbar(Terminal *);\r
106 static void deselect(Terminal *);\r
107 static void term_print_finish(Terminal *);\r
108 static void scroll(Terminal *, int, int, int, int);\r
109 #ifdef OPTIMISE_SCROLL\r
110 static void scroll_display(Terminal *, int, int, int);\r
111 #endif /* OPTIMISE_SCROLL */\r
112 \r
113 static termline *newline(Terminal *term, int cols, int bce)\r
114 {\r
115     termline *line;\r
116     int j;\r
117 \r
118     line = snew(termline);\r
119     line->chars = snewn(cols, termchar);\r
120     for (j = 0; j < cols; j++)\r
121         line->chars[j] = (bce ? term->erase_char : term->basic_erase_char);\r
122     line->cols = line->size = cols;\r
123     line->lattr = LATTR_NORM;\r
124     line->temporary = FALSE;\r
125     line->cc_free = 0;\r
126 \r
127     return line;\r
128 }\r
129 \r
130 static void freeline(termline *line)\r
131 {\r
132     if (line) {\r
133         sfree(line->chars);\r
134         sfree(line);\r
135     }\r
136 }\r
137 \r
138 static void unlineptr(termline *line)\r
139 {\r
140     if (line->temporary)\r
141         freeline(line);\r
142 }\r
143 \r
144 #ifdef TERM_CC_DIAGS\r
145 /*\r
146  * Diagnostic function: verify that a termline has a correct\r
147  * combining character structure.\r
148  * \r
149  * This is a performance-intensive check, so it's no longer enabled\r
150  * by default.\r
151  */\r
152 static void cc_check(termline *line)\r
153 {\r
154     unsigned char *flags;\r
155     int i, j;\r
156 \r
157     assert(line->size >= line->cols);\r
158 \r
159     flags = snewn(line->size, unsigned char);\r
160 \r
161     for (i = 0; i < line->size; i++)\r
162         flags[i] = (i < line->cols);\r
163 \r
164     for (i = 0; i < line->cols; i++) {\r
165         j = i;\r
166         while (line->chars[j].cc_next) {\r
167             j += line->chars[j].cc_next;\r
168             assert(j >= line->cols && j < line->size);\r
169             assert(!flags[j]);\r
170             flags[j] = TRUE;\r
171         }\r
172     }\r
173 \r
174     j = line->cc_free;\r
175     if (j) {\r
176         while (1) {\r
177             assert(j >= line->cols && j < line->size);\r
178             assert(!flags[j]);\r
179             flags[j] = TRUE;\r
180             if (line->chars[j].cc_next)\r
181                 j += line->chars[j].cc_next;\r
182             else\r
183                 break;\r
184         }\r
185     }\r
186 \r
187     j = 0;\r
188     for (i = 0; i < line->size; i++)\r
189         j += (flags[i] != 0);\r
190 \r
191     assert(j == line->size);\r
192 \r
193     sfree(flags);\r
194 }\r
195 #endif\r
196 \r
197 /*\r
198  * Add a combining character to a character cell.\r
199  */\r
200 static void add_cc(termline *line, int col, unsigned long chr)\r
201 {\r
202     int newcc;\r
203 \r
204     assert(col >= 0 && col < line->cols);\r
205 \r
206     /*\r
207      * Start by extending the cols array if the free list is empty.\r
208      */\r
209     if (!line->cc_free) {\r
210         int n = line->size;\r
211         line->size += 16 + (line->size - line->cols) / 2;\r
212         line->chars = sresize(line->chars, line->size, termchar);\r
213         line->cc_free = n;\r
214         while (n < line->size) {\r
215             if (n+1 < line->size)\r
216                 line->chars[n].cc_next = 1;\r
217             else\r
218                 line->chars[n].cc_next = 0;\r
219             n++;\r
220         }\r
221     }\r
222 \r
223     /*\r
224      * Now walk the cc list of the cell in question.\r
225      */\r
226     while (line->chars[col].cc_next)\r
227         col += line->chars[col].cc_next;\r
228 \r
229     /*\r
230      * `col' now points at the last cc currently in this cell; so\r
231      * we simply add another one.\r
232      */\r
233     newcc = line->cc_free;\r
234     if (line->chars[newcc].cc_next)\r
235         line->cc_free = newcc + line->chars[newcc].cc_next;\r
236     else\r
237         line->cc_free = 0;\r
238     line->chars[newcc].cc_next = 0;\r
239     line->chars[newcc].chr = chr;\r
240     line->chars[col].cc_next = newcc - col;\r
241 \r
242 #ifdef TERM_CC_DIAGS\r
243     cc_check(line);\r
244 #endif\r
245 }\r
246 \r
247 /*\r
248  * Clear the combining character list in a character cell.\r
249  */\r
250 static void clear_cc(termline *line, int col)\r
251 {\r
252     int oldfree, origcol = col;\r
253 \r
254     assert(col >= 0 && col < line->cols);\r
255 \r
256     if (!line->chars[col].cc_next)\r
257         return;                        /* nothing needs doing */\r
258 \r
259     oldfree = line->cc_free;\r
260     line->cc_free = col + line->chars[col].cc_next;\r
261     while (line->chars[col].cc_next)\r
262         col += line->chars[col].cc_next;\r
263     if (oldfree)\r
264         line->chars[col].cc_next = oldfree - col;\r
265     else\r
266         line->chars[col].cc_next = 0;\r
267 \r
268     line->chars[origcol].cc_next = 0;\r
269 \r
270 #ifdef TERM_CC_DIAGS\r
271     cc_check(line);\r
272 #endif\r
273 }\r
274 \r
275 /*\r
276  * Compare two character cells for equality. Special case required\r
277  * in do_paint() where we override what we expect the chr and attr\r
278  * fields to be.\r
279  */\r
280 static int termchars_equal_override(termchar *a, termchar *b,\r
281                                     unsigned long bchr, unsigned long battr)\r
282 {\r
283     /* FULL-TERMCHAR */\r
284     if (a->chr != bchr)\r
285         return FALSE;\r
286     if ((a->attr &~ DATTR_MASK) != (battr &~ DATTR_MASK))\r
287         return FALSE;\r
288     while (a->cc_next || b->cc_next) {\r
289         if (!a->cc_next || !b->cc_next)\r
290             return FALSE;              /* one cc-list ends, other does not */\r
291         a += a->cc_next;\r
292         b += b->cc_next;\r
293         if (a->chr != b->chr)\r
294             return FALSE;\r
295     }\r
296     return TRUE;\r
297 }\r
298 \r
299 static int termchars_equal(termchar *a, termchar *b)\r
300 {\r
301     return termchars_equal_override(a, b, b->chr, b->attr);\r
302 }\r
303 \r
304 /*\r
305  * Copy a character cell. (Requires a pointer to the destination\r
306  * termline, so as to access its free list.)\r
307  */\r
308 static void copy_termchar(termline *destline, int x, termchar *src)\r
309 {\r
310     clear_cc(destline, x);\r
311 \r
312     destline->chars[x] = *src;         /* copy everything except cc-list */\r
313     destline->chars[x].cc_next = 0;    /* and make sure this is zero */\r
314 \r
315     while (src->cc_next) {\r
316         src += src->cc_next;\r
317         add_cc(destline, x, src->chr);\r
318     }\r
319 \r
320 #ifdef TERM_CC_DIAGS\r
321     cc_check(destline);\r
322 #endif\r
323 }\r
324 \r
325 /*\r
326  * Move a character cell within its termline.\r
327  */\r
328 static void move_termchar(termline *line, termchar *dest, termchar *src)\r
329 {\r
330     /* First clear the cc list from the original char, just in case. */\r
331     clear_cc(line, dest - line->chars);\r
332 \r
333     /* Move the character cell and adjust its cc_next. */\r
334     *dest = *src;                      /* copy everything except cc-list */\r
335     if (src->cc_next)\r
336         dest->cc_next = src->cc_next - (dest-src);\r
337 \r
338     /* Ensure the original cell doesn't have a cc list. */\r
339     src->cc_next = 0;\r
340 \r
341 #ifdef TERM_CC_DIAGS\r
342     cc_check(line);\r
343 #endif\r
344 }\r
345 \r
346 /*\r
347  * Compress and decompress a termline into an RLE-based format for\r
348  * storing in scrollback. (Since scrollback almost never needs to\r
349  * be modified and exists in huge quantities, this is a sensible\r
350  * tradeoff, particularly since it allows us to continue adding\r
351  * features to the main termchar structure without proportionally\r
352  * bloating the terminal emulator's memory footprint unless those\r
353  * features are in constant use.)\r
354  */\r
355 struct buf {\r
356     unsigned char *data;\r
357     int len, size;\r
358 };\r
359 static void add(struct buf *b, unsigned char c)\r
360 {\r
361     if (b->len >= b->size) {\r
362         b->size = (b->len * 3 / 2) + 512;\r
363         b->data = sresize(b->data, b->size, unsigned char);\r
364     }\r
365     b->data[b->len++] = c;\r
366 }\r
367 static int get(struct buf *b)\r
368 {\r
369     return b->data[b->len++];\r
370 }\r
371 static void makerle(struct buf *b, termline *ldata,\r
372                     void (*makeliteral)(struct buf *b, termchar *c,\r
373                                         unsigned long *state))\r
374 {\r
375     int hdrpos, hdrsize, n, prevlen, prevpos, thislen, thispos, prev2;\r
376     termchar *c = ldata->chars;\r
377     unsigned long state = 0, oldstate;\r
378 \r
379     n = ldata->cols;\r
380 \r
381     hdrpos = b->len;\r
382     hdrsize = 0;\r
383     add(b, 0);\r
384     prevlen = prevpos = 0;\r
385     prev2 = FALSE;\r
386 \r
387     while (n-- > 0) {\r
388         thispos = b->len;\r
389         makeliteral(b, c++, &state);\r
390         thislen = b->len - thispos;\r
391         if (thislen == prevlen &&\r
392             !memcmp(b->data + prevpos, b->data + thispos, thislen)) {\r
393             /*\r
394              * This literal precisely matches the previous one.\r
395              * Turn it into a run if it's worthwhile.\r
396              * \r
397              * With one-byte literals, it costs us two bytes to\r
398              * encode a run, plus another byte to write the header\r
399              * to resume normal output; so a three-element run is\r
400              * neutral, and anything beyond that is unconditionally\r
401              * worthwhile. With two-byte literals or more, even a\r
402              * 2-run is a win.\r
403              */\r
404             if (thislen > 1 || prev2) {\r
405                 int runpos, runlen;\r
406 \r
407                 /*\r
408                  * It's worth encoding a run. Start at prevpos,\r
409                  * unless hdrsize==0 in which case we can back up\r
410                  * another one and start by overwriting hdrpos.\r
411                  */\r
412 \r
413                 hdrsize--;             /* remove the literal at prevpos */\r
414                 if (prev2) {\r
415                     assert(hdrsize > 0);\r
416                     hdrsize--;\r
417                     prevpos -= prevlen;/* and possibly another one */\r
418                 }\r
419 \r
420                 if (hdrsize == 0) {\r
421                     assert(prevpos == hdrpos + 1);\r
422                     runpos = hdrpos;\r
423                     b->len = prevpos+prevlen;\r
424                 } else {\r
425                     memmove(b->data + prevpos+1, b->data + prevpos, prevlen);\r
426                     runpos = prevpos;\r
427                     b->len = prevpos+prevlen+1;\r
428                     /*\r
429                      * Terminate the previous run of ordinary\r
430                      * literals.\r
431                      */\r
432                     assert(hdrsize >= 1 && hdrsize <= 128);\r
433                     b->data[hdrpos] = hdrsize - 1;\r
434                 }\r
435 \r
436                 runlen = prev2 ? 3 : 2;\r
437 \r
438                 while (n > 0 && runlen < 129) {\r
439                     int tmppos, tmplen;\r
440                     tmppos = b->len;\r
441                     oldstate = state;\r
442                     makeliteral(b, c, &state);\r
443                     tmplen = b->len - tmppos;\r
444                     b->len = tmppos;\r
445                     if (tmplen != thislen ||\r
446                         memcmp(b->data + runpos+1, b->data + tmppos, tmplen)) {\r
447                         state = oldstate;\r
448                         break;         /* run over */\r
449                     }\r
450                     n--, c++, runlen++;\r
451                 }\r
452 \r
453                 assert(runlen >= 2 && runlen <= 129);\r
454                 b->data[runpos] = runlen + 0x80 - 2;\r
455 \r
456                 hdrpos = b->len;\r
457                 hdrsize = 0;\r
458                 add(b, 0);\r
459                 /* And ensure this run doesn't interfere with the next. */\r
460                 prevlen = prevpos = 0;\r
461                 prev2 = FALSE;\r
462 \r
463                 continue;\r
464             } else {\r
465                 /*\r
466                  * Just flag that the previous two literals were\r
467                  * identical, in case we find a third identical one\r
468                  * we want to turn into a run.\r
469                  */\r
470                 prev2 = TRUE;\r
471                 prevlen = thislen;\r
472                 prevpos = thispos;\r
473             }\r
474         } else {\r
475             prev2 = FALSE;\r
476             prevlen = thislen;\r
477             prevpos = thispos;\r
478         }\r
479 \r
480         /*\r
481          * This character isn't (yet) part of a run. Add it to\r
482          * hdrsize.\r
483          */\r
484         hdrsize++;\r
485         if (hdrsize == 128) {\r
486             b->data[hdrpos] = hdrsize - 1;\r
487             hdrpos = b->len;\r
488             hdrsize = 0;\r
489             add(b, 0);\r
490             prevlen = prevpos = 0;\r
491             prev2 = FALSE;\r
492         }\r
493     }\r
494 \r
495     /*\r
496      * Clean up.\r
497      */\r
498     if (hdrsize > 0) {\r
499         assert(hdrsize <= 128);\r
500         b->data[hdrpos] = hdrsize - 1;\r
501     } else {\r
502         b->len = hdrpos;\r
503     }\r
504 }\r
505 static void makeliteral_chr(struct buf *b, termchar *c, unsigned long *state)\r
506 {\r
507     /*\r
508      * My encoding for characters is UTF-8-like, in that it stores\r
509      * 7-bit ASCII in one byte and uses high-bit-set bytes as\r
510      * introducers to indicate a longer sequence. However, it's\r
511      * unlike UTF-8 in that it doesn't need to be able to\r
512      * resynchronise, and therefore I don't want to waste two bits\r
513      * per byte on having recognisable continuation characters.\r
514      * Also I don't want to rule out the possibility that I may one\r
515      * day use values 0x80000000-0xFFFFFFFF for interesting\r
516      * purposes, so unlike UTF-8 I need a full 32-bit range.\r
517      * Accordingly, here is my encoding:\r
518      * \r
519      * 00000000-0000007F: 0xxxxxxx (but see below)\r
520      * 00000080-00003FFF: 10xxxxxx xxxxxxxx\r
521      * 00004000-001FFFFF: 110xxxxx xxxxxxxx xxxxxxxx\r
522      * 00200000-0FFFFFFF: 1110xxxx xxxxxxxx xxxxxxxx xxxxxxxx\r
523      * 10000000-FFFFFFFF: 11110ZZZ xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx\r
524      * \r
525      * (`Z' is like `x' but is always going to be zero since the\r
526      * values I'm encoding don't go above 2^32. In principle the\r
527      * five-byte form of the encoding could extend to 2^35, and\r
528      * there could be six-, seven-, eight- and nine-byte forms as\r
529      * well to allow up to 64-bit values to be encoded. But that's\r
530      * completely unnecessary for these purposes!)\r
531      * \r
532      * The encoding as written above would be very simple, except\r
533      * that 7-bit ASCII can occur in several different ways in the\r
534      * terminal data; sometimes it crops up in the D800 page\r
535      * (CSET_ASCII) but at other times it's in the 0000 page (real\r
536      * Unicode). Therefore, this encoding is actually _stateful_:\r
537      * the one-byte encoding of 00-7F actually indicates `reuse the\r
538      * upper three bytes of the last character', and to encode an\r
539      * absolute value of 00-7F you need to use the two-byte form\r
540      * instead.\r
541      */\r
542     if ((c->chr & ~0x7F) == *state) {\r
543         add(b, (unsigned char)(c->chr & 0x7F));\r
544     } else if (c->chr < 0x4000) {\r
545         add(b, (unsigned char)(((c->chr >> 8) & 0x3F) | 0x80));\r
546         add(b, (unsigned char)(c->chr & 0xFF));\r
547     } else if (c->chr < 0x200000) {\r
548         add(b, (unsigned char)(((c->chr >> 16) & 0x1F) | 0xC0));\r
549         add(b, (unsigned char)((c->chr >> 8) & 0xFF));\r
550         add(b, (unsigned char)(c->chr & 0xFF));\r
551     } else if (c->chr < 0x10000000) {\r
552         add(b, (unsigned char)(((c->chr >> 24) & 0x0F) | 0xE0));\r
553         add(b, (unsigned char)((c->chr >> 16) & 0xFF));\r
554         add(b, (unsigned char)((c->chr >> 8) & 0xFF));\r
555         add(b, (unsigned char)(c->chr & 0xFF));\r
556     } else {\r
557         add(b, 0xF0);\r
558         add(b, (unsigned char)((c->chr >> 24) & 0xFF));\r
559         add(b, (unsigned char)((c->chr >> 16) & 0xFF));\r
560         add(b, (unsigned char)((c->chr >> 8) & 0xFF));\r
561         add(b, (unsigned char)(c->chr & 0xFF));\r
562     }\r
563     *state = c->chr & ~0xFF;\r
564 }\r
565 static void makeliteral_attr(struct buf *b, termchar *c, unsigned long *state)\r
566 {\r
567     /*\r
568      * My encoding for attributes is 16-bit-granular and assumes\r
569      * that the top bit of the word is never required. I either\r
570      * store a two-byte value with the top bit clear (indicating\r
571      * just that value), or a four-byte value with the top bit set\r
572      * (indicating the same value with its top bit clear).\r
573      * \r
574      * However, first I permute the bits of the attribute value, so\r
575      * that the eight bits of colour (four in each of fg and bg)\r
576      * which are never non-zero unless xterm 256-colour mode is in\r
577      * use are placed higher up the word than everything else. This\r
578      * ensures that attribute values remain 16-bit _unless_ the\r
579      * user uses extended colour.\r
580      */\r
581     unsigned attr, colourbits;\r
582 \r
583     attr = c->attr;\r
584 \r
585     assert(ATTR_BGSHIFT > ATTR_FGSHIFT);\r
586 \r
587     colourbits = (attr >> (ATTR_BGSHIFT + 4)) & 0xF;\r
588     colourbits <<= 4;\r
589     colourbits |= (attr >> (ATTR_FGSHIFT + 4)) & 0xF;\r
590 \r
591     attr = (((attr >> (ATTR_BGSHIFT + 8)) << (ATTR_BGSHIFT + 4)) |\r
592             (attr & ((1 << (ATTR_BGSHIFT + 4))-1)));\r
593     attr = (((attr >> (ATTR_FGSHIFT + 8)) << (ATTR_FGSHIFT + 4)) |\r
594             (attr & ((1 << (ATTR_FGSHIFT + 4))-1)));\r
595 \r
596     attr |= (colourbits << (32-9));\r
597 \r
598     if (attr < 0x8000) {\r
599         add(b, (unsigned char)((attr >> 8) & 0xFF));\r
600         add(b, (unsigned char)(attr & 0xFF));\r
601     } else {\r
602         add(b, (unsigned char)(((attr >> 24) & 0x7F) | 0x80));\r
603         add(b, (unsigned char)((attr >> 16) & 0xFF));\r
604         add(b, (unsigned char)((attr >> 8) & 0xFF));\r
605         add(b, (unsigned char)(attr & 0xFF));\r
606     }\r
607 }\r
608 static void makeliteral_cc(struct buf *b, termchar *c, unsigned long *state)\r
609 {\r
610     /*\r
611      * For combining characters, I just encode a bunch of ordinary\r
612      * chars using makeliteral_chr, and terminate with a \0\r
613      * character (which I know won't come up as a combining char\r
614      * itself).\r
615      * \r
616      * I don't use the stateful encoding in makeliteral_chr.\r
617      */\r
618     unsigned long zstate;\r
619     termchar z;\r
620 \r
621     while (c->cc_next) {\r
622         c += c->cc_next;\r
623 \r
624         assert(c->chr != 0);\r
625 \r
626         zstate = 0;\r
627         makeliteral_chr(b, c, &zstate);\r
628     }\r
629 \r
630     z.chr = 0;\r
631     zstate = 0;\r
632     makeliteral_chr(b, &z, &zstate);\r
633 }\r
634 \r
635 static termline *decompressline(unsigned char *data, int *bytes_used);\r
636 \r
637 static unsigned char *compressline(termline *ldata)\r
638 {\r
639     struct buf buffer = { NULL, 0, 0 }, *b = &buffer;\r
640 \r
641     /*\r
642      * First, store the column count, 7 bits at a time, least\r
643      * significant `digit' first, with the high bit set on all but\r
644      * the last.\r
645      */\r
646     {\r
647         int n = ldata->cols;\r
648         while (n >= 128) {\r
649             add(b, (unsigned char)((n & 0x7F) | 0x80));\r
650             n >>= 7;\r
651         }\r
652         add(b, (unsigned char)(n));\r
653     }\r
654 \r
655     /*\r
656      * Next store the lattrs; same principle.\r
657      */\r
658     {\r
659         int n = ldata->lattr;\r
660         while (n >= 128) {\r
661             add(b, (unsigned char)((n & 0x7F) | 0x80));\r
662             n >>= 7;\r
663         }\r
664         add(b, (unsigned char)(n));\r
665     }\r
666 \r
667     /*\r
668      * Now we store a sequence of separate run-length encoded\r
669      * fragments, each containing exactly as many symbols as there\r
670      * are columns in the ldata.\r
671      * \r
672      * All of these have a common basic format:\r
673      * \r
674      *  - a byte 00-7F indicates that X+1 literals follow it\r
675      *  - a byte 80-FF indicates that a single literal follows it\r
676      *    and expects to be repeated (X-0x80)+2 times.\r
677      * \r
678      * The format of the `literals' varies between the fragments.\r
679      */\r
680     makerle(b, ldata, makeliteral_chr);\r
681     makerle(b, ldata, makeliteral_attr);\r
682     makerle(b, ldata, makeliteral_cc);\r
683 \r
684     /*\r
685      * Diagnostics: ensure that the compressed data really does\r
686      * decompress to the right thing.\r
687      * \r
688      * This is a bit performance-heavy for production code.\r
689      */\r
690 #ifdef TERM_CC_DIAGS\r
691 #ifndef CHECK_SB_COMPRESSION\r
692     {\r
693         int dused;\r
694         termline *dcl;\r
695         int i;\r
696 \r
697 #ifdef DIAGNOSTIC_SB_COMPRESSION\r
698         for (i = 0; i < b->len; i++) {\r
699             printf(" %02x ", b->data[i]);\r
700         }\r
701         printf("\n");\r
702 #endif\r
703 \r
704         dcl = decompressline(b->data, &dused);\r
705         assert(b->len == dused);\r
706         assert(ldata->cols == dcl->cols);\r
707         assert(ldata->lattr == dcl->lattr);\r
708         for (i = 0; i < ldata->cols; i++)\r
709             assert(termchars_equal(&ldata->chars[i], &dcl->chars[i]));\r
710 \r
711 #ifdef DIAGNOSTIC_SB_COMPRESSION\r
712         printf("%d cols (%d bytes) -> %d bytes (factor of %g)\n",\r
713                ldata->cols, 4 * ldata->cols, dused,\r
714                (double)dused / (4 * ldata->cols));\r
715 #endif\r
716 \r
717         freeline(dcl);\r
718     }\r
719 #endif\r
720 #endif /* TERM_CC_DIAGS */\r
721 \r
722     /*\r
723      * Trim the allocated memory so we don't waste any, and return.\r
724      */\r
725     return sresize(b->data, b->len, unsigned char);\r
726 }\r
727 \r
728 static void readrle(struct buf *b, termline *ldata,\r
729                     void (*readliteral)(struct buf *b, termchar *c,\r
730                                         termline *ldata, unsigned long *state))\r
731 {\r
732     int n = 0;\r
733     unsigned long state = 0;\r
734 \r
735     while (n < ldata->cols) {\r
736         int hdr = get(b);\r
737 \r
738         if (hdr >= 0x80) {\r
739             /* A run. */\r
740 \r
741             int pos = b->len, count = hdr + 2 - 0x80;\r
742             while (count--) {\r
743                 assert(n < ldata->cols);\r
744                 b->len = pos;\r
745                 readliteral(b, ldata->chars + n, ldata, &state);\r
746                 n++;\r
747             }\r
748         } else {\r
749             /* Just a sequence of consecutive literals. */\r
750 \r
751             int count = hdr + 1;\r
752             while (count--) {\r
753                 assert(n < ldata->cols);\r
754                 readliteral(b, ldata->chars + n, ldata, &state);\r
755                 n++;\r
756             }\r
757         }\r
758     }\r
759 \r
760     assert(n == ldata->cols);\r
761 }\r
762 static void readliteral_chr(struct buf *b, termchar *c, termline *ldata,\r
763                             unsigned long *state)\r
764 {\r
765     int byte;\r
766 \r
767     /*\r
768      * 00000000-0000007F: 0xxxxxxx\r
769      * 00000080-00003FFF: 10xxxxxx xxxxxxxx\r
770      * 00004000-001FFFFF: 110xxxxx xxxxxxxx xxxxxxxx\r
771      * 00200000-0FFFFFFF: 1110xxxx xxxxxxxx xxxxxxxx xxxxxxxx\r
772      * 10000000-FFFFFFFF: 11110ZZZ xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx\r
773      */\r
774 \r
775     byte = get(b);\r
776     if (byte < 0x80) {\r
777         c->chr = byte | *state;\r
778     } else if (byte < 0xC0) {\r
779         c->chr = (byte &~ 0xC0) << 8;\r
780         c->chr |= get(b);\r
781     } else if (byte < 0xE0) {\r
782         c->chr = (byte &~ 0xE0) << 16;\r
783         c->chr |= get(b) << 8;\r
784         c->chr |= get(b);\r
785     } else if (byte < 0xF0) {\r
786         c->chr = (byte &~ 0xF0) << 24;\r
787         c->chr |= get(b) << 16;\r
788         c->chr |= get(b) << 8;\r
789         c->chr |= get(b);\r
790     } else {\r
791         assert(byte == 0xF0);\r
792         c->chr = get(b) << 24;\r
793         c->chr |= get(b) << 16;\r
794         c->chr |= get(b) << 8;\r
795         c->chr |= get(b);\r
796     }\r
797     *state = c->chr & ~0xFF;\r
798 }\r
799 static void readliteral_attr(struct buf *b, termchar *c, termline *ldata,\r
800                              unsigned long *state)\r
801 {\r
802     unsigned val, attr, colourbits;\r
803 \r
804     val = get(b) << 8;\r
805     val |= get(b);\r
806 \r
807     if (val >= 0x8000) {\r
808         val &= ~0x8000;\r
809         val <<= 16;\r
810         val |= get(b) << 8;\r
811         val |= get(b);\r
812     }\r
813 \r
814     colourbits = (val >> (32-9)) & 0xFF;\r
815     attr = (val & ((1<<(32-9))-1));\r
816 \r
817     attr = (((attr >> (ATTR_FGSHIFT + 4)) << (ATTR_FGSHIFT + 8)) |\r
818             (attr & ((1 << (ATTR_FGSHIFT + 4))-1)));\r
819     attr = (((attr >> (ATTR_BGSHIFT + 4)) << (ATTR_BGSHIFT + 8)) |\r
820             (attr & ((1 << (ATTR_BGSHIFT + 4))-1)));\r
821 \r
822     attr |= (colourbits >> 4) << (ATTR_BGSHIFT + 4);\r
823     attr |= (colourbits & 0xF) << (ATTR_FGSHIFT + 4);\r
824 \r
825     c->attr = attr;\r
826 }\r
827 static void readliteral_cc(struct buf *b, termchar *c, termline *ldata,\r
828                            unsigned long *state)\r
829 {\r
830     termchar n;\r
831     unsigned long zstate;\r
832     int x = c - ldata->chars;\r
833 \r
834     c->cc_next = 0;\r
835 \r
836     while (1) {\r
837         zstate = 0;\r
838         readliteral_chr(b, &n, ldata, &zstate);\r
839         if (!n.chr)\r
840             break;\r
841         add_cc(ldata, x, n.chr);\r
842     }\r
843 }\r
844 \r
845 static termline *decompressline(unsigned char *data, int *bytes_used)\r
846 {\r
847     int ncols, byte, shift;\r
848     struct buf buffer, *b = &buffer;\r
849     termline *ldata;\r
850 \r
851     b->data = data;\r
852     b->len = 0;\r
853 \r
854     /*\r
855      * First read in the column count.\r
856      */\r
857     ncols = shift = 0;\r
858     do {\r
859         byte = get(b);\r
860         ncols |= (byte & 0x7F) << shift;\r
861         shift += 7;\r
862     } while (byte & 0x80);\r
863 \r
864     /*\r
865      * Now create the output termline.\r
866      */\r
867     ldata = snew(termline);\r
868     ldata->chars = snewn(ncols, termchar);\r
869     ldata->cols = ldata->size = ncols;\r
870     ldata->temporary = TRUE;\r
871     ldata->cc_free = 0;\r
872 \r
873     /*\r
874      * We must set all the cc pointers in ldata->chars to 0 right\r
875      * now, so that cc diagnostics that verify the integrity of the\r
876      * whole line will make sense while we're in the middle of\r
877      * building it up.\r
878      */\r
879     {\r
880         int i;\r
881         for (i = 0; i < ldata->cols; i++)\r
882             ldata->chars[i].cc_next = 0;\r
883     }\r
884 \r
885     /*\r
886      * Now read in the lattr.\r
887      */\r
888     ldata->lattr = shift = 0;\r
889     do {\r
890         byte = get(b);\r
891         ldata->lattr |= (byte & 0x7F) << shift;\r
892         shift += 7;\r
893     } while (byte & 0x80);\r
894 \r
895     /*\r
896      * Now we read in each of the RLE streams in turn.\r
897      */\r
898     readrle(b, ldata, readliteral_chr);\r
899     readrle(b, ldata, readliteral_attr);\r
900     readrle(b, ldata, readliteral_cc);\r
901 \r
902     /* Return the number of bytes read, for diagnostic purposes. */\r
903     if (bytes_used)\r
904         *bytes_used = b->len;\r
905 \r
906     return ldata;\r
907 }\r
908 \r
909 /*\r
910  * Resize a line to make it `cols' columns wide.\r
911  */\r
912 static void resizeline(Terminal *term, termline *line, int cols)\r
913 {\r
914     int i, oldcols;\r
915 \r
916     if (line->cols != cols) {\r
917 \r
918         oldcols = line->cols;\r
919 \r
920         /*\r
921          * This line is the wrong length, which probably means it\r
922          * hasn't been accessed since a resize. Resize it now.\r
923          * \r
924          * First, go through all the characters that will be thrown\r
925          * out in the resize (if we're shrinking the line) and\r
926          * return their cc lists to the cc free list.\r
927          */\r
928         for (i = cols; i < oldcols; i++)\r
929             clear_cc(line, i);\r
930 \r
931         /*\r
932          * If we're shrinking the line, we now bodily move the\r
933          * entire cc section from where it started to where it now\r
934          * needs to be. (We have to do this before the resize, so\r
935          * that the data we're copying is still there. However, if\r
936          * we're expanding, we have to wait until _after_ the\r
937          * resize so that the space we're copying into is there.)\r
938          */\r
939         if (cols < oldcols)\r
940             memmove(line->chars + cols, line->chars + oldcols,\r
941                     (line->size - line->cols) * TSIZE);\r
942 \r
943         /*\r
944          * Now do the actual resize, leaving the _same_ amount of\r
945          * cc space as there was to begin with.\r
946          */\r
947         line->size += cols - oldcols;\r
948         line->chars = sresize(line->chars, line->size, TTYPE);\r
949         line->cols = cols;\r
950 \r
951         /*\r
952          * If we're expanding the line, _now_ we move the cc\r
953          * section.\r
954          */\r
955         if (cols > oldcols)\r
956             memmove(line->chars + cols, line->chars + oldcols,\r
957                     (line->size - line->cols) * TSIZE);\r
958 \r
959         /*\r
960          * Go through what's left of the original line, and adjust\r
961          * the first cc_next pointer in each list. (All the\r
962          * subsequent ones are still valid because they are\r
963          * relative offsets within the cc block.) Also do the same\r
964          * to the head of the cc_free list.\r
965          */\r
966         for (i = 0; i < oldcols && i < cols; i++)\r
967             if (line->chars[i].cc_next)\r
968                 line->chars[i].cc_next += cols - oldcols;\r
969         if (line->cc_free)\r
970             line->cc_free += cols - oldcols;\r
971 \r
972         /*\r
973          * And finally fill in the new space with erase chars. (We\r
974          * don't have to worry about cc lists here, because we\r
975          * _know_ the erase char doesn't have one.)\r
976          */\r
977         for (i = oldcols; i < cols; i++)\r
978             line->chars[i] = term->basic_erase_char;\r
979 \r
980 #ifdef TERM_CC_DIAGS\r
981         cc_check(line);\r
982 #endif\r
983     }\r
984 }\r
985 \r
986 /*\r
987  * Get the number of lines in the scrollback.\r
988  */\r
989 static int sblines(Terminal *term)\r
990 {\r
991     int sblines = count234(term->scrollback);\r
992     if (term->cfg.erase_to_scrollback &&\r
993         term->alt_which && term->alt_screen) {\r
994             sblines += term->alt_sblines;\r
995     }\r
996     return sblines;\r
997 }\r
998 \r
999 /*\r
1000  * Retrieve a line of the screen or of the scrollback, according to\r
1001  * whether the y coordinate is non-negative or negative\r
1002  * (respectively).\r
1003  */\r
1004 static termline *lineptr(Terminal *term, int y, int lineno, int screen)\r
1005 {\r
1006     termline *line;\r
1007     tree234 *whichtree;\r
1008     int treeindex;\r
1009 \r
1010     if (y >= 0) {\r
1011         whichtree = term->screen;\r
1012         treeindex = y;\r
1013     } else {\r
1014         int altlines = 0;\r
1015 \r
1016         assert(!screen);\r
1017 \r
1018         if (term->cfg.erase_to_scrollback &&\r
1019             term->alt_which && term->alt_screen) {\r
1020             altlines = term->alt_sblines;\r
1021         }\r
1022         if (y < -altlines) {\r
1023             whichtree = term->scrollback;\r
1024             treeindex = y + altlines + count234(term->scrollback);\r
1025         } else {\r
1026             whichtree = term->alt_screen;\r
1027             treeindex = y + term->alt_sblines;\r
1028             /* treeindex = y + count234(term->alt_screen); */\r
1029         }\r
1030     }\r
1031     if (whichtree == term->scrollback) {\r
1032         unsigned char *cline = index234(whichtree, treeindex);\r
1033         line = decompressline(cline, NULL);\r
1034     } else {\r
1035         line = index234(whichtree, treeindex);\r
1036     }\r
1037 \r
1038     /* We assume that we don't screw up and retrieve something out of range. */\r
1039     if (line == NULL) {\r
1040         fatalbox("line==NULL in terminal.c\n"\r
1041                  "lineno=%d y=%d w=%d h=%d\n"\r
1042                  "count(scrollback=%p)=%d\n"\r
1043                  "count(screen=%p)=%d\n"\r
1044                  "count(alt=%p)=%d alt_sblines=%d\n"\r
1045                  "whichtree=%p treeindex=%d\n\n"\r
1046                  "Please contact <putty@projects.tartarus.org> "\r
1047                  "and pass on the above information.",\r
1048                  lineno, y, term->cols, term->rows,\r
1049                  term->scrollback, count234(term->scrollback),\r
1050                  term->screen, count234(term->screen),\r
1051                  term->alt_screen, count234(term->alt_screen), term->alt_sblines,\r
1052                  whichtree, treeindex);\r
1053     }\r
1054     assert(line != NULL);\r
1055 \r
1056     resizeline(term, line, term->cols);\r
1057     /* FIXME: should we sort the compressed scrollback out here? */\r
1058 \r
1059     return line;\r
1060 }\r
1061 \r
1062 #define lineptr(x) (lineptr)(term,x,__LINE__,FALSE)\r
1063 #define scrlineptr(x) (lineptr)(term,x,__LINE__,TRUE)\r
1064 \r
1065 static void term_schedule_tblink(Terminal *term);\r
1066 static void term_schedule_cblink(Terminal *term);\r
1067 \r
1068 static void term_timer(void *ctx, long now)\r
1069 {\r
1070     Terminal *term = (Terminal *)ctx;\r
1071     int update = FALSE;\r
1072 \r
1073     if (term->tblink_pending && now - term->next_tblink >= 0) {\r
1074         term->tblinker = !term->tblinker;\r
1075         term->tblink_pending = FALSE;\r
1076         term_schedule_tblink(term);\r
1077         update = TRUE;\r
1078     }\r
1079 \r
1080     if (term->cblink_pending && now - term->next_cblink >= 0) {\r
1081         term->cblinker = !term->cblinker;\r
1082         term->cblink_pending = FALSE;\r
1083         term_schedule_cblink(term);\r
1084         update = TRUE;\r
1085     }\r
1086 \r
1087     if (term->in_vbell && now - term->vbell_end >= 0) {\r
1088         term->in_vbell = FALSE;\r
1089         update = TRUE;\r
1090     }\r
1091 \r
1092     if (update ||\r
1093         (term->window_update_pending && now - term->next_update >= 0))\r
1094         term_update(term);\r
1095 }\r
1096 \r
1097 static void term_schedule_update(Terminal *term)\r
1098 {\r
1099     if (!term->window_update_pending) {\r
1100         term->window_update_pending = TRUE;\r
1101         term->next_update = schedule_timer(UPDATE_DELAY, term_timer, term);\r
1102     }\r
1103 }\r
1104 \r
1105 /*\r
1106  * Call this whenever the terminal window state changes, to queue\r
1107  * an update.\r
1108  */\r
1109 static void seen_disp_event(Terminal *term)\r
1110 {\r
1111     term->seen_disp_event = TRUE;      /* for scrollback-reset-on-activity */\r
1112     term_schedule_update(term);\r
1113 }\r
1114 \r
1115 /*\r
1116  * Call when the terminal's blinking-text settings change, or when\r
1117  * a text blink has just occurred.\r
1118  */\r
1119 static void term_schedule_tblink(Terminal *term)\r
1120 {\r
1121     if (term->blink_is_real) {\r
1122         if (!term->tblink_pending)\r
1123             term->next_tblink = schedule_timer(TBLINK_DELAY, term_timer, term);\r
1124         term->tblink_pending = TRUE;\r
1125     } else {\r
1126         term->tblinker = 1;            /* reset when not in use */\r
1127         term->tblink_pending = FALSE;\r
1128     }\r
1129 }\r
1130 \r
1131 /*\r
1132  * Likewise with cursor blinks.\r
1133  */\r
1134 static void term_schedule_cblink(Terminal *term)\r
1135 {\r
1136     if (term->cfg.blink_cur && term->has_focus) {\r
1137         if (!term->cblink_pending)\r
1138             term->next_cblink = schedule_timer(CBLINK_DELAY, term_timer, term);\r
1139         term->cblink_pending = TRUE;\r
1140     } else {\r
1141         term->cblinker = 1;            /* reset when not in use */\r
1142         term->cblink_pending = FALSE;\r
1143     }\r
1144 }\r
1145 \r
1146 /*\r
1147  * Call to reset cursor blinking on new output.\r
1148  */\r
1149 static void term_reset_cblink(Terminal *term)\r
1150 {\r
1151     seen_disp_event(term);\r
1152     term->cblinker = 1;\r
1153     term->cblink_pending = FALSE;\r
1154     term_schedule_cblink(term);\r
1155 }\r
1156 \r
1157 /*\r
1158  * Call to begin a visual bell.\r
1159  */\r
1160 static void term_schedule_vbell(Terminal *term, int already_started,\r
1161                                 long startpoint)\r
1162 {\r
1163     long ticks_already_gone;\r
1164 \r
1165     if (already_started)\r
1166         ticks_already_gone = GETTICKCOUNT() - startpoint;\r
1167     else\r
1168         ticks_already_gone = 0;\r
1169 \r
1170     if (ticks_already_gone < VBELL_DELAY) {\r
1171         term->in_vbell = TRUE;\r
1172         term->vbell_end = schedule_timer(VBELL_DELAY - ticks_already_gone,\r
1173                                          term_timer, term);\r
1174     } else {\r
1175         term->in_vbell = FALSE;\r
1176     }\r
1177 }\r
1178 \r
1179 /*\r
1180  * Set up power-on settings for the terminal.\r
1181  * If 'clear' is false, don't actually clear the primary screen, and\r
1182  * position the cursor below the last non-blank line (scrolling if\r
1183  * necessary).\r
1184  */\r
1185 static void power_on(Terminal *term, int clear)\r
1186 {\r
1187     term->alt_x = term->alt_y = 0;\r
1188     term->savecurs.x = term->savecurs.y = 0;\r
1189     term->alt_savecurs.x = term->alt_savecurs.y = 0;\r
1190     term->alt_t = term->marg_t = 0;\r
1191     if (term->rows != -1)\r
1192         term->alt_b = term->marg_b = term->rows - 1;\r
1193     else\r
1194         term->alt_b = term->marg_b = 0;\r
1195     if (term->cols != -1) {\r
1196         int i;\r
1197         for (i = 0; i < term->cols; i++)\r
1198             term->tabs[i] = (i % 8 == 0 ? TRUE : FALSE);\r
1199     }\r
1200     term->alt_om = term->dec_om = term->cfg.dec_om;\r
1201     term->alt_ins = term->insert = FALSE;\r
1202     term->alt_wnext = term->wrapnext =\r
1203         term->save_wnext = term->alt_save_wnext = FALSE;\r
1204     term->alt_wrap = term->wrap = term->cfg.wrap_mode;\r
1205     term->alt_cset = term->cset = term->save_cset = term->alt_save_cset = 0;\r
1206     term->alt_utf = term->utf = term->save_utf = term->alt_save_utf = 0;\r
1207     term->utf_state = 0;\r
1208     term->alt_sco_acs = term->sco_acs =\r
1209         term->save_sco_acs = term->alt_save_sco_acs = 0;\r
1210     term->cset_attr[0] = term->cset_attr[1] =\r
1211         term->save_csattr = term->alt_save_csattr = CSET_ASCII;\r
1212     term->rvideo = 0;\r
1213     term->in_vbell = FALSE;\r
1214     term->cursor_on = 1;\r
1215     term->big_cursor = 0;\r
1216     term->default_attr = term->save_attr =\r
1217         term->alt_save_attr = term->curr_attr = ATTR_DEFAULT;\r
1218     term->term_editing = term->term_echoing = FALSE;\r
1219     term->app_cursor_keys = term->cfg.app_cursor;\r
1220     term->app_keypad_keys = term->cfg.app_keypad;\r
1221     term->use_bce = term->cfg.bce;\r
1222     term->blink_is_real = term->cfg.blinktext;\r
1223     term->erase_char = term->basic_erase_char;\r
1224     term->alt_which = 0;\r
1225     term_print_finish(term);\r
1226     term->xterm_mouse = 0;\r
1227     set_raw_mouse_mode(term->frontend, FALSE);\r
1228     {\r
1229         int i;\r
1230         for (i = 0; i < 256; i++)\r
1231             term->wordness[i] = term->cfg.wordness[i];\r
1232     }\r
1233     if (term->screen) {\r
1234         swap_screen(term, 1, FALSE, FALSE);\r
1235         erase_lots(term, FALSE, TRUE, TRUE);\r
1236         swap_screen(term, 0, FALSE, FALSE);\r
1237         if (clear)\r
1238             erase_lots(term, FALSE, TRUE, TRUE);\r
1239         term->curs.y = find_last_nonempty_line(term, term->screen) + 1;\r
1240         if (term->curs.y == term->rows) {\r
1241             term->curs.y--;\r
1242             scroll(term, 0, term->rows - 1, 1, TRUE);\r
1243         }\r
1244     } else {\r
1245         term->curs.y = 0;\r
1246     }\r
1247     term->curs.x = 0;\r
1248     term_schedule_tblink(term);\r
1249     term_schedule_cblink(term);\r
1250 }\r
1251 \r
1252 /*\r
1253  * Force a screen update.\r
1254  */\r
1255 void term_update(Terminal *term)\r
1256 {\r
1257     Context ctx;\r
1258 \r
1259     term->window_update_pending = FALSE;\r
1260 \r
1261     ctx = get_ctx(term->frontend);\r
1262     if (ctx) {\r
1263         int need_sbar_update = term->seen_disp_event;\r
1264         if (term->seen_disp_event && term->cfg.scroll_on_disp) {\r
1265             term->disptop = 0;         /* return to main screen */\r
1266             term->seen_disp_event = 0;\r
1267             need_sbar_update = TRUE;\r
1268         }\r
1269 \r
1270         if (need_sbar_update)\r
1271             update_sbar(term);\r
1272         do_paint(term, ctx, TRUE);\r
1273         sys_cursor(term->frontend, term->curs.x, term->curs.y - term->disptop);\r
1274         free_ctx(ctx);\r
1275     }\r
1276 }\r
1277 \r
1278 /*\r
1279  * Called from front end when a keypress occurs, to trigger\r
1280  * anything magical that needs to happen in that situation.\r
1281  */\r
1282 void term_seen_key_event(Terminal *term)\r
1283 {\r
1284     /*\r
1285      * On any keypress, clear the bell overload mechanism\r
1286      * completely, on the grounds that large numbers of\r
1287      * beeps coming from deliberate key action are likely\r
1288      * to be intended (e.g. beeps from filename completion\r
1289      * blocking repeatedly).\r
1290      */\r
1291     term->beep_overloaded = FALSE;\r
1292     while (term->beephead) {\r
1293         struct beeptime *tmp = term->beephead;\r
1294         term->beephead = tmp->next;\r
1295         sfree(tmp);\r
1296     }\r
1297     term->beeptail = NULL;\r
1298     term->nbeeps = 0;\r
1299 \r
1300     /*\r
1301      * Reset the scrollback on keypress, if we're doing that.\r
1302      */\r
1303     if (term->cfg.scroll_on_key) {\r
1304         term->disptop = 0;             /* return to main screen */\r
1305         seen_disp_event(term);\r
1306     }\r
1307 }\r
1308 \r
1309 /*\r
1310  * Same as power_on(), but an external function.\r
1311  */\r
1312 void term_pwron(Terminal *term, int clear)\r
1313 {\r
1314     power_on(term, clear);\r
1315     if (term->ldisc)                   /* cause ldisc to notice changes */\r
1316         ldisc_send(term->ldisc, NULL, 0, 0);\r
1317     term->disptop = 0;\r
1318     deselect(term);\r
1319     term_update(term);\r
1320 }\r
1321 \r
1322 static void set_erase_char(Terminal *term)\r
1323 {\r
1324     term->erase_char = term->basic_erase_char;\r
1325     if (term->use_bce)\r
1326         term->erase_char.attr = (term->curr_attr &\r
1327                                  (ATTR_FGMASK | ATTR_BGMASK));\r
1328 }\r
1329 \r
1330 /*\r
1331  * When the user reconfigures us, we need to check the forbidden-\r
1332  * alternate-screen config option, disable raw mouse mode if the\r
1333  * user has disabled mouse reporting, and abandon a print job if\r
1334  * the user has disabled printing.\r
1335  */\r
1336 void term_reconfig(Terminal *term, Config *cfg)\r
1337 {\r
1338     /*\r
1339      * Before adopting the new config, check all those terminal\r
1340      * settings which control power-on defaults; and if they've\r
1341      * changed, we will modify the current state as well as the\r
1342      * default one. The full list is: Auto wrap mode, DEC Origin\r
1343      * Mode, BCE, blinking text, character classes.\r
1344      */\r
1345     int reset_wrap, reset_decom, reset_bce, reset_tblink, reset_charclass;\r
1346     int i;\r
1347 \r
1348     reset_wrap = (term->cfg.wrap_mode != cfg->wrap_mode);\r
1349     reset_decom = (term->cfg.dec_om != cfg->dec_om);\r
1350     reset_bce = (term->cfg.bce != cfg->bce);\r
1351     reset_tblink = (term->cfg.blinktext != cfg->blinktext);\r
1352     reset_charclass = 0;\r
1353     for (i = 0; i < lenof(term->cfg.wordness); i++)\r
1354         if (term->cfg.wordness[i] != cfg->wordness[i])\r
1355             reset_charclass = 1;\r
1356 \r
1357     /*\r
1358      * If the bidi or shaping settings have changed, flush the bidi\r
1359      * cache completely.\r
1360      */\r
1361     if (term->cfg.arabicshaping != cfg->arabicshaping ||\r
1362         term->cfg.bidi != cfg->bidi) {\r
1363         for (i = 0; i < term->bidi_cache_size; i++) {\r
1364             sfree(term->pre_bidi_cache[i].chars);\r
1365             sfree(term->post_bidi_cache[i].chars);\r
1366             term->pre_bidi_cache[i].width = -1;\r
1367             term->pre_bidi_cache[i].chars = NULL;\r
1368             term->post_bidi_cache[i].width = -1;\r
1369             term->post_bidi_cache[i].chars = NULL;\r
1370         }\r
1371     }\r
1372 \r
1373     term->cfg = *cfg;                  /* STRUCTURE COPY */\r
1374 \r
1375     if (reset_wrap)\r
1376         term->alt_wrap = term->wrap = term->cfg.wrap_mode;\r
1377     if (reset_decom)\r
1378         term->alt_om = term->dec_om = term->cfg.dec_om;\r
1379     if (reset_bce) {\r
1380         term->use_bce = term->cfg.bce;\r
1381         set_erase_char(term);\r
1382     }\r
1383     if (reset_tblink) {\r
1384         term->blink_is_real = term->cfg.blinktext;\r
1385     }\r
1386     if (reset_charclass)\r
1387         for (i = 0; i < 256; i++)\r
1388             term->wordness[i] = term->cfg.wordness[i];\r
1389 \r
1390     if (term->cfg.no_alt_screen)\r
1391         swap_screen(term, 0, FALSE, FALSE);\r
1392     if (term->cfg.no_mouse_rep) {\r
1393         term->xterm_mouse = 0;\r
1394         set_raw_mouse_mode(term->frontend, 0);\r
1395     }\r
1396     if (term->cfg.no_remote_charset) {\r
1397         term->cset_attr[0] = term->cset_attr[1] = CSET_ASCII;\r
1398         term->sco_acs = term->alt_sco_acs = 0;\r
1399         term->utf = 0;\r
1400     }\r
1401     if (!*term->cfg.printer) {\r
1402         term_print_finish(term);\r
1403     }\r
1404     term_schedule_tblink(term);\r
1405     term_schedule_cblink(term);\r
1406 }\r
1407 \r
1408 /*\r
1409  * Clear the scrollback.\r
1410  */\r
1411 void term_clrsb(Terminal *term)\r
1412 {\r
1413     unsigned char *line;\r
1414     term->disptop = 0;\r
1415     while ((line = delpos234(term->scrollback, 0)) != NULL) {\r
1416         sfree(line);            /* this is compressed data, not a termline */\r
1417     }\r
1418     term->tempsblines = 0;\r
1419     term->alt_sblines = 0;\r
1420     update_sbar(term);\r
1421 }\r
1422 \r
1423 /*\r
1424  * Initialise the terminal.\r
1425  */\r
1426 Terminal *term_init(Config *mycfg, struct unicode_data *ucsdata,\r
1427                     void *frontend)\r
1428 {\r
1429     Terminal *term;\r
1430 \r
1431     /*\r
1432      * Allocate a new Terminal structure and initialise the fields\r
1433      * that need it.\r
1434      */\r
1435     term = snew(Terminal);\r
1436     term->frontend = frontend;\r
1437     term->ucsdata = ucsdata;\r
1438     term->cfg = *mycfg;                /* STRUCTURE COPY */\r
1439     term->logctx = NULL;\r
1440     term->compatibility_level = TM_PUTTY;\r
1441     strcpy(term->id_string, "\033[?6c");\r
1442     term->cblink_pending = term->tblink_pending = FALSE;\r
1443     term->paste_buffer = NULL;\r
1444     term->paste_len = 0;\r
1445     term->last_paste = 0;\r
1446     bufchain_init(&term->inbuf);\r
1447     bufchain_init(&term->printer_buf);\r
1448     term->printing = term->only_printing = FALSE;\r
1449     term->print_job = NULL;\r
1450     term->vt52_mode = FALSE;\r
1451     term->cr_lf_return = FALSE;\r
1452     term->seen_disp_event = FALSE;\r
1453     term->mouse_is_down = FALSE;\r
1454     term->reset_132 = FALSE;\r
1455     term->cblinker = term->tblinker = 0;\r
1456     term->has_focus = 1;\r
1457     term->repeat_off = FALSE;\r
1458     term->termstate = TOPLEVEL;\r
1459     term->selstate = NO_SELECTION;\r
1460     term->curstype = 0;\r
1461 \r
1462     term->screen = term->alt_screen = term->scrollback = NULL;\r
1463     term->tempsblines = 0;\r
1464     term->alt_sblines = 0;\r
1465     term->disptop = 0;\r
1466     term->disptext = NULL;\r
1467     term->dispcursx = term->dispcursy = -1;\r
1468     term->tabs = NULL;\r
1469     deselect(term);\r
1470     term->rows = term->cols = -1;\r
1471     power_on(term, TRUE);\r
1472     term->beephead = term->beeptail = NULL;\r
1473 #ifdef OPTIMISE_SCROLL\r
1474     term->scrollhead = term->scrolltail = NULL;\r
1475 #endif /* OPTIMISE_SCROLL */\r
1476     term->nbeeps = 0;\r
1477     term->lastbeep = FALSE;\r
1478     term->beep_overloaded = FALSE;\r
1479     term->attr_mask = 0xffffffff;\r
1480     term->resize_fn = NULL;\r
1481     term->resize_ctx = NULL;\r
1482     term->in_term_out = FALSE;\r
1483     term->ltemp = NULL;\r
1484     term->ltemp_size = 0;\r
1485     term->wcFrom = NULL;\r
1486     term->wcTo = NULL;\r
1487     term->wcFromTo_size = 0;\r
1488 \r
1489     term->window_update_pending = FALSE;\r
1490 \r
1491     term->bidi_cache_size = 0;\r
1492     term->pre_bidi_cache = term->post_bidi_cache = NULL;\r
1493 \r
1494     /* FULL-TERMCHAR */\r
1495     term->basic_erase_char.chr = CSET_ASCII | ' ';\r
1496     term->basic_erase_char.attr = ATTR_DEFAULT;\r
1497     term->basic_erase_char.cc_next = 0;\r
1498     term->erase_char = term->basic_erase_char;\r
1499 \r
1500     return term;\r
1501 }\r
1502 \r
1503 void term_free(Terminal *term)\r
1504 {\r
1505     termline *line;\r
1506     struct beeptime *beep;\r
1507     int i;\r
1508 \r
1509     while ((line = delpos234(term->scrollback, 0)) != NULL)\r
1510         sfree(line);                   /* compressed data, not a termline */\r
1511     freetree234(term->scrollback);\r
1512     while ((line = delpos234(term->screen, 0)) != NULL)\r
1513         freeline(line);\r
1514     freetree234(term->screen);\r
1515     while ((line = delpos234(term->alt_screen, 0)) != NULL)\r
1516         freeline(line);\r
1517     freetree234(term->alt_screen);\r
1518     if (term->disptext) {\r
1519         for (i = 0; i < term->rows; i++)\r
1520             freeline(term->disptext[i]);\r
1521     }\r
1522     sfree(term->disptext);\r
1523     while (term->beephead) {\r
1524         beep = term->beephead;\r
1525         term->beephead = beep->next;\r
1526         sfree(beep);\r
1527     }\r
1528     bufchain_clear(&term->inbuf);\r
1529     if(term->print_job)\r
1530         printer_finish_job(term->print_job);\r
1531     bufchain_clear(&term->printer_buf);\r
1532     sfree(term->paste_buffer);\r
1533     sfree(term->ltemp);\r
1534     sfree(term->wcFrom);\r
1535     sfree(term->wcTo);\r
1536 \r
1537     for (i = 0; i < term->bidi_cache_size; i++) {\r
1538         sfree(term->pre_bidi_cache[i].chars);\r
1539         sfree(term->post_bidi_cache[i].chars);\r
1540     }\r
1541     sfree(term->pre_bidi_cache);\r
1542     sfree(term->post_bidi_cache);\r
1543 \r
1544     expire_timer_context(term);\r
1545 \r
1546     sfree(term);\r
1547 }\r
1548 \r
1549 /*\r
1550  * Set up the terminal for a given size.\r
1551  */\r
1552 void term_size(Terminal *term, int newrows, int newcols, int newsavelines)\r
1553 {\r
1554     tree234 *newalt;\r
1555     termline **newdisp, *line;\r
1556     int i, j, oldrows = term->rows;\r
1557     int sblen;\r
1558     int save_alt_which = term->alt_which;\r
1559 \r
1560     if (newrows == term->rows && newcols == term->cols &&\r
1561         newsavelines == term->savelines)\r
1562         return;                        /* nothing to do */\r
1563 \r
1564     /* Behave sensibly if we're given zero (or negative) rows/cols */\r
1565 \r
1566     if (newrows < 1) newrows = 1;\r
1567     if (newcols < 1) newcols = 1;\r
1568 \r
1569     deselect(term);\r
1570     swap_screen(term, 0, FALSE, FALSE);\r
1571 \r
1572     term->alt_t = term->marg_t = 0;\r
1573     term->alt_b = term->marg_b = newrows - 1;\r
1574 \r
1575     if (term->rows == -1) {\r
1576         term->scrollback = newtree234(NULL);\r
1577         term->screen = newtree234(NULL);\r
1578         term->tempsblines = 0;\r
1579         term->rows = 0;\r
1580     }\r
1581 \r
1582     /*\r
1583      * Resize the screen and scrollback. We only need to shift\r
1584      * lines around within our data structures, because lineptr()\r
1585      * will take care of resizing each individual line if\r
1586      * necessary. So:\r
1587      * \r
1588      *  - If the new screen is longer, we shunt lines in from temporary\r
1589      *    scrollback if possible, otherwise we add new blank lines at\r
1590      *    the bottom.\r
1591      *\r
1592      *  - If the new screen is shorter, we remove any blank lines at\r
1593      *    the bottom if possible, otherwise shunt lines above the cursor\r
1594      *    to scrollback if possible, otherwise delete lines below the\r
1595      *    cursor.\r
1596      * \r
1597      *  - Then, if the new scrollback length is less than the\r
1598      *    amount of scrollback we actually have, we must throw some\r
1599      *    away.\r
1600      */\r
1601     sblen = count234(term->scrollback);\r
1602     /* Do this loop to expand the screen if newrows > rows */\r
1603     assert(term->rows == count234(term->screen));\r
1604     while (term->rows < newrows) {\r
1605         if (term->tempsblines > 0) {\r
1606             unsigned char *cline;\r
1607             /* Insert a line from the scrollback at the top of the screen. */\r
1608             assert(sblen >= term->tempsblines);\r
1609             cline = delpos234(term->scrollback, --sblen);\r
1610             line = decompressline(cline, NULL);\r
1611             sfree(cline);\r
1612             line->temporary = FALSE;   /* reconstituted line is now real */\r
1613             term->tempsblines -= 1;\r
1614             addpos234(term->screen, line, 0);\r
1615             term->curs.y += 1;\r
1616             term->savecurs.y += 1;\r
1617             term->alt_y += 1;\r
1618             term->alt_savecurs.y += 1;\r
1619         } else {\r
1620             /* Add a new blank line at the bottom of the screen. */\r
1621             line = newline(term, newcols, FALSE);\r
1622             addpos234(term->screen, line, count234(term->screen));\r
1623         }\r
1624         term->rows += 1;\r
1625     }\r
1626     /* Do this loop to shrink the screen if newrows < rows */\r
1627     while (term->rows > newrows) {\r
1628         if (term->curs.y < term->rows - 1) {\r
1629             /* delete bottom row, unless it contains the cursor */\r
1630             sfree(delpos234(term->screen, term->rows - 1));\r
1631         } else {\r
1632             /* push top row to scrollback */\r
1633             line = delpos234(term->screen, 0);\r
1634             addpos234(term->scrollback, compressline(line), sblen++);\r
1635             freeline(line);\r
1636             term->tempsblines += 1;\r
1637             term->curs.y -= 1;\r
1638             term->savecurs.y -= 1;\r
1639             term->alt_y -= 1;\r
1640             term->alt_savecurs.y -= 1;\r
1641         }\r
1642         term->rows -= 1;\r
1643     }\r
1644     assert(term->rows == newrows);\r
1645     assert(count234(term->screen) == newrows);\r
1646 \r
1647     /* Delete any excess lines from the scrollback. */\r
1648     while (sblen > newsavelines) {\r
1649         line = delpos234(term->scrollback, 0);\r
1650         sfree(line);\r
1651         sblen--;\r
1652     }\r
1653     if (sblen < term->tempsblines)\r
1654         term->tempsblines = sblen;\r
1655     assert(count234(term->scrollback) <= newsavelines);\r
1656     assert(count234(term->scrollback) >= term->tempsblines);\r
1657     term->disptop = 0;\r
1658 \r
1659     /* Make a new displayed text buffer. */\r
1660     newdisp = snewn(newrows, termline *);\r
1661     for (i = 0; i < newrows; i++) {\r
1662         newdisp[i] = newline(term, newcols, FALSE);\r
1663         for (j = 0; j < newcols; j++)\r
1664             newdisp[i]->chars[j].attr = ATTR_INVALID;\r
1665     }\r
1666     if (term->disptext) {\r
1667         for (i = 0; i < oldrows; i++)\r
1668             freeline(term->disptext[i]);\r
1669     }\r
1670     sfree(term->disptext);\r
1671     term->disptext = newdisp;\r
1672     term->dispcursx = term->dispcursy = -1;\r
1673 \r
1674     /* Make a new alternate screen. */\r
1675     newalt = newtree234(NULL);\r
1676     for (i = 0; i < newrows; i++) {\r
1677         line = newline(term, newcols, TRUE);\r
1678         addpos234(newalt, line, i);\r
1679     }\r
1680     if (term->alt_screen) {\r
1681         while (NULL != (line = delpos234(term->alt_screen, 0)))\r
1682             freeline(line);\r
1683         freetree234(term->alt_screen);\r
1684     }\r
1685     term->alt_screen = newalt;\r
1686     term->alt_sblines = 0;\r
1687 \r
1688     term->tabs = sresize(term->tabs, newcols, unsigned char);\r
1689     {\r
1690         int i;\r
1691         for (i = (term->cols > 0 ? term->cols : 0); i < newcols; i++)\r
1692             term->tabs[i] = (i % 8 == 0 ? TRUE : FALSE);\r
1693     }\r
1694 \r
1695     /* Check that the cursor positions are still valid. */\r
1696     if (term->savecurs.y < 0)\r
1697         term->savecurs.y = 0;\r
1698     if (term->savecurs.y >= newrows)\r
1699         term->savecurs.y = newrows - 1;\r
1700     if (term->savecurs.x >= newcols)\r
1701         term->savecurs.x = newcols - 1;\r
1702     if (term->alt_savecurs.y < 0)\r
1703         term->alt_savecurs.y = 0;\r
1704     if (term->alt_savecurs.y >= newrows)\r
1705         term->alt_savecurs.y = newrows - 1;\r
1706     if (term->alt_savecurs.x >= newcols)\r
1707         term->alt_savecurs.x = newcols - 1;\r
1708     if (term->curs.y < 0)\r
1709         term->curs.y = 0;\r
1710     if (term->curs.y >= newrows)\r
1711         term->curs.y = newrows - 1;\r
1712     if (term->curs.x >= newcols)\r
1713         term->curs.x = newcols - 1;\r
1714     if (term->alt_y < 0)\r
1715         term->alt_y = 0;\r
1716     if (term->alt_y >= newrows)\r
1717         term->alt_y = newrows - 1;\r
1718     if (term->alt_x >= newcols)\r
1719         term->alt_x = newcols - 1;\r
1720     term->alt_x = term->alt_y = 0;\r
1721     term->wrapnext = term->alt_wnext = FALSE;\r
1722 \r
1723     term->rows = newrows;\r
1724     term->cols = newcols;\r
1725     term->savelines = newsavelines;\r
1726 \r
1727     swap_screen(term, save_alt_which, FALSE, FALSE);\r
1728 \r
1729     update_sbar(term);\r
1730     term_update(term);\r
1731     if (term->resize_fn)\r
1732         term->resize_fn(term->resize_ctx, term->cols, term->rows);\r
1733 }\r
1734 \r
1735 /*\r
1736  * Hand a function and context pointer to the terminal which it can\r
1737  * use to notify a back end of resizes.\r
1738  */\r
1739 void term_provide_resize_fn(Terminal *term,\r
1740                             void (*resize_fn)(void *, int, int),\r
1741                             void *resize_ctx)\r
1742 {\r
1743     term->resize_fn = resize_fn;\r
1744     term->resize_ctx = resize_ctx;\r
1745     if (resize_fn && term->cols > 0 && term->rows > 0)\r
1746         resize_fn(resize_ctx, term->cols, term->rows);\r
1747 }\r
1748 \r
1749 /* Find the bottom line on the screen that has any content.\r
1750  * If only the top line has content, returns 0.\r
1751  * If no lines have content, return -1.\r
1752  */ \r
1753 static int find_last_nonempty_line(Terminal * term, tree234 * screen)\r
1754 {\r
1755     int i;\r
1756     for (i = count234(screen) - 1; i >= 0; i--) {\r
1757         termline *line = index234(screen, i);\r
1758         int j;\r
1759         for (j = 0; j < line->cols; j++)\r
1760             if (!termchars_equal(&line->chars[j], &term->erase_char))\r
1761                 break;\r
1762         if (j != line->cols) break;\r
1763     }\r
1764     return i;\r
1765 }\r
1766 \r
1767 /*\r
1768  * Swap screens. If `reset' is TRUE and we have been asked to\r
1769  * switch to the alternate screen, we must bring most of its\r
1770  * configuration from the main screen and erase the contents of the\r
1771  * alternate screen completely. (This is even true if we're already\r
1772  * on it! Blame xterm.)\r
1773  */\r
1774 static void swap_screen(Terminal *term, int which, int reset, int keep_cur_pos)\r
1775 {\r
1776     int t;\r
1777     pos tp;\r
1778     tree234 *ttr;\r
1779 \r
1780     if (!which)\r
1781         reset = FALSE;                 /* do no weird resetting if which==0 */\r
1782 \r
1783     if (which != term->alt_which) {\r
1784         term->alt_which = which;\r
1785 \r
1786         ttr = term->alt_screen;\r
1787         term->alt_screen = term->screen;\r
1788         term->screen = ttr;\r
1789         term->alt_sblines = find_last_nonempty_line(term, term->alt_screen) + 1;\r
1790         t = term->curs.x;\r
1791         if (!reset && !keep_cur_pos)\r
1792             term->curs.x = term->alt_x;\r
1793         term->alt_x = t;\r
1794         t = term->curs.y;\r
1795         if (!reset && !keep_cur_pos)\r
1796             term->curs.y = term->alt_y;\r
1797         term->alt_y = t;\r
1798         t = term->marg_t;\r
1799         if (!reset) term->marg_t = term->alt_t;\r
1800         term->alt_t = t;\r
1801         t = term->marg_b;\r
1802         if (!reset) term->marg_b = term->alt_b;\r
1803         term->alt_b = t;\r
1804         t = term->dec_om;\r
1805         if (!reset) term->dec_om = term->alt_om;\r
1806         term->alt_om = t;\r
1807         t = term->wrap;\r
1808         if (!reset) term->wrap = term->alt_wrap;\r
1809         term->alt_wrap = t;\r
1810         t = term->wrapnext;\r
1811         if (!reset) term->wrapnext = term->alt_wnext;\r
1812         term->alt_wnext = t;\r
1813         t = term->insert;\r
1814         if (!reset) term->insert = term->alt_ins;\r
1815         term->alt_ins = t;\r
1816         t = term->cset;\r
1817         if (!reset) term->cset = term->alt_cset;\r
1818         term->alt_cset = t;\r
1819         t = term->utf;\r
1820         if (!reset) term->utf = term->alt_utf;\r
1821         term->alt_utf = t;\r
1822         t = term->sco_acs;\r
1823         if (!reset) term->sco_acs = term->alt_sco_acs;\r
1824         term->alt_sco_acs = t;\r
1825 \r
1826         tp = term->savecurs;\r
1827         if (!reset && !keep_cur_pos)\r
1828             term->savecurs = term->alt_savecurs;\r
1829         term->alt_savecurs = tp;\r
1830         t = term->save_cset;\r
1831         if (!reset && !keep_cur_pos)\r
1832             term->save_cset = term->alt_save_cset;\r
1833         term->alt_save_cset = t;\r
1834         t = term->save_csattr;\r
1835         if (!reset && !keep_cur_pos)\r
1836             term->save_csattr = term->alt_save_csattr;\r
1837         term->alt_save_csattr = t;\r
1838         t = term->save_attr;\r
1839         if (!reset && !keep_cur_pos)\r
1840             term->save_attr = term->alt_save_attr;\r
1841         term->alt_save_attr = t;\r
1842         t = term->save_utf;\r
1843         if (!reset && !keep_cur_pos)\r
1844             term->save_utf = term->alt_save_utf;\r
1845         term->alt_save_utf = t;\r
1846         t = term->save_wnext;\r
1847         if (!reset && !keep_cur_pos)\r
1848             term->save_wnext = term->alt_save_wnext;\r
1849         term->alt_save_wnext = t;\r
1850         t = term->save_sco_acs;\r
1851         if (!reset && !keep_cur_pos)\r
1852             term->save_sco_acs = term->alt_save_sco_acs;\r
1853         term->alt_save_sco_acs = t;\r
1854     }\r
1855 \r
1856     if (reset && term->screen) {\r
1857         /*\r
1858          * Yes, this _is_ supposed to honour background-colour-erase.\r
1859          */\r
1860         erase_lots(term, FALSE, TRUE, TRUE);\r
1861     }\r
1862 }\r
1863 \r
1864 /*\r
1865  * Update the scroll bar.\r
1866  */\r
1867 static void update_sbar(Terminal *term)\r
1868 {\r
1869     int nscroll = sblines(term);\r
1870     set_sbar(term->frontend, nscroll + term->rows,\r
1871              nscroll + term->disptop, term->rows);\r
1872 }\r
1873 \r
1874 /*\r
1875  * Check whether the region bounded by the two pointers intersects\r
1876  * the scroll region, and de-select the on-screen selection if so.\r
1877  */\r
1878 static void check_selection(Terminal *term, pos from, pos to)\r
1879 {\r
1880     if (poslt(from, term->selend) && poslt(term->selstart, to))\r
1881         deselect(term);\r
1882 }\r
1883 \r
1884 /*\r
1885  * Scroll the screen. (`lines' is +ve for scrolling forward, -ve\r
1886  * for backward.) `sb' is TRUE if the scrolling is permitted to\r
1887  * affect the scrollback buffer.\r
1888  */\r
1889 static void scroll(Terminal *term, int topline, int botline, int lines, int sb)\r
1890 {\r
1891     termline *line;\r
1892     int i, seltop;\r
1893 #ifdef OPTIMISE_SCROLL\r
1894     int olddisptop, shift;\r
1895 #endif /* OPTIMISE_SCROLL */\r
1896 \r
1897     if (topline != 0 || term->alt_which != 0)\r
1898         sb = FALSE;\r
1899 \r
1900 #ifdef OPTIMISE_SCROLL\r
1901     olddisptop = term->disptop;\r
1902     shift = lines;\r
1903 #endif /* OPTIMISE_SCROLL */\r
1904     if (lines < 0) {\r
1905         while (lines < 0) {\r
1906             line = delpos234(term->screen, botline);\r
1907             resizeline(term, line, term->cols);\r
1908             for (i = 0; i < term->cols; i++)\r
1909                 copy_termchar(line, i, &term->erase_char);\r
1910             line->lattr = LATTR_NORM;\r
1911             addpos234(term->screen, line, topline);\r
1912 \r
1913             if (term->selstart.y >= topline && term->selstart.y <= botline) {\r
1914                 term->selstart.y++;\r
1915                 if (term->selstart.y > botline) {\r
1916                     term->selstart.y = botline + 1;\r
1917                     term->selstart.x = 0;\r
1918                 }\r
1919             }\r
1920             if (term->selend.y >= topline && term->selend.y <= botline) {\r
1921                 term->selend.y++;\r
1922                 if (term->selend.y > botline) {\r
1923                     term->selend.y = botline + 1;\r
1924                     term->selend.x = 0;\r
1925                 }\r
1926             }\r
1927 \r
1928             lines++;\r
1929         }\r
1930     } else {\r
1931         while (lines > 0) {\r
1932             line = delpos234(term->screen, topline);\r
1933 #ifdef TERM_CC_DIAGS\r
1934             cc_check(line);\r
1935 #endif\r
1936             if (sb && term->savelines > 0) {\r
1937                 int sblen = count234(term->scrollback);\r
1938                 /*\r
1939                  * We must add this line to the scrollback. We'll\r
1940                  * remove a line from the top of the scrollback if\r
1941                  * the scrollback is full.\r
1942                  */\r
1943                 if (sblen == term->savelines) {\r
1944                     unsigned char *cline;\r
1945 \r
1946                     sblen--;\r
1947                     cline = delpos234(term->scrollback, 0);\r
1948                     sfree(cline);\r
1949                 } else\r
1950                     term->tempsblines += 1;\r
1951 \r
1952                 addpos234(term->scrollback, compressline(line), sblen);\r
1953 \r
1954                 /* now `line' itself can be reused as the bottom line */\r
1955 \r
1956                 /*\r
1957                  * If the user is currently looking at part of the\r
1958                  * scrollback, and they haven't enabled any options\r
1959                  * that are going to reset the scrollback as a\r
1960                  * result of this movement, then the chances are\r
1961                  * they'd like to keep looking at the same line. So\r
1962                  * we move their viewpoint at the same rate as the\r
1963                  * scroll, at least until their viewpoint hits the\r
1964                  * top end of the scrollback buffer, at which point\r
1965                  * we don't have the choice any more.\r
1966                  * \r
1967                  * Thanks to Jan Holmen Holsten for the idea and\r
1968                  * initial implementation.\r
1969                  */\r
1970                 if (term->disptop > -term->savelines && term->disptop < 0)\r
1971                     term->disptop--;\r
1972             }\r
1973             resizeline(term, line, term->cols);\r
1974             for (i = 0; i < term->cols; i++)\r
1975                 copy_termchar(line, i, &term->erase_char);\r
1976             line->lattr = LATTR_NORM;\r
1977             addpos234(term->screen, line, botline);\r
1978 \r
1979             /*\r
1980              * If the selection endpoints move into the scrollback,\r
1981              * we keep them moving until they hit the top. However,\r
1982              * of course, if the line _hasn't_ moved into the\r
1983              * scrollback then we don't do this, and cut them off\r
1984              * at the top of the scroll region.\r
1985              * \r
1986              * This applies to selstart and selend (for an existing\r
1987              * selection), and also selanchor (for one being\r
1988              * selected as we speak).\r
1989              */\r
1990             seltop = sb ? -term->savelines : topline;\r
1991 \r
1992             if (term->selstate != NO_SELECTION) {\r
1993                 if (term->selstart.y >= seltop &&\r
1994                     term->selstart.y <= botline) {\r
1995                     term->selstart.y--;\r
1996                     if (term->selstart.y < seltop) {\r
1997                         term->selstart.y = seltop;\r
1998                         term->selstart.x = 0;\r
1999                     }\r
2000                 }\r
2001                 if (term->selend.y >= seltop && term->selend.y <= botline) {\r
2002                     term->selend.y--;\r
2003                     if (term->selend.y < seltop) {\r
2004                         term->selend.y = seltop;\r
2005                         term->selend.x = 0;\r
2006                     }\r
2007                 }\r
2008                 if (term->selanchor.y >= seltop &&\r
2009                     term->selanchor.y <= botline) {\r
2010                     term->selanchor.y--;\r
2011                     if (term->selanchor.y < seltop) {\r
2012                         term->selanchor.y = seltop;\r
2013                         term->selanchor.x = 0;\r
2014                     }\r
2015                 }\r
2016             }\r
2017 \r
2018             lines--;\r
2019         }\r
2020     }\r
2021 #ifdef OPTIMISE_SCROLL\r
2022     shift += term->disptop - olddisptop;\r
2023     if (shift < term->rows && shift > -term->rows && shift != 0)\r
2024         scroll_display(term, topline, botline, shift);\r
2025 #endif /* OPTIMISE_SCROLL */\r
2026 }\r
2027 \r
2028 #ifdef OPTIMISE_SCROLL\r
2029 /*\r
2030  * Add a scroll of a region on the screen into the pending scroll list.\r
2031  * `lines' is +ve for scrolling forward, -ve for backward.\r
2032  *\r
2033  * If the scroll is on the same area as the last scroll in the list,\r
2034  * merge them.\r
2035  */\r
2036 static void save_scroll(Terminal *term, int topline, int botline, int lines)\r
2037 {\r
2038     struct scrollregion *newscroll;\r
2039     if (term->scrolltail &&\r
2040         term->scrolltail->topline == topline && \r
2041         term->scrolltail->botline == botline) {\r
2042         term->scrolltail->lines += lines;\r
2043     } else {\r
2044         newscroll = snew(struct scrollregion);\r
2045         newscroll->topline = topline;\r
2046         newscroll->botline = botline;\r
2047         newscroll->lines = lines;\r
2048         newscroll->next = NULL;\r
2049 \r
2050         if (!term->scrollhead)\r
2051             term->scrollhead = newscroll;\r
2052         else\r
2053             term->scrolltail->next = newscroll;\r
2054         term->scrolltail = newscroll;\r
2055     }\r
2056 }\r
2057 \r
2058 /*\r
2059  * Scroll the physical display, and our conception of it in disptext.\r
2060  */\r
2061 static void scroll_display(Terminal *term, int topline, int botline, int lines)\r
2062 {\r
2063     int distance, nlines, i, j;\r
2064 \r
2065     distance = lines > 0 ? lines : -lines;\r
2066     nlines = botline - topline + 1 - distance;\r
2067     if (lines > 0) {\r
2068         for (i = 0; i < nlines; i++)\r
2069             for (j = 0; j < term->cols; j++)\r
2070                 copy_termchar(term->disptext[i], j,\r
2071                               term->disptext[i+distance]->chars+j);\r
2072         if (term->dispcursy >= 0 &&\r
2073             term->dispcursy >= topline + distance &&\r
2074             term->dispcursy < topline + distance + nlines)\r
2075             term->dispcursy -= distance;\r
2076         for (i = 0; i < distance; i++)\r
2077             for (j = 0; j < term->cols; j++)\r
2078                 term->disptext[nlines+i]->chars[j].attr |= ATTR_INVALID;\r
2079     } else {\r
2080         for (i = nlines; i-- ;)\r
2081             for (j = 0; j < term->cols; j++)\r
2082                 copy_termchar(term->disptext[i+distance], j,\r
2083                               term->disptext[i]->chars+j);\r
2084         if (term->dispcursy >= 0 &&\r
2085             term->dispcursy >= topline &&\r
2086             term->dispcursy < topline + nlines)\r
2087             term->dispcursy += distance;\r
2088         for (i = 0; i < distance; i++)\r
2089             for (j = 0; j < term->cols; j++)\r
2090                 term->disptext[i]->chars[j].attr |= ATTR_INVALID;\r
2091     }\r
2092     save_scroll(term, topline, botline, lines);\r
2093 }\r
2094 #endif /* OPTIMISE_SCROLL */\r
2095 \r
2096 /*\r
2097  * Move the cursor to a given position, clipping at boundaries. We\r
2098  * may or may not want to clip at the scroll margin: marg_clip is 0\r
2099  * not to, 1 to disallow _passing_ the margins, and 2 to disallow\r
2100  * even _being_ outside the margins.\r
2101  */\r
2102 static void move(Terminal *term, int x, int y, int marg_clip)\r
2103 {\r
2104     if (x < 0)\r
2105         x = 0;\r
2106     if (x >= term->cols)\r
2107         x = term->cols - 1;\r
2108     if (marg_clip) {\r
2109         if ((term->curs.y >= term->marg_t || marg_clip == 2) &&\r
2110             y < term->marg_t)\r
2111             y = term->marg_t;\r
2112         if ((term->curs.y <= term->marg_b || marg_clip == 2) &&\r
2113             y > term->marg_b)\r
2114             y = term->marg_b;\r
2115     }\r
2116     if (y < 0)\r
2117         y = 0;\r
2118     if (y >= term->rows)\r
2119         y = term->rows - 1;\r
2120     term->curs.x = x;\r
2121     term->curs.y = y;\r
2122     term->wrapnext = FALSE;\r
2123 }\r
2124 \r
2125 /*\r
2126  * Save or restore the cursor and SGR mode.\r
2127  */\r
2128 static void save_cursor(Terminal *term, int save)\r
2129 {\r
2130     if (save) {\r
2131         term->savecurs = term->curs;\r
2132         term->save_attr = term->curr_attr;\r
2133         term->save_cset = term->cset;\r
2134         term->save_utf = term->utf;\r
2135         term->save_wnext = term->wrapnext;\r
2136         term->save_csattr = term->cset_attr[term->cset];\r
2137         term->save_sco_acs = term->sco_acs;\r
2138     } else {\r
2139         term->curs = term->savecurs;\r
2140         /* Make sure the window hasn't shrunk since the save */\r
2141         if (term->curs.x >= term->cols)\r
2142             term->curs.x = term->cols - 1;\r
2143         if (term->curs.y >= term->rows)\r
2144             term->curs.y = term->rows - 1;\r
2145 \r
2146         term->curr_attr = term->save_attr;\r
2147         term->cset = term->save_cset;\r
2148         term->utf = term->save_utf;\r
2149         term->wrapnext = term->save_wnext;\r
2150         /*\r
2151          * wrapnext might reset to False if the x position is no\r
2152          * longer at the rightmost edge.\r
2153          */\r
2154         if (term->wrapnext && term->curs.x < term->cols-1)\r
2155             term->wrapnext = FALSE;\r
2156         term->cset_attr[term->cset] = term->save_csattr;\r
2157         term->sco_acs = term->save_sco_acs;\r
2158         set_erase_char(term);\r
2159     }\r
2160 }\r
2161 \r
2162 /*\r
2163  * This function is called before doing _anything_ which affects\r
2164  * only part of a line of text. It is used to mark the boundary\r
2165  * between two character positions, and it indicates that some sort\r
2166  * of effect is going to happen on only one side of that boundary.\r
2167  * \r
2168  * The effect of this function is to check whether a CJK\r
2169  * double-width character is straddling the boundary, and to remove\r
2170  * it and replace it with two spaces if so. (Of course, one or\r
2171  * other of those spaces is then likely to be replaced with\r
2172  * something else again, as a result of whatever happens next.)\r
2173  * \r
2174  * Also, if the boundary is at the right-hand _edge_ of the screen,\r
2175  * it implies something deliberate is being done to the rightmost\r
2176  * column position; hence we must clear LATTR_WRAPPED2.\r
2177  * \r
2178  * The input to the function is the coordinates of the _second_\r
2179  * character of the pair.\r
2180  */\r
2181 static void check_boundary(Terminal *term, int x, int y)\r
2182 {\r
2183     termline *ldata;\r
2184 \r
2185     /* Validate input coordinates, just in case. */\r
2186     if (x == 0 || x > term->cols)\r
2187         return;\r
2188 \r
2189     ldata = scrlineptr(y);\r
2190     if (x == term->cols) {\r
2191         ldata->lattr &= ~LATTR_WRAPPED2;\r
2192     } else {\r
2193         if (ldata->chars[x].chr == UCSWIDE) {\r
2194             clear_cc(ldata, x-1);\r
2195             clear_cc(ldata, x);\r
2196             ldata->chars[x-1].chr = ' ' | CSET_ASCII;\r
2197             ldata->chars[x] = ldata->chars[x-1];\r
2198         }\r
2199     }\r
2200 }\r
2201 \r
2202 /*\r
2203  * Erase a large portion of the screen: the whole screen, or the\r
2204  * whole line, or parts thereof.\r
2205  */\r
2206 static void erase_lots(Terminal *term,\r
2207                        int line_only, int from_begin, int to_end)\r
2208 {\r
2209     pos start, end;\r
2210     int erase_lattr;\r
2211     int erasing_lines_from_top = 0;\r
2212 \r
2213     if (line_only) {\r
2214         start.y = term->curs.y;\r
2215         start.x = 0;\r
2216         end.y = term->curs.y + 1;\r
2217         end.x = 0;\r
2218         erase_lattr = FALSE;\r
2219     } else {\r
2220         start.y = 0;\r
2221         start.x = 0;\r
2222         end.y = term->rows;\r
2223         end.x = 0;\r
2224         erase_lattr = TRUE;\r
2225     }\r
2226     if (!from_begin) {\r
2227         start = term->curs;\r
2228     }\r
2229     if (!to_end) {\r
2230         end = term->curs;\r
2231         incpos(end);\r
2232     }\r
2233     if (!from_begin || !to_end)\r
2234         check_boundary(term, term->curs.x, term->curs.y);\r
2235     check_selection(term, start, end);\r
2236 \r
2237     /* Clear screen also forces a full window redraw, just in case. */\r
2238     if (start.y == 0 && start.x == 0 && end.y == term->rows)\r
2239         term_invalidate(term);\r
2240 \r
2241     /* Lines scrolled away shouldn't be brought back on if the terminal\r
2242      * resizes. */\r
2243     if (start.y == 0 && start.x == 0 && end.x == 0 && erase_lattr)\r
2244         erasing_lines_from_top = 1;\r
2245 \r
2246     if (term->cfg.erase_to_scrollback && erasing_lines_from_top) {\r
2247         /* If it's a whole number of lines, starting at the top, and\r
2248          * we're fully erasing them, erase by scrolling and keep the\r
2249          * lines in the scrollback. */\r
2250         int scrolllines = end.y;\r
2251         if (end.y == term->rows) {\r
2252             /* Shrink until we find a non-empty row.*/\r
2253             scrolllines = find_last_nonempty_line(term, term->screen) + 1;\r
2254         }\r
2255         if (scrolllines > 0)\r
2256             scroll(term, 0, scrolllines - 1, scrolllines, TRUE);\r
2257     } else {\r
2258         termline *ldata = scrlineptr(start.y);\r
2259         while (poslt(start, end)) {\r
2260             if (start.x == term->cols) {\r
2261                 if (!erase_lattr)\r
2262                     ldata->lattr &= ~(LATTR_WRAPPED | LATTR_WRAPPED2);\r
2263                 else\r
2264                     ldata->lattr = LATTR_NORM;\r
2265             } else {\r
2266                 copy_termchar(ldata, start.x, &term->erase_char);\r
2267             }\r
2268             if (incpos(start) && start.y < term->rows) {\r
2269                 ldata = scrlineptr(start.y);\r
2270             }\r
2271         }\r
2272     }\r
2273 \r
2274     /* After an erase of lines from the top of the screen, we shouldn't\r
2275      * bring the lines back again if the terminal enlarges (since the user or\r
2276      * application has explictly thrown them away). */\r
2277     if (erasing_lines_from_top && !(term->alt_which))\r
2278         term->tempsblines = 0;\r
2279 }\r
2280 \r
2281 /*\r
2282  * Insert or delete characters within the current line. n is +ve if\r
2283  * insertion is desired, and -ve for deletion.\r
2284  */\r
2285 static void insch(Terminal *term, int n)\r
2286 {\r
2287     int dir = (n < 0 ? -1 : +1);\r
2288     int m, j;\r
2289     pos cursplus;\r
2290     termline *ldata;\r
2291 \r
2292     n = (n < 0 ? -n : n);\r
2293     if (n > term->cols - term->curs.x)\r
2294         n = term->cols - term->curs.x;\r
2295     m = term->cols - term->curs.x - n;\r
2296     cursplus.y = term->curs.y;\r
2297     cursplus.x = term->curs.x + n;\r
2298     check_selection(term, term->curs, cursplus);\r
2299     check_boundary(term, term->curs.x, term->curs.y);\r
2300     if (dir < 0)\r
2301         check_boundary(term, term->curs.x + n, term->curs.y);\r
2302     ldata = scrlineptr(term->curs.y);\r
2303     if (dir < 0) {\r
2304         for (j = 0; j < m; j++)\r
2305             move_termchar(ldata,\r
2306                           ldata->chars + term->curs.x + j,\r
2307                           ldata->chars + term->curs.x + j + n);\r
2308         while (n--)\r
2309             copy_termchar(ldata, term->curs.x + m++, &term->erase_char);\r
2310     } else {\r
2311         for (j = m; j-- ;)\r
2312             move_termchar(ldata,\r
2313                           ldata->chars + term->curs.x + j + n,\r
2314                           ldata->chars + term->curs.x + j);\r
2315         while (n--)\r
2316             copy_termchar(ldata, term->curs.x + n, &term->erase_char);\r
2317     }\r
2318 }\r
2319 \r
2320 /*\r
2321  * Toggle terminal mode `mode' to state `state'. (`query' indicates\r
2322  * whether the mode is a DEC private one or a normal one.)\r
2323  */\r
2324 static void toggle_mode(Terminal *term, int mode, int query, int state)\r
2325 {\r
2326     if (query)\r
2327         switch (mode) {\r
2328           case 1:                      /* DECCKM: application cursor keys */\r
2329             term->app_cursor_keys = state;\r
2330             break;\r
2331           case 2:                      /* DECANM: VT52 mode */\r
2332             term->vt52_mode = !state;\r
2333             if (term->vt52_mode) {\r
2334                 term->blink_is_real = FALSE;\r
2335                 term->vt52_bold = FALSE;\r
2336             } else {\r
2337                 term->blink_is_real = term->cfg.blinktext;\r
2338             }\r
2339             term_schedule_tblink(term);\r
2340             break;\r
2341           case 3:                      /* DECCOLM: 80/132 columns */\r
2342             deselect(term);\r
2343             if (!term->cfg.no_remote_resize)\r
2344                 request_resize(term->frontend, state ? 132 : 80, term->rows);\r
2345             term->reset_132 = state;\r
2346             term->alt_t = term->marg_t = 0;\r
2347             term->alt_b = term->marg_b = term->rows - 1;\r
2348             move(term, 0, 0, 0);\r
2349             erase_lots(term, FALSE, TRUE, TRUE);\r
2350             break;\r
2351           case 5:                      /* DECSCNM: reverse video */\r
2352             /*\r
2353              * Toggle reverse video. If we receive an OFF within the\r
2354              * visual bell timeout period after an ON, we trigger an\r
2355              * effective visual bell, so that ESC[?5hESC[?5l will\r
2356              * always be an actually _visible_ visual bell.\r
2357              */\r
2358             if (term->rvideo && !state) {\r
2359                 /* This is an OFF, so set up a vbell */\r
2360                 term_schedule_vbell(term, TRUE, term->rvbell_startpoint);\r
2361             } else if (!term->rvideo && state) {\r
2362                 /* This is an ON, so we notice the time and save it. */\r
2363                 term->rvbell_startpoint = GETTICKCOUNT();\r
2364             }\r
2365             term->rvideo = state;\r
2366             seen_disp_event(term);\r
2367             break;\r
2368           case 6:                      /* DECOM: DEC origin mode */\r
2369             term->dec_om = state;\r
2370             break;\r
2371           case 7:                      /* DECAWM: auto wrap */\r
2372             term->wrap = state;\r
2373             break;\r
2374           case 8:                      /* DECARM: auto key repeat */\r
2375             term->repeat_off = !state;\r
2376             break;\r
2377           case 10:                     /* DECEDM: set local edit mode */\r
2378             term->term_editing = state;\r
2379             if (term->ldisc)           /* cause ldisc to notice changes */\r
2380                 ldisc_send(term->ldisc, NULL, 0, 0);\r
2381             break;\r
2382           case 25:                     /* DECTCEM: enable/disable cursor */\r
2383             compatibility2(OTHER, VT220);\r
2384             term->cursor_on = state;\r
2385             seen_disp_event(term);\r
2386             break;\r
2387           case 47:                     /* alternate screen */\r
2388             compatibility(OTHER);\r
2389             deselect(term);\r
2390             swap_screen(term, term->cfg.no_alt_screen ? 0 : state, FALSE, FALSE);\r
2391             term->disptop = 0;\r
2392             break;\r
2393           case 1000:                   /* xterm mouse 1 (normal) */\r
2394             term->xterm_mouse = state ? 1 : 0;\r
2395             set_raw_mouse_mode(term->frontend, state);\r
2396             break;\r
2397           case 1002:                   /* xterm mouse 2 (inc. button drags) */\r
2398             term->xterm_mouse = state ? 2 : 0;\r
2399             set_raw_mouse_mode(term->frontend, state);\r
2400             break;\r
2401           case 1047:                   /* alternate screen */\r
2402             compatibility(OTHER);\r
2403             deselect(term);\r
2404             swap_screen(term, term->cfg.no_alt_screen ? 0 : state, TRUE, TRUE);\r
2405             term->disptop = 0;\r
2406             break;\r
2407           case 1048:                   /* save/restore cursor */\r
2408             if (!term->cfg.no_alt_screen)\r
2409                 save_cursor(term, state);\r
2410             if (!state) seen_disp_event(term);\r
2411             break;\r
2412           case 1049:                   /* cursor & alternate screen */\r
2413             if (state && !term->cfg.no_alt_screen)\r
2414                 save_cursor(term, state);\r
2415             if (!state) seen_disp_event(term);\r
2416             compatibility(OTHER);\r
2417             deselect(term);\r
2418             swap_screen(term, term->cfg.no_alt_screen ? 0 : state, TRUE, FALSE);\r
2419             if (!state && !term->cfg.no_alt_screen)\r
2420                 save_cursor(term, state);\r
2421             term->disptop = 0;\r
2422             break;\r
2423     } else\r
2424         switch (mode) {\r
2425           case 4:                      /* IRM: set insert mode */\r
2426             compatibility(VT102);\r
2427             term->insert = state;\r
2428             break;\r
2429           case 12:                     /* SRM: set echo mode */\r
2430             term->term_echoing = !state;\r
2431             if (term->ldisc)           /* cause ldisc to notice changes */\r
2432                 ldisc_send(term->ldisc, NULL, 0, 0);\r
2433             break;\r
2434           case 20:                     /* LNM: Return sends ... */\r
2435             term->cr_lf_return = state;\r
2436             break;\r
2437           case 34:                     /* WYULCURM: Make cursor BIG */\r
2438             compatibility2(OTHER, VT220);\r
2439             term->big_cursor = !state;\r
2440         }\r
2441 }\r
2442 \r
2443 /*\r
2444  * Process an OSC sequence: set window title or icon name.\r
2445  */\r
2446 static void do_osc(Terminal *term)\r
2447 {\r
2448     if (term->osc_w) {\r
2449         while (term->osc_strlen--)\r
2450             term->wordness[(unsigned char)\r
2451                 term->osc_string[term->osc_strlen]] = term->esc_args[0];\r
2452     } else {\r
2453         term->osc_string[term->osc_strlen] = '\0';\r
2454         switch (term->esc_args[0]) {\r
2455           case 0:\r
2456           case 1:\r
2457             if (!term->cfg.no_remote_wintitle)\r
2458                 set_icon(term->frontend, term->osc_string);\r
2459             if (term->esc_args[0] == 1)\r
2460                 break;\r
2461             /* fall through: parameter 0 means set both */\r
2462           case 2:\r
2463           case 21:\r
2464             if (!term->cfg.no_remote_wintitle)\r
2465                 set_title(term->frontend, term->osc_string);\r
2466             break;\r
2467         }\r
2468     }\r
2469 }\r
2470 \r
2471 /*\r
2472  * ANSI printing routines.\r
2473  */\r
2474 static void term_print_setup(Terminal *term)\r
2475 {\r
2476     bufchain_clear(&term->printer_buf);\r
2477     term->print_job = printer_start_job(term->cfg.printer);\r
2478 }\r
2479 static void term_print_flush(Terminal *term)\r
2480 {\r
2481     void *data;\r
2482     int len;\r
2483     int size;\r
2484     while ((size = bufchain_size(&term->printer_buf)) > 5) {\r
2485         bufchain_prefix(&term->printer_buf, &data, &len);\r
2486         if (len > size-5)\r
2487             len = size-5;\r
2488         printer_job_data(term->print_job, data, len);\r
2489         bufchain_consume(&term->printer_buf, len);\r
2490     }\r
2491 }\r
2492 static void term_print_finish(Terminal *term)\r
2493 {\r
2494     void *data;\r
2495     int len, size;\r
2496     char c;\r
2497 \r
2498     if (!term->printing && !term->only_printing)\r
2499         return;                        /* we need do nothing */\r
2500 \r
2501     term_print_flush(term);\r
2502     while ((size = bufchain_size(&term->printer_buf)) > 0) {\r
2503         bufchain_prefix(&term->printer_buf, &data, &len);\r
2504         c = *(char *)data;\r
2505         if (c == '\033' || c == '\233') {\r
2506             bufchain_consume(&term->printer_buf, size);\r
2507             break;\r
2508         } else {\r
2509             printer_job_data(term->print_job, &c, 1);\r
2510             bufchain_consume(&term->printer_buf, 1);\r
2511         }\r
2512     }\r
2513     printer_finish_job(term->print_job);\r
2514     term->print_job = NULL;\r
2515     term->printing = term->only_printing = FALSE;\r
2516 }\r
2517 \r
2518 /*\r
2519  * Remove everything currently in `inbuf' and stick it up on the\r
2520  * in-memory display. There's a big state machine in here to\r
2521  * process escape sequences...\r
2522  */\r
2523 static void term_out(Terminal *term)\r
2524 {\r
2525     unsigned long c;\r
2526     int unget;\r
2527     unsigned char localbuf[256], *chars;\r
2528     int nchars = 0;\r
2529 \r
2530     unget = -1;\r
2531 \r
2532     chars = NULL;                      /* placate compiler warnings */\r
2533     while (nchars > 0 || unget != -1 || bufchain_size(&term->inbuf) > 0) {\r
2534         if (unget == -1) {\r
2535             if (nchars == 0) {\r
2536                 void *ret;\r
2537                 bufchain_prefix(&term->inbuf, &ret, &nchars);\r
2538                 if (nchars > sizeof(localbuf))\r
2539                     nchars = sizeof(localbuf);\r
2540                 memcpy(localbuf, ret, nchars);\r
2541                 bufchain_consume(&term->inbuf, nchars);\r
2542                 chars = localbuf;\r
2543                 assert(chars != NULL);\r
2544             }\r
2545             c = *chars++;\r
2546             nchars--;\r
2547 \r
2548             /*\r
2549              * Optionally log the session traffic to a file. Useful for\r
2550              * debugging and possibly also useful for actual logging.\r
2551              */\r
2552             if (term->cfg.logtype == LGTYP_DEBUG && term->logctx)\r
2553                 logtraffic(term->logctx, (unsigned char) c, LGTYP_DEBUG);\r
2554         } else {\r
2555             c = unget;\r
2556             unget = -1;\r
2557         }\r
2558 \r
2559         /* Note only VT220+ are 8-bit VT102 is seven bit, it shouldn't even\r
2560          * be able to display 8-bit characters, but I'll let that go 'cause\r
2561          * of i18n.\r
2562          */\r
2563 \r
2564         /*\r
2565          * If we're printing, add the character to the printer\r
2566          * buffer.\r
2567          */\r
2568         if (term->printing) {\r
2569             bufchain_add(&term->printer_buf, &c, 1);\r
2570 \r
2571             /*\r
2572              * If we're in print-only mode, we use a much simpler\r
2573              * state machine designed only to recognise the ESC[4i\r
2574              * termination sequence.\r
2575              */\r
2576             if (term->only_printing) {\r
2577                 if (c == '\033')\r
2578                     term->print_state = 1;\r
2579                 else if (c == (unsigned char)'\233')\r
2580                     term->print_state = 2;\r
2581                 else if (c == '[' && term->print_state == 1)\r
2582                     term->print_state = 2;\r
2583                 else if (c == '4' && term->print_state == 2)\r
2584                     term->print_state = 3;\r
2585                 else if (c == 'i' && term->print_state == 3)\r
2586                     term->print_state = 4;\r
2587                 else\r
2588                     term->print_state = 0;\r
2589                 if (term->print_state == 4) {\r
2590                     term_print_finish(term);\r
2591                 }\r
2592                 continue;\r
2593             }\r
2594         }\r
2595 \r
2596         /* First see about all those translations. */\r
2597         if (term->termstate == TOPLEVEL) {\r
2598             if (in_utf(term))\r
2599                 switch (term->utf_state) {\r
2600                   case 0:\r
2601                     if (c < 0x80) {\r
2602                         /* UTF-8 must be stateless so we ignore iso2022. */\r
2603                         if (term->ucsdata->unitab_ctrl[c] != 0xFF) \r
2604                              c = term->ucsdata->unitab_ctrl[c];\r
2605                         else c = ((unsigned char)c) | CSET_ASCII;\r
2606                         break;\r
2607                     } else if ((c & 0xe0) == 0xc0) {\r
2608                         term->utf_size = term->utf_state = 1;\r
2609                         term->utf_char = (c & 0x1f);\r
2610                     } else if ((c & 0xf0) == 0xe0) {\r
2611                         term->utf_size = term->utf_state = 2;\r
2612                         term->utf_char = (c & 0x0f);\r
2613                     } else if ((c & 0xf8) == 0xf0) {\r
2614                         term->utf_size = term->utf_state = 3;\r
2615                         term->utf_char = (c & 0x07);\r
2616                     } else if ((c & 0xfc) == 0xf8) {\r
2617                         term->utf_size = term->utf_state = 4;\r
2618                         term->utf_char = (c & 0x03);\r
2619                     } else if ((c & 0xfe) == 0xfc) {\r
2620                         term->utf_size = term->utf_state = 5;\r
2621                         term->utf_char = (c & 0x01);\r
2622                     } else {\r
2623                         c = UCSERR;\r
2624                         break;\r
2625                     }\r
2626                     continue;\r
2627                   case 1:\r
2628                   case 2:\r
2629                   case 3:\r
2630                   case 4:\r
2631                   case 5:\r
2632                     if ((c & 0xC0) != 0x80) {\r
2633                         unget = c;\r
2634                         c = UCSERR;\r
2635                         term->utf_state = 0;\r
2636                         break;\r
2637                     }\r
2638                     term->utf_char = (term->utf_char << 6) | (c & 0x3f);\r
2639                     if (--term->utf_state)\r
2640                         continue;\r
2641 \r
2642                     c = term->utf_char;\r
2643 \r
2644                     /* Is somebody trying to be evil! */\r
2645                     if (c < 0x80 ||\r
2646                         (c < 0x800 && term->utf_size >= 2) ||\r
2647                         (c < 0x10000 && term->utf_size >= 3) ||\r
2648                         (c < 0x200000 && term->utf_size >= 4) ||\r
2649                         (c < 0x4000000 && term->utf_size >= 5))\r
2650                         c = UCSERR;\r
2651 \r
2652                     /* Unicode line separator and paragraph separator are CR-LF */\r
2653                     if (c == 0x2028 || c == 0x2029)\r
2654                         c = 0x85;\r
2655 \r
2656                     /* High controls are probably a Baaad idea too. */\r
2657                     if (c < 0xA0)\r
2658                         c = 0xFFFD;\r
2659 \r
2660                     /* The UTF-16 surrogates are not nice either. */\r
2661                     /*       The standard give the option of decoding these: \r
2662                      *       I don't want to! */\r
2663                     if (c >= 0xD800 && c < 0xE000)\r
2664                         c = UCSERR;\r
2665 \r
2666                     /* ISO 10646 characters now limited to UTF-16 range. */\r
2667                     if (c > 0x10FFFF)\r
2668                         c = UCSERR;\r
2669 \r
2670                     /* This is currently a TagPhobic application.. */\r
2671                     if (c >= 0xE0000 && c <= 0xE007F)\r
2672                         continue;\r
2673 \r
2674                     /* U+FEFF is best seen as a null. */\r
2675                     if (c == 0xFEFF)\r
2676                         continue;\r
2677                     /* But U+FFFE is an error. */\r
2678                     if (c == 0xFFFE || c == 0xFFFF)\r
2679                         c = UCSERR;\r
2680 \r
2681                     break;\r
2682             }\r
2683             /* Are we in the nasty ACS mode? Note: no sco in utf mode. */\r
2684             else if(term->sco_acs && \r
2685                     (c!='\033' && c!='\012' && c!='\015' && c!='\b'))\r
2686             {\r
2687                if (term->sco_acs == 2) c |= 0x80;\r
2688                c |= CSET_SCOACS;\r
2689             } else {\r
2690                 switch (term->cset_attr[term->cset]) {\r
2691                     /* \r
2692                      * Linedraw characters are different from 'ESC ( B'\r
2693                      * only for a small range. For ones outside that\r
2694                      * range, make sure we use the same font as well as\r
2695                      * the same encoding.\r
2696                      */\r
2697                   case CSET_LINEDRW:\r
2698                     if (term->ucsdata->unitab_ctrl[c] != 0xFF)\r
2699                         c = term->ucsdata->unitab_ctrl[c];\r
2700                     else\r
2701                         c = ((unsigned char) c) | CSET_LINEDRW;\r
2702                     break;\r
2703 \r
2704                   case CSET_GBCHR:\r
2705                     /* If UK-ASCII, make the '#' a LineDraw Pound */\r
2706                     if (c == '#') {\r
2707                         c = '}' | CSET_LINEDRW;\r
2708                         break;\r
2709                     }\r
2710                   /*FALLTHROUGH*/ case CSET_ASCII:\r
2711                     if (term->ucsdata->unitab_ctrl[c] != 0xFF)\r
2712                         c = term->ucsdata->unitab_ctrl[c];\r
2713                     else\r
2714                         c = ((unsigned char) c) | CSET_ASCII;\r
2715                     break;\r
2716                 case CSET_SCOACS:\r
2717                     if (c>=' ') c = ((unsigned char)c) | CSET_SCOACS;\r
2718                     break;\r
2719                 }\r
2720             }\r
2721         }\r
2722 \r
2723         /*\r
2724          * How about C1 controls? \r
2725          * Explicitly ignore SCI (0x9a), which we don't translate to DECID.\r
2726          */\r
2727         if ((c & -32) == 0x80 && term->termstate < DO_CTRLS &&\r
2728             !term->vt52_mode && has_compat(VT220)) {\r
2729             if (c == 0x9a)\r
2730                 c = 0;\r
2731             else {\r
2732                 term->termstate = SEEN_ESC;\r
2733                 term->esc_query = FALSE;\r
2734                 c = '@' + (c & 0x1F);\r
2735             }\r
2736         }\r
2737 \r
2738         /* Or the GL control. */\r
2739         if (c == '\177' && term->termstate < DO_CTRLS && has_compat(OTHER)) {\r
2740             if (term->curs.x && !term->wrapnext)\r
2741                 term->curs.x--;\r
2742             term->wrapnext = FALSE;\r
2743             /* destructive backspace might be disabled */\r
2744             if (!term->cfg.no_dbackspace) {\r
2745                 check_boundary(term, term->curs.x, term->curs.y);\r
2746                 check_boundary(term, term->curs.x+1, term->curs.y);\r
2747                 copy_termchar(scrlineptr(term->curs.y),\r
2748                               term->curs.x, &term->erase_char);\r
2749             }\r
2750         } else\r
2751             /* Or normal C0 controls. */\r
2752         if ((c & ~0x1F) == 0 && term->termstate < DO_CTRLS) {\r
2753             switch (c) {\r
2754               case '\005':             /* ENQ: terminal type query */\r
2755                 /* \r
2756                  * Strictly speaking this is VT100 but a VT100 defaults to\r
2757                  * no response. Other terminals respond at their option.\r
2758                  *\r
2759                  * Don't put a CR in the default string as this tends to\r
2760                  * upset some weird software.\r
2761                  */\r
2762                 compatibility(ANSIMIN);\r
2763                 if (term->ldisc) {\r
2764                     char abuf[lenof(term->cfg.answerback)], *s, *d;\r
2765                     for (s = term->cfg.answerback, d = abuf; *s;) {\r
2766                         char *n;\r
2767                         char c = ctrlparse(s, &n);\r
2768                         if (n) {\r
2769                             *d++ = c;\r
2770                             s = n;\r
2771                         } else {\r
2772                             *d++ = *s++;\r
2773                         }\r
2774                     }\r
2775                     lpage_send(term->ldisc, DEFAULT_CODEPAGE,\r
2776                                abuf, d - abuf, 0);\r
2777                 }\r
2778                 break;\r
2779               case '\007':            /* BEL: Bell */\r
2780                 {\r
2781                     struct beeptime *newbeep;\r
2782                     unsigned long ticks;\r
2783 \r
2784                     ticks = GETTICKCOUNT();\r
2785 \r
2786                     if (!term->beep_overloaded) {\r
2787                         newbeep = snew(struct beeptime);\r
2788                         newbeep->ticks = ticks;\r
2789                         newbeep->next = NULL;\r
2790                         if (!term->beephead)\r
2791                             term->beephead = newbeep;\r
2792                         else\r
2793                             term->beeptail->next = newbeep;\r
2794                         term->beeptail = newbeep;\r
2795                         term->nbeeps++;\r
2796                     }\r
2797 \r
2798                     /*\r
2799                      * Throw out any beeps that happened more than\r
2800                      * t seconds ago.\r
2801                      */\r
2802                     while (term->beephead &&\r
2803                            term->beephead->ticks < ticks - term->cfg.bellovl_t) {\r
2804                         struct beeptime *tmp = term->beephead;\r
2805                         term->beephead = tmp->next;\r
2806                         sfree(tmp);\r
2807                         if (!term->beephead)\r
2808                             term->beeptail = NULL;\r
2809                         term->nbeeps--;\r
2810                     }\r
2811 \r
2812                     if (term->cfg.bellovl && term->beep_overloaded &&\r
2813                         ticks - term->lastbeep >= (unsigned)term->cfg.bellovl_s) {\r
2814                         /*\r
2815                          * If we're currently overloaded and the\r
2816                          * last beep was more than s seconds ago,\r
2817                          * leave overload mode.\r
2818                          */\r
2819                         term->beep_overloaded = FALSE;\r
2820                     } else if (term->cfg.bellovl && !term->beep_overloaded &&\r
2821                                term->nbeeps >= term->cfg.bellovl_n) {\r
2822                         /*\r
2823                          * Now, if we have n or more beeps\r
2824                          * remaining in the queue, go into overload\r
2825                          * mode.\r
2826                          */\r
2827                         term->beep_overloaded = TRUE;\r
2828                     }\r
2829                     term->lastbeep = ticks;\r
2830 \r
2831                     /*\r
2832                      * Perform an actual beep if we're not overloaded.\r
2833                      */\r
2834                     if (!term->cfg.bellovl || !term->beep_overloaded) {\r
2835                         do_beep(term->frontend, term->cfg.beep);\r
2836 \r
2837                         if (term->cfg.beep == BELL_VISUAL) {\r
2838                             term_schedule_vbell(term, FALSE, 0);\r
2839                         }\r
2840                     }\r
2841                     seen_disp_event(term);\r
2842                 }\r
2843                 break;\r
2844               case '\b':              /* BS: Back space */\r
2845                 if (term->curs.x == 0 &&\r
2846                     (term->curs.y == 0 || term->wrap == 0))\r
2847                     /* do nothing */ ;\r
2848                 else if (term->curs.x == 0 && term->curs.y > 0)\r
2849                     term->curs.x = term->cols - 1, term->curs.y--;\r
2850                 else if (term->wrapnext)\r
2851                     term->wrapnext = FALSE;\r
2852                 else\r
2853                     term->curs.x--;\r
2854                 seen_disp_event(term);\r
2855                 break;\r
2856               case '\016':            /* LS1: Locking-shift one */\r
2857                 compatibility(VT100);\r
2858                 term->cset = 1;\r
2859                 break;\r
2860               case '\017':            /* LS0: Locking-shift zero */\r
2861                 compatibility(VT100);\r
2862                 term->cset = 0;\r
2863                 break;\r
2864               case '\033':            /* ESC: Escape */\r
2865                 if (term->vt52_mode)\r
2866                     term->termstate = VT52_ESC;\r
2867                 else {\r
2868                     compatibility(ANSIMIN);\r
2869                     term->termstate = SEEN_ESC;\r
2870                     term->esc_query = FALSE;\r
2871                 }\r
2872                 break;\r
2873               case '\015':            /* CR: Carriage return */\r
2874                 term->curs.x = 0;\r
2875                 term->wrapnext = FALSE;\r
2876                 seen_disp_event(term);\r
2877                 term->paste_hold = 0;\r
2878 \r
2879         if (term->cfg.crhaslf) {  \r
2880                   if (term->curs.y == term->marg_b)\r
2881                     scroll(term, term->marg_t, term->marg_b, 1, TRUE);\r
2882                   else if (term->curs.y < term->rows - 1)\r
2883                     term->curs.y++;\r
2884         }\r
2885                 if (term->logctx)\r
2886                     logtraffic(term->logctx, (unsigned char) c, LGTYP_ASCII);\r
2887                 break;\r
2888               case '\014':            /* FF: Form feed */\r
2889                 if (has_compat(SCOANSI)) {\r
2890                     move(term, 0, 0, 0);\r
2891                     erase_lots(term, FALSE, FALSE, TRUE);\r
2892                     term->disptop = 0;\r
2893                     term->wrapnext = FALSE;\r
2894                     seen_disp_event(term);\r
2895                     break;\r
2896                 }\r
2897               case '\013':            /* VT: Line tabulation */\r
2898                 compatibility(VT100);\r
2899               case '\012':            /* LF: Line feed */\r
2900                 if (term->curs.y == term->marg_b)\r
2901                     scroll(term, term->marg_t, term->marg_b, 1, TRUE);\r
2902                 else if (term->curs.y < term->rows - 1)\r
2903                     term->curs.y++;\r
2904                 if (term->cfg.lfhascr)\r
2905                     term->curs.x = 0;\r
2906                 term->wrapnext = FALSE;\r
2907                 seen_disp_event(term);\r
2908                 term->paste_hold = 0;\r
2909                 if (term->logctx)\r
2910                     logtraffic(term->logctx, (unsigned char) c, LGTYP_ASCII);\r
2911                 break;\r
2912               case '\t':              /* HT: Character tabulation */\r
2913                 {\r
2914                     pos old_curs = term->curs;\r
2915                     termline *ldata = scrlineptr(term->curs.y);\r
2916 \r
2917                     do {\r
2918                         term->curs.x++;\r
2919                     } while (term->curs.x < term->cols - 1 &&\r
2920                              !term->tabs[term->curs.x]);\r
2921 \r
2922                     if ((ldata->lattr & LATTR_MODE) != LATTR_NORM) {\r
2923                         if (term->curs.x >= term->cols / 2)\r
2924                             term->curs.x = term->cols / 2 - 1;\r
2925                     } else {\r
2926                         if (term->curs.x >= term->cols)\r
2927                             term->curs.x = term->cols - 1;\r
2928                     }\r
2929 \r
2930                     check_selection(term, old_curs, term->curs);\r
2931                 }\r
2932                 seen_disp_event(term);\r
2933                 break;\r
2934             }\r
2935         } else\r
2936             switch (term->termstate) {\r
2937               case TOPLEVEL:\r
2938                 /* Only graphic characters get this far;\r
2939                  * ctrls are stripped above */\r
2940                 {\r
2941                     termline *cline = scrlineptr(term->curs.y);\r
2942                     int width = 0;\r
2943                     if (DIRECT_CHAR(c))\r
2944                         width = 1;\r
2945                     if (!width)\r
2946                         width = (term->cfg.cjk_ambig_wide ?\r
2947                                  mk_wcwidth_cjk((wchar_t) c) :\r
2948                                  mk_wcwidth((wchar_t) c));\r
2949 \r
2950                     if (term->wrapnext && term->wrap && width > 0) {\r
2951                         cline->lattr |= LATTR_WRAPPED;\r
2952                         if (term->curs.y == term->marg_b)\r
2953                             scroll(term, term->marg_t, term->marg_b, 1, TRUE);\r
2954                         else if (term->curs.y < term->rows - 1)\r
2955                             term->curs.y++;\r
2956                         term->curs.x = 0;\r
2957                         term->wrapnext = FALSE;\r
2958                         cline = scrlineptr(term->curs.y);\r
2959                     }\r
2960                     if (term->insert && width > 0)\r
2961                         insch(term, width);\r
2962                     if (term->selstate != NO_SELECTION) {\r
2963                         pos cursplus = term->curs;\r
2964                         incpos(cursplus);\r
2965                         check_selection(term, term->curs, cursplus);\r
2966                     }\r
2967                     if (((c & CSET_MASK) == CSET_ASCII ||\r
2968                          (c & CSET_MASK) == 0) &&\r
2969                         term->logctx)\r
2970                         logtraffic(term->logctx, (unsigned char) c,\r
2971                                    LGTYP_ASCII);\r
2972 \r
2973                     switch (width) {\r
2974                       case 2:\r
2975                         /*\r
2976                          * If we're about to display a double-width\r
2977                          * character starting in the rightmost\r
2978                          * column, then we do something special\r
2979                          * instead. We must print a space in the\r
2980                          * last column of the screen, then wrap;\r
2981                          * and we also set LATTR_WRAPPED2 which\r
2982                          * instructs subsequent cut-and-pasting not\r
2983                          * only to splice this line to the one\r
2984                          * after it, but to ignore the space in the\r
2985                          * last character position as well.\r
2986                          * (Because what was actually output to the\r
2987                          * terminal was presumably just a sequence\r
2988                          * of CJK characters, and we don't want a\r
2989                          * space to be pasted in the middle of\r
2990                          * those just because they had the\r
2991                          * misfortune to start in the wrong parity\r
2992                          * column. xterm concurs.)\r
2993                          */\r
2994                         check_boundary(term, term->curs.x, term->curs.y);\r
2995                         check_boundary(term, term->curs.x+2, term->curs.y);\r
2996                         if (term->curs.x == term->cols-1) {\r
2997                             copy_termchar(cline, term->curs.x,\r
2998                                           &term->erase_char);\r
2999                             cline->lattr |= LATTR_WRAPPED | LATTR_WRAPPED2;\r
3000                             if (term->curs.y == term->marg_b)\r
3001                                 scroll(term, term->marg_t, term->marg_b,\r
3002                                        1, TRUE);\r
3003                             else if (term->curs.y < term->rows - 1)\r
3004                                 term->curs.y++;\r
3005                             term->curs.x = 0;\r
3006                             cline = scrlineptr(term->curs.y);\r
3007                             /* Now we must check_boundary again, of course. */\r
3008                             check_boundary(term, term->curs.x, term->curs.y);\r
3009                             check_boundary(term, term->curs.x+2, term->curs.y);\r
3010                         }\r
3011 \r
3012                         /* FULL-TERMCHAR */\r
3013                         clear_cc(cline, term->curs.x);\r
3014                         cline->chars[term->curs.x].chr = c;\r
3015                         cline->chars[term->curs.x].attr = term->curr_attr;\r
3016 \r
3017                         term->curs.x++;\r
3018 \r
3019                         /* FULL-TERMCHAR */\r
3020                         clear_cc(cline, term->curs.x);\r
3021                         cline->chars[term->curs.x].chr = UCSWIDE;\r
3022                         cline->chars[term->curs.x].attr = term->curr_attr;\r
3023 \r
3024                         break;\r
3025                       case 1:\r
3026                         check_boundary(term, term->curs.x, term->curs.y);\r
3027                         check_boundary(term, term->curs.x+1, term->curs.y);\r
3028 \r
3029                         /* FULL-TERMCHAR */\r
3030                         clear_cc(cline, term->curs.x);\r
3031                         cline->chars[term->curs.x].chr = c;\r
3032                         cline->chars[term->curs.x].attr = term->curr_attr;\r
3033 \r
3034                         break;\r
3035                       case 0:\r
3036                         if (term->curs.x > 0) {\r
3037                             int x = term->curs.x - 1;\r
3038 \r
3039                             /* If we're in wrapnext state, the character\r
3040                              * to combine with is _here_, not to our left. */\r
3041                             if (term->wrapnext)\r
3042                                 x++;\r
3043 \r
3044                             /*\r
3045                              * If the previous character is\r
3046                              * UCSWIDE, back up another one.\r
3047                              */\r
3048                             if (cline->chars[x].chr == UCSWIDE) {\r
3049                                 assert(x > 0);\r
3050                                 x--;\r
3051                             }\r
3052 \r
3053                             add_cc(cline, x, c);\r
3054                             seen_disp_event(term);\r
3055                         }\r
3056                         continue;\r
3057                       default:\r
3058                         continue;\r
3059                     }\r
3060                     term->curs.x++;\r
3061                     if (term->curs.x == term->cols) {\r
3062                         term->curs.x--;\r
3063                         term->wrapnext = TRUE;\r
3064                         if (term->wrap && term->vt52_mode) {\r
3065                             cline->lattr |= LATTR_WRAPPED;\r
3066                             if (term->curs.y == term->marg_b)\r
3067                                 scroll(term, term->marg_t, term->marg_b, 1, TRUE);\r
3068                             else if (term->curs.y < term->rows - 1)\r
3069                                 term->curs.y++;\r
3070                             term->curs.x = 0;\r
3071                             term->wrapnext = FALSE;\r
3072                         }\r
3073                     }\r
3074                     seen_disp_event(term);\r
3075                 }\r
3076                 break;\r
3077 \r
3078               case OSC_MAYBE_ST:\r
3079                 /*\r
3080                  * This state is virtually identical to SEEN_ESC, with the\r
3081                  * exception that we have an OSC sequence in the pipeline,\r
3082                  * and _if_ we see a backslash, we process it.\r
3083                  */\r
3084                 if (c == '\\') {\r
3085                     do_osc(term);\r
3086                     term->termstate = TOPLEVEL;\r
3087                     break;\r
3088                 }\r
3089                 /* else fall through */\r
3090               case SEEN_ESC:\r
3091                 if (c >= ' ' && c <= '/') {\r
3092                     if (term->esc_query)\r
3093                         term->esc_query = -1;\r
3094                     else\r
3095                         term->esc_query = c;\r
3096                     break;\r
3097                 }\r
3098                 term->termstate = TOPLEVEL;\r
3099                 switch (ANSI(c, term->esc_query)) {\r
3100                   case '[':             /* enter CSI mode */\r
3101                     term->termstate = SEEN_CSI;\r
3102                     term->esc_nargs = 1;\r
3103                     term->esc_args[0] = ARG_DEFAULT;\r
3104                     term->esc_query = FALSE;\r
3105                     break;\r
3106                   case ']':             /* OSC: xterm escape sequences */\r
3107                     /* Compatibility is nasty here, xterm, linux, decterm yuk! */\r
3108                     compatibility(OTHER);\r
3109                     term->termstate = SEEN_OSC;\r
3110                     term->esc_args[0] = 0;\r
3111                     break;\r
3112                   case '7':             /* DECSC: save cursor */\r
3113                     compatibility(VT100);\r
3114                     save_cursor(term, TRUE);\r
3115                     break;\r
3116                   case '8':             /* DECRC: restore cursor */\r
3117                     compatibility(VT100);\r
3118                     save_cursor(term, FALSE);\r
3119                     seen_disp_event(term);\r
3120                     break;\r
3121                   case '=':             /* DECKPAM: Keypad application mode */\r
3122                     compatibility(VT100);\r
3123                     term->app_keypad_keys = TRUE;\r
3124                     break;\r
3125                   case '>':             /* DECKPNM: Keypad numeric mode */\r
3126                     compatibility(VT100);\r
3127                     term->app_keypad_keys = FALSE;\r
3128                     break;\r