X-Git-Url: https://git.distorted.org.uk/~mdw/sgt/putty/blobdiff_plain/37d2a50503dd8647ab021e3015b08317ef953740..0ed48730a1c7c81cf93a49ce61541461d7df5a58:/terminal.c diff --git a/terminal.c b/terminal.c index 410d8bb5..0221a564 100644 --- a/terminal.c +++ b/terminal.c @@ -56,12 +56,37 @@ #define has_compat(x) ( ((CL_##x)&term->compatibility_level) != 0 ) +const char sco2ansicolour[] = { 0, 4, 2, 6, 1, 5, 3, 7 }; + #define sel_nl_sz (sizeof(sel_nl)/sizeof(wchar_t)) const wchar_t sel_nl[] = SEL_NL; /* + * Fetch the character at a particular position in a line array, + * for purposes of `wordtype'. The reason this isn't just a simple + * array reference is that if the character we find is UCSWIDE, + * then we must look one space further to the left. + */ +#define UCSGET(a, x) \ + ( (x)>0 && (a)[(x)].chr == UCSWIDE ? (a)[(x)-1].chr : (a)[(x)].chr ) + +/* + * Detect the various aliases of U+0020 SPACE. + */ +#define IS_SPACE_CHR(chr) \ + ((chr) == 0x20 || (DIRECT_CHAR(chr) && ((chr) & 0xFF) == 0x20)) + +/* + * Spot magic CSETs. + */ +#define CSET_OF(chr) (DIRECT_CHAR(chr)||DIRECT_FONT(chr) ? (chr)&CSET_MASK : 0) + +/* * Internal prototypes. */ +static void resizeline(Terminal *, termline *, int); +static termline *lineptr(Terminal *, int, int, int); +static void unlineptr(termline *); static void do_paint(Terminal *, Context, int); static void erase_lots(Terminal *, int, int, int); static void swap_screen(Terminal *, int, int, int); @@ -72,29 +97,526 @@ static void term_print_finish(Terminal *); static void scroll_display(Terminal *, int, int, int); #endif /* OPTIMISE_SCROLL */ +static termline *newline(Terminal *term, int cols, int bce) +{ + termline *line; + int j; + + line = snew(termline); + line->chars = snewn(cols, termchar); + for (j = 0; j < cols; j++) + line->chars[j] = (bce ? term->erase_char : term->basic_erase_char); + line->cols = cols; + line->lattr = LATTR_NORM; + line->temporary = FALSE; + + return line; +} + +static void freeline(termline *line) +{ + if (line) { + sfree(line->chars); + sfree(line); + } +} + +static void unlineptr(termline *line) +{ + if (line->temporary) + freeline(line); +} + +/* + * Compress and decompress a termline into an RLE-based format for + * storing in scrollback. (Since scrollback almost never needs to + * be modified and exists in huge quantities, this is a sensible + * tradeoff, particularly since it allows us to continue adding + * features to the main termchar structure without proportionally + * bloating the terminal emulator's memory footprint unless those + * features are in constant use.) + */ +struct buf { + unsigned char *data; + int len, size; +}; +static void add(struct buf *b, unsigned char c) +{ + if (b->len >= b->size) { + b->size = (b->len * 3 / 2) + 512; + b->data = sresize(b->data, b->size, unsigned char); + } + b->data[b->len++] = c; +} +static int get(struct buf *b) +{ + return b->data[b->len++]; +} +static void makerle(struct buf *b, termline *ldata, + void (*makeliteral)(struct buf *b, termchar *c, + unsigned long *state)) +{ + int hdrpos, hdrsize, n, prevlen, prevpos, thislen, thispos, prev2; + termchar *c = ldata->chars; + unsigned long state = 0, oldstate; + + n = ldata->cols; + + hdrpos = b->len; + hdrsize = 0; + add(b, 0); + prevlen = prevpos = 0; + prev2 = FALSE; + + while (n-- > 0) { + thispos = b->len; + makeliteral(b, c++, &state); + thislen = b->len - thispos; + if (thislen == prevlen && + !memcmp(b->data + prevpos, b->data + thispos, thislen)) { + /* + * This literal precisely matches the previous one. + * Turn it into a run if it's worthwhile. + * + * With one-byte literals, it costs us two bytes to + * encode a run, plus another byte to write the header + * to resume normal output; so a three-element run is + * neutral, and anything beyond that is unconditionally + * worthwhile. With two-byte literals or more, even a + * 2-run is a win. + */ + if (thislen > 1 || prev2) { + int runpos, runlen; + + /* + * It's worth encoding a run. Start at prevpos, + * unless hdrsize==0 in which case we can back up + * another one and start by overwriting hdrpos. + */ + + hdrsize--; /* remove the literal at prevpos */ + if (prev2) { + assert(hdrsize > 0); + hdrsize--; + prevpos -= prevlen;/* and possibly another one */ + } + + if (hdrsize == 0) { + assert(prevpos == hdrpos + 1); + runpos = hdrpos; + b->len = prevpos+prevlen; + } else { + memmove(b->data + prevpos+1, b->data + prevpos, prevlen); + runpos = prevpos; + b->len = prevpos+prevlen+1; + /* + * Terminate the previous run of ordinary + * literals. + */ + assert(hdrsize >= 1 && hdrsize <= 128); + b->data[hdrpos] = hdrsize - 1; + } + + runlen = prev2 ? 3 : 2; + + while (n > 0 && runlen < 129) { + int tmppos, tmplen; + tmppos = b->len; + oldstate = state; + makeliteral(b, c, &state); + tmplen = b->len - tmppos; + b->len = tmppos; + if (tmplen != thislen || + memcmp(b->data + runpos+1, b->data + tmppos, tmplen)) { + state = oldstate; + break; /* run over */ + } + n--, c++, runlen++; + } + + assert(runlen >= 2 && runlen <= 129); + b->data[runpos] = runlen + 0x80 - 2; + + hdrpos = b->len; + hdrsize = 0; + add(b, 0); + + continue; + } else { + /* + * Just flag that the previous two literals were + * identical, in case we find a third identical one + * we want to turn into a run. + */ + prev2 = TRUE; + prevlen = thislen; + prevpos = thispos; + } + } else { + prev2 = FALSE; + prevlen = thislen; + prevpos = thispos; + } + + /* + * This character isn't (yet) part of a run. Add it to + * hdrsize. + */ + hdrsize++; + if (hdrsize == 128) { + b->data[hdrpos] = hdrsize - 1; + hdrpos = b->len; + hdrsize = 0; + add(b, 0); + prevlen = prevpos = 0; + prev2 = FALSE; + } + } + + /* + * Clean up. + */ + if (hdrsize > 0) { + assert(hdrsize <= 128); + b->data[hdrpos] = hdrsize - 1; + } else { + b->len = hdrpos; + } +} +static void makeliteral_chr(struct buf *b, termchar *c, unsigned long *state) +{ + /* + * My encoding for characters is UTF-8-like, in that it stores + * 7-bit ASCII in one byte and uses high-bit-set bytes as + * introducers to indicate a longer sequence. However, it's + * unlike UTF-8 in that it doesn't need to be able to + * resynchronise, and therefore I don't want to waste two bits + * per byte on having recognisable continuation characters. + * Also I don't want to rule out the possibility that I may one + * day use values 0x80000000-0xFFFFFFFF for interesting + * purposes, so unlike UTF-8 I need a full 32-bit range. + * Accordingly, here is my encoding: + * + * 00000000-0000007F: 0xxxxxxx (but see below) + * 00000080-00003FFF: 10xxxxxx xxxxxxxx + * 00004000-001FFFFF: 110xxxxx xxxxxxxx xxxxxxxx + * 00200000-0FFFFFFF: 1110xxxx xxxxxxxx xxxxxxxx xxxxxxxx + * 10000000-FFFFFFFF: 11110ZZZ xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx + * + * (`Z' is like `x' but is always going to be zero since the + * values I'm encoding don't go above 2^32. In principle the + * five-byte form of the encoding could extend to 2^35, and + * there could be six-, seven-, eight- and nine-byte forms as + * well to allow up to 64-bit values to be encoded. But that's + * completely unnecessary for these purposes!) + * + * The encoding as written above would be very simple, except + * that 7-bit ASCII can occur in several different ways in the + * terminal data; sometimes it crops up in the D800 page + * (CSET_ASCII) but at other times it's in the 0000 page (real + * Unicode). Therefore, this encoding is actually _stateful_: + * the one-byte encoding of 00-7F actually indicates `reuse the + * upper three bytes of the last character', and to encode an + * absolute value of 00-7F you need to use the two-byte form + * instead. + */ + if ((c->chr & ~0x7F) == *state) { + add(b, (unsigned char)(c->chr & 0x7F)); + } else if (c->chr < 0x4000) { + add(b, (unsigned char)(((c->chr >> 8) & 0x3F) | 0x80)); + add(b, (unsigned char)(c->chr & 0xFF)); + } else if (c->chr < 0x200000) { + add(b, (unsigned char)(((c->chr >> 16) & 0x1F) | 0xC0)); + add(b, (unsigned char)((c->chr >> 8) & 0xFF)); + add(b, (unsigned char)(c->chr & 0xFF)); + } else if (c->chr < 0x10000000) { + add(b, (unsigned char)(((c->chr >> 24) & 0x0F) | 0xE0)); + add(b, (unsigned char)((c->chr >> 16) & 0xFF)); + add(b, (unsigned char)((c->chr >> 8) & 0xFF)); + add(b, (unsigned char)(c->chr & 0xFF)); + } else { + add(b, 0xF0); + add(b, (unsigned char)((c->chr >> 24) & 0xFF)); + add(b, (unsigned char)((c->chr >> 16) & 0xFF)); + add(b, (unsigned char)((c->chr >> 8) & 0xFF)); + add(b, (unsigned char)(c->chr & 0xFF)); + } + *state = c->chr & ~0xFF; +} +static void makeliteral_attr(struct buf *b, termchar *c, unsigned long *state) +{ + /* + * My encoding for attributes is 16-bit-granular and assumes + * that the top bit of the word is never required. I either + * store a two-byte value with the top bit clear (indicating + * just that value), or a four-byte value with the top bit set + * (indicating the same value with its top bit clear). + */ + if (c->attr < 0x8000) { + add(b, (unsigned char)((c->attr >> 8) & 0xFF)); + add(b, (unsigned char)(c->attr & 0xFF)); + } else { + add(b, (unsigned char)(((c->attr >> 24) & 0x7F) | 0x80)); + add(b, (unsigned char)((c->attr >> 16) & 0xFF)); + add(b, (unsigned char)((c->attr >> 8) & 0xFF)); + add(b, (unsigned char)(c->attr & 0xFF)); + } +} + +static termline *decompressline(unsigned char *data, int *bytes_used); + +static unsigned char *compressline(termline *ldata) +{ + struct buf buffer = { NULL, 0, 0 }, *b = &buffer; + + /* + * First, store the column count, 7 bits at a time, least + * significant `digit' first, with the high bit set on all but + * the last. + */ + { + int n = ldata->cols; + while (n >= 128) { + add(b, (unsigned char)((n & 0x7F) | 0x80)); + n >>= 7; + } + add(b, (unsigned char)(n)); + } + + /* + * Next store the lattrs; same principle. + */ + { + int n = ldata->lattr; + while (n >= 128) { + add(b, (unsigned char)((n & 0x7F) | 0x80)); + n >>= 7; + } + add(b, (unsigned char)(n)); + } + + /* + * Now we store a sequence of separate run-length encoded + * fragments, each containing exactly as many symbols as there + * are columns in the ldata. + * + * All of these have a common basic format: + * + * - a byte 00-7F indicates that X+1 literals follow it + * - a byte 80-FF indicates that a single literal follows it + * and expects to be repeated (X-0x80)+2 times. + * + * The format of the `literals' varies between the fragments. + */ + makerle(b, ldata, makeliteral_chr); + makerle(b, ldata, makeliteral_attr); + + /* + * Diagnostics: ensure that the compressed data really does + * decompress to the right thing. + */ +#ifndef CHECK_SB_COMPRESSION + { + int dused; + termline *dcl; + +#ifdef DIAGNOSTIC_SB_COMPRESSION + int i; + for (i = 0; i < b->len; i++) { + printf(" %02x ", b->data[i]); + } + printf("\n"); +#endif + + dcl = decompressline(b->data, &dused); + assert(b->len == dused); + assert(ldata->cols == dcl->cols); + assert(ldata->lattr == dcl->lattr); + assert(!memcmp(ldata->chars, dcl->chars, ldata->cols * TSIZE)); + +#ifdef DIAGNOSTIC_SB_COMPRESSION + printf("%d cols (%d bytes) -> %d bytes (factor of %g)\n", + ldata->cols, 4 * ldata->cols, dused, + (double)dused / (4 * ldata->cols)); +#endif + + freeline(dcl); + } +#endif + + /* + * Trim the allocated memory so we don't waste any, and return. + */ + return sresize(b->data, b->len, unsigned char); +} + +static void readrle(struct buf *b, termline *ldata, + void (*readliteral)(struct buf *b, termchar *c, + unsigned long *state)) +{ + int n = 0; + unsigned long state = 0; + + while (n < ldata->cols) { + int hdr = get(b); + + if (hdr >= 0x80) { + /* A run. */ + + int pos = b->len, count = hdr + 2 - 0x80; + while (count--) { + assert(n < ldata->cols); + b->len = pos; + readliteral(b, ldata->chars + n, &state); + n++; + } + } else { + /* Just a sequence of consecutive literals. */ + + int count = hdr + 1; + while (count--) { + assert(n < ldata->cols); + readliteral(b, ldata->chars + n, &state); + n++; + } + } + } + + assert(n == ldata->cols); +} +static void readliteral_chr(struct buf *b, termchar *c, unsigned long *state) +{ + int byte; + + /* + * 00000000-0000007F: 0xxxxxxx + * 00000080-00003FFF: 10xxxxxx xxxxxxxx + * 00004000-001FFFFF: 110xxxxx xxxxxxxx xxxxxxxx + * 00200000-0FFFFFFF: 1110xxxx xxxxxxxx xxxxxxxx xxxxxxxx + * 10000000-FFFFFFFF: 11110ZZZ xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx + */ + + byte = get(b); + if (byte < 0x80) { + c->chr = byte | *state; + } else if (byte < 0xC0) { + c->chr = (byte &~ 0xC0) << 8; + c->chr |= get(b); + } else if (byte < 0xE0) { + c->chr = (byte &~ 0xE0) << 16; + c->chr |= get(b) << 8; + c->chr |= get(b); + } else if (byte < 0xF0) { + c->chr = (byte &~ 0xF0) << 24; + c->chr |= get(b) << 16; + c->chr |= get(b) << 8; + c->chr |= get(b); + } else { + assert(byte == 0xF0); + c->chr = get(b) << 24; + c->chr |= get(b) << 16; + c->chr |= get(b) << 8; + c->chr |= get(b); + } + *state = c->chr & ~0xFF; +} +static void readliteral_attr(struct buf *b, termchar *c, unsigned long *state) +{ + int val; + + val = get(b) << 8; + val |= get(b); + + if (val >= 0x8000) { + val <<= 16; + val |= get(b) << 8; + val |= get(b); + } + + c->attr = val; +} + +static termline *decompressline(unsigned char *data, int *bytes_used) +{ + int ncols, byte, shift; + struct buf buffer, *b = &buffer; + termline *ldata; + + b->data = data; + b->len = 0; + + /* + * First read in the column count. + */ + ncols = shift = 0; + do { + byte = get(b); + ncols |= (byte & 0x7F) << shift; + shift += 7; + } while (byte & 0x80); + + /* + * Now create the output termline. + */ + ldata = snew(termline); + ldata->chars = snewn(ncols, termchar); + ldata->cols = ncols; + ldata->temporary = TRUE; + + /* + * Now read in the lattr. + */ + ldata->lattr = shift = 0; + do { + byte = get(b); + ldata->lattr |= (byte & 0x7F) << shift; + shift += 7; + } while (byte & 0x80); + + /* + * Now we read in each of the RLE streams in turn. + */ + readrle(b, ldata, readliteral_chr); + readrle(b, ldata, readliteral_attr); + + /* Return the number of bytes read, for diagnostic purposes. */ + if (bytes_used) + *bytes_used = b->len; + + return ldata; +} + /* * Resize a line to make it `cols' columns wide. */ -unsigned long *resizeline(unsigned long *line, int cols) +static void resizeline(Terminal *term, termline *line, int cols) { int i, oldlen; - unsigned long lineattrs; - if (line[0] != (unsigned long)cols) { + if (line->cols != cols) { /* * This line is the wrong length, which probably means it * hasn't been accessed since a resize. Resize it now. */ - oldlen = line[0]; - lineattrs = line[oldlen + 1]; - line = srealloc(line, TSIZE * (2 + cols)); - line[0] = cols; + oldlen = line->cols; + line->chars = sresize(line->chars, cols, TTYPE); + line->cols = cols; for (i = oldlen; i < cols; i++) - line[i + 1] = ERASE_CHAR; - line[cols + 1] = lineattrs & LATTR_MODE; + line->chars[i] = term->basic_erase_char; } +} - return line; +/* + * Get the number of lines in the scrollback. + */ +static int sblines(Terminal *term) +{ + int sblines = count234(term->scrollback); + if (term->cfg.erase_to_scrollback && + term->alt_which && term->alt_screen) { + sblines += term->alt_sblines; + } + return sblines; } /* @@ -102,9 +624,9 @@ unsigned long *resizeline(unsigned long *line, int cols) * whether the y coordinate is non-negative or negative * (respectively). */ -unsigned long *lineptr(Terminal *term, int y, int lineno) +static termline *lineptr(Terminal *term, int y, int lineno, int screen) { - unsigned long *line, *newline; + termline *line; tree234 *whichtree; int treeindex; @@ -112,25 +634,41 @@ unsigned long *lineptr(Terminal *term, int y, int lineno) whichtree = term->screen; treeindex = y; } else { - whichtree = term->scrollback; - treeindex = y + count234(term->scrollback); + int altlines = 0; + + assert(!screen); + + if (term->cfg.erase_to_scrollback && + term->alt_which && term->alt_screen) { + altlines = term->alt_sblines; + } + if (y < -altlines) { + whichtree = term->scrollback; + treeindex = y + altlines + count234(term->scrollback); + } else { + whichtree = term->alt_screen; + treeindex = y + term->alt_sblines; + /* treeindex = y + count234(term->alt_screen); */ + } + } + if (whichtree == term->scrollback) { + unsigned char *cline = index234(whichtree, treeindex); + line = decompressline(cline, NULL); + } else { + line = index234(whichtree, treeindex); } - line = index234(whichtree, treeindex); /* We assume that we don't screw up and retrieve something out of range. */ assert(line != NULL); - newline = resizeline(line, term->cols); - if (newline != line) { - delpos234(whichtree, treeindex); - addpos234(whichtree, newline, treeindex); - line = newline; - } + resizeline(term, line, term->cols); + /* FIXME: should we sort the compressed scrollback out here? */ - return line + 1; + return line; } -#define lineptr(x) lineptr(term,x,__LINE__) +#define lineptr(x) (lineptr)(term,x,__LINE__,FALSE) +#define scrlineptr(x) (lineptr)(term,x,__LINE__,TRUE) /* * Set up power-on settings for the terminal. @@ -150,32 +688,32 @@ static void power_on(Terminal *term) for (i = 0; i < term->cols; i++) term->tabs[i] = (i % 8 == 0 ? TRUE : FALSE); } - term->alt_om = term->dec_om = cfg.dec_om; + term->alt_om = term->dec_om = term->cfg.dec_om; term->alt_ins = term->insert = FALSE; term->alt_wnext = term->wrapnext = term->save_wnext = FALSE; - term->alt_wrap = term->wrap = cfg.wrap_mode; + term->alt_wrap = term->wrap = term->cfg.wrap_mode; term->alt_cset = term->cset = term->save_cset = 0; term->alt_utf = term->utf = term->save_utf = 0; term->utf_state = 0; term->alt_sco_acs = term->sco_acs = term->save_sco_acs = 0; - term->cset_attr[0] = term->cset_attr[1] = term->save_csattr = ATTR_ASCII; + term->cset_attr[0] = term->cset_attr[1] = term->save_csattr = CSET_ASCII; term->rvideo = 0; term->in_vbell = FALSE; term->cursor_on = 1; term->big_cursor = 0; - term->save_attr = term->curr_attr = ATTR_DEFAULT; + term->default_attr = term->save_attr = term->curr_attr = ATTR_DEFAULT; term->term_editing = term->term_echoing = FALSE; - term->app_cursor_keys = cfg.app_cursor; - term->app_keypad_keys = cfg.app_keypad; - term->use_bce = cfg.bce; - term->blink_is_real = cfg.blinktext; - term->erase_char = ERASE_CHAR; + term->app_cursor_keys = term->cfg.app_cursor; + term->app_keypad_keys = term->cfg.app_keypad; + term->use_bce = term->cfg.bce; + term->blink_is_real = term->cfg.blinktext; + term->erase_char = term->basic_erase_char; term->alt_which = 0; term_print_finish(term); { int i; for (i = 0; i < 256; i++) - term->wordness[i] = cfg.wordness[i]; + term->wordness[i] = term->cfg.wordness[i]; } if (term->screen) { swap_screen(term, 1, FALSE, FALSE); @@ -194,11 +732,20 @@ void term_update(Terminal *term) ctx = get_ctx(term->frontend); if (ctx) { int need_sbar_update = term->seen_disp_event; - if (term->seen_disp_event && cfg.scroll_on_disp) { + if (term->seen_disp_event && term->cfg.scroll_on_disp) { term->disptop = 0; /* return to main screen */ term->seen_disp_event = 0; need_sbar_update = TRUE; } + + /* Allocate temporary buffers for Arabic shaping and bidi. */ + if (!term->cfg.arabicshaping || !term->cfg.bidi) + { + term->wcFrom = sresize(term->wcFrom, term->cols, bidi_char); + term->ltemp = sresize(term->ltemp, term->cols+1, termchar); + term->wcTo = sresize(term->wcTo, term->cols, bidi_char); + } + if (need_sbar_update) update_sbar(term); do_paint(term, ctx, TRUE); @@ -232,7 +779,7 @@ void term_seen_key_event(Terminal *term) /* * Reset the scrollback on keypress, if we're doing that. */ - if (cfg.scroll_on_key) { + if (term->cfg.scroll_on_key) { term->disptop = 0; /* return to main screen */ term->seen_disp_event = 1; } @@ -252,26 +799,69 @@ void term_pwron(Terminal *term) term_update(term); } +static void set_erase_char(Terminal *term) +{ + term->erase_char = term->basic_erase_char; + if (term->use_bce) + term->erase_char.attr = (term->curr_attr & + (ATTR_FGMASK | ATTR_BGMASK)); +} + /* * When the user reconfigures us, we need to check the forbidden- * alternate-screen config option, disable raw mouse mode if the * user has disabled mouse reporting, and abandon a print job if * the user has disabled printing. */ -void term_reconfig(Terminal *term) +void term_reconfig(Terminal *term, Config *cfg) { - if (cfg.no_alt_screen) + /* + * Before adopting the new config, check all those terminal + * settings which control power-on defaults; and if they've + * changed, we will modify the current state as well as the + * default one. The full list is: Auto wrap mode, DEC Origin + * Mode, BCE, blinking text, character classes. + */ + int reset_wrap, reset_decom, reset_bce, reset_blink, reset_charclass; + int i; + + reset_wrap = (term->cfg.wrap_mode != cfg->wrap_mode); + reset_decom = (term->cfg.dec_om != cfg->dec_om); + reset_bce = (term->cfg.bce != cfg->bce); + reset_blink = (term->cfg.blinktext != cfg->blinktext); + reset_charclass = 0; + for (i = 0; i < lenof(term->cfg.wordness); i++) + if (term->cfg.wordness[i] != cfg->wordness[i]) + reset_charclass = 1; + + term->cfg = *cfg; /* STRUCTURE COPY */ + + if (reset_wrap) + term->alt_wrap = term->wrap = term->cfg.wrap_mode; + if (reset_decom) + term->alt_om = term->dec_om = term->cfg.dec_om; + if (reset_bce) { + term->use_bce = term->cfg.bce; + set_erase_char(term); + } + if (reset_blink) + term->blink_is_real = term->cfg.blinktext; + if (reset_charclass) + for (i = 0; i < 256; i++) + term->wordness[i] = term->cfg.wordness[i]; + + if (term->cfg.no_alt_screen) swap_screen(term, 0, FALSE, FALSE); - if (cfg.no_mouse_rep) { + if (term->cfg.no_mouse_rep) { term->xterm_mouse = 0; set_raw_mouse_mode(term->frontend, 0); } - if (cfg.no_remote_charset) { - term->cset_attr[0] = term->cset_attr[1] = ATTR_ASCII; + if (term->cfg.no_remote_charset) { + term->cset_attr[0] = term->cset_attr[1] = CSET_ASCII; term->sco_acs = term->alt_sco_acs = 0; term->utf = 0; } - if (!*cfg.printer) { + if (!*term->cfg.printer) { term_print_finish(term); } } @@ -281,18 +871,21 @@ void term_reconfig(Terminal *term) */ void term_clrsb(Terminal *term) { - unsigned long *line; + termline *line; term->disptop = 0; while ((line = delpos234(term->scrollback, 0)) != NULL) { - sfree(line); + sfree(line); /* this is compressed data, not a termline */ } + term->tempsblines = 0; + term->alt_sblines = 0; update_sbar(term); } /* * Initialise the terminal. */ -Terminal *term_init(void *frontend) +Terminal *term_init(Config *mycfg, struct unicode_data *ucsdata, + void *frontend) { Terminal *term; @@ -300,13 +893,16 @@ Terminal *term_init(void *frontend) * Allocate a new Terminal structure and initialise the fields * that need it. */ - term = smalloc(sizeof(Terminal)); + term = snew(Terminal); term->frontend = frontend; + term->ucsdata = ucsdata; + term->cfg = *mycfg; /* STRUCTURE COPY */ term->logctx = NULL; term->compatibility_level = TM_PUTTY; strcpy(term->id_string, "\033[?6c"); term->last_blink = term->last_tblink = 0; term->paste_buffer = NULL; + term->paste_len = 0; term->last_paste = 0; bufchain_init(&term->inbuf); bufchain_init(&term->printer_buf); @@ -325,30 +921,91 @@ Terminal *term_init(void *frontend) term->curstype = 0; term->screen = term->alt_screen = term->scrollback = NULL; + term->tempsblines = 0; + term->alt_sblines = 0; term->disptop = 0; - term->disptext = term->dispcurs = NULL; + term->disptext = NULL; + term->dispcursx = term->dispcursy = -1; term->tabs = NULL; deselect(term); term->rows = term->cols = -1; power_on(term); term->beephead = term->beeptail = NULL; +#ifdef OPTIMISE_SCROLL + term->scrollhead = term->scrolltail = NULL; +#endif /* OPTIMISE_SCROLL */ term->nbeeps = 0; term->lastbeep = FALSE; term->beep_overloaded = FALSE; + term->attr_mask = 0xffffffff; term->resize_fn = NULL; term->resize_ctx = NULL; + term->in_term_out = FALSE; + term->ltemp = NULL; + term->wcFrom = NULL; + term->wcTo = NULL; + + term->bidi_cache_size = 0; + term->pre_bidi_cache = term->post_bidi_cache = NULL; + + term->basic_erase_char.chr = CSET_ASCII | ' '; + term->basic_erase_char.attr = ATTR_DEFAULT; return term; } +void term_free(Terminal *term) +{ + termline *line; + struct beeptime *beep; + int i; + + while ((line = delpos234(term->scrollback, 0)) != NULL) + sfree(line); /* compressed data, not a termline */ + freetree234(term->scrollback); + while ((line = delpos234(term->screen, 0)) != NULL) + freeline(line); + freetree234(term->screen); + while ((line = delpos234(term->alt_screen, 0)) != NULL) + freeline(line); + freetree234(term->alt_screen); + if (term->disptext) { + for (i = 0; i < term->rows; i++) + freeline(term->disptext[i]); + } + sfree(term->disptext); + while (term->beephead) { + beep = term->beephead; + term->beephead = beep->next; + sfree(beep); + } + bufchain_clear(&term->inbuf); + if(term->print_job) + printer_finish_job(term->print_job); + bufchain_clear(&term->printer_buf); + sfree(term->paste_buffer); + sfree(term->ltemp); + sfree(term->wcFrom); + sfree(term->wcTo); + + for (i = 0; i < term->bidi_cache_size; i++) { + sfree(term->pre_bidi_cache[i]); + sfree(term->post_bidi_cache[i]); + } + sfree(term->pre_bidi_cache); + sfree(term->post_bidi_cache); + + sfree(term); +} + /* * Set up the terminal for a given size. */ void term_size(Terminal *term, int newrows, int newcols, int newsavelines) { tree234 *newalt; - unsigned long *newdisp, *line; - int i, j; + termline **newdisp, *line; + int i, j, oldrows = term->rows; int sblen; int save_alt_which = term->alt_which; @@ -365,6 +1022,7 @@ void term_size(Terminal *term, int newrows, int newcols, int newsavelines) if (term->rows == -1) { term->scrollback = newtree234(NULL); term->screen = newtree234(NULL); + term->tempsblines = 0; term->rows = 0; } @@ -374,15 +1032,14 @@ void term_size(Terminal *term, int newrows, int newcols, int newsavelines) * will take care of resizing each individual line if * necessary. So: * - * - If the new screen and the old screen differ in length, we - * must shunt some lines in from the scrollback or out to - * the scrollback. - * - * - If doing that fails to provide us with enough material to - * fill the new screen (i.e. the number of rows needed in - * the new screen exceeds the total number in the previous - * screen+scrollback), we must invent some blank lines to - * cover the gap. + * - If the new screen is longer, we shunt lines in from temporary + * scrollback if possible, otherwise we add new blank lines at + * the bottom. + * + * - If the new screen is shorter, we remove any blank lines at + * the bottom if possible, otherwise shunt lines above the cursor + * to scrollback if possible, otherwise delete lines below the + * cursor. * * - Then, if the new scrollback length is less than the * amount of scrollback we actually have, we must throw some @@ -390,62 +1047,99 @@ void term_size(Terminal *term, int newrows, int newcols, int newsavelines) */ sblen = count234(term->scrollback); /* Do this loop to expand the screen if newrows > rows */ - for (i = term->rows; i < newrows; i++) { - if (sblen > 0) { - line = delpos234(term->scrollback, --sblen); + assert(term->rows == count234(term->screen)); + while (term->rows < newrows) { + if (term->tempsblines > 0) { + unsigned char *cline; + /* Insert a line from the scrollback at the top of the screen. */ + assert(sblen >= term->tempsblines); + cline = delpos234(term->scrollback, --sblen); + line = decompressline(cline, NULL); + sfree(cline); + line->temporary = FALSE; /* reconstituted line is now real */ + term->tempsblines -= 1; + addpos234(term->screen, line, 0); + term->curs.y += 1; + term->savecurs.y += 1; } else { - line = smalloc(TSIZE * (newcols + 2)); - line[0] = newcols; - for (j = 0; j <= newcols; j++) - line[j + 1] = ERASE_CHAR; + /* Add a new blank line at the bottom of the screen. */ + line = newline(term, newcols, FALSE); + addpos234(term->screen, line, count234(term->screen)); } - addpos234(term->screen, line, 0); + term->rows += 1; } /* Do this loop to shrink the screen if newrows < rows */ - for (i = newrows; i < term->rows; i++) { - line = delpos234(term->screen, 0); - addpos234(term->scrollback, line, sblen++); + while (term->rows > newrows) { + if (term->curs.y < term->rows - 1) { + /* delete bottom row, unless it contains the cursor */ + sfree(delpos234(term->screen, term->rows - 1)); + } else { + /* push top row to scrollback */ + line = delpos234(term->screen, 0); + addpos234(term->scrollback, compressline(line), sblen++); + freeline(line); + term->tempsblines += 1; + term->curs.y -= 1; + term->savecurs.y -= 1; + } + term->rows -= 1; } + assert(term->rows == newrows); assert(count234(term->screen) == newrows); + + /* Delete any excess lines from the scrollback. */ while (sblen > newsavelines) { line = delpos234(term->scrollback, 0); sfree(line); sblen--; } + if (sblen < term->tempsblines) + term->tempsblines = sblen; assert(count234(term->scrollback) <= newsavelines); + assert(count234(term->scrollback) >= term->tempsblines); term->disptop = 0; - newdisp = smalloc(newrows * (newcols + 1) * TSIZE); - for (i = 0; i < newrows * (newcols + 1); i++) - newdisp[i] = ATTR_INVALID; + /* Make a new displayed text buffer. */ + newdisp = snewn(newrows, termline *); + for (i = 0; i < newrows; i++) { + newdisp[i] = newline(term, newcols, FALSE); + for (j = 0; j < newcols; j++) + newdisp[i]->chars[i].attr = ATTR_INVALID; + } + if (term->disptext) { + for (i = 0; i < oldrows; i++) + freeline(term->disptext[i]); + } sfree(term->disptext); term->disptext = newdisp; - term->dispcurs = NULL; + term->dispcursx = term->dispcursy = -1; + /* Make a new alternate screen. */ newalt = newtree234(NULL); for (i = 0; i < newrows; i++) { - line = smalloc(TSIZE * (newcols + 2)); - line[0] = newcols; - for (j = 0; j <= newcols; j++) - line[j + 1] = term->erase_char; + line = newline(term, newcols, TRUE); addpos234(newalt, line, i); } if (term->alt_screen) { while (NULL != (line = delpos234(term->alt_screen, 0))) - sfree(line); + freeline(line); freetree234(term->alt_screen); } term->alt_screen = newalt; + term->alt_sblines = 0; - term->tabs = srealloc(term->tabs, newcols * sizeof(*term->tabs)); + term->tabs = sresize(term->tabs, newcols, unsigned char); { int i; for (i = (term->cols > 0 ? term->cols : 0); i < newcols; i++) term->tabs[i] = (i % 8 == 0 ? TRUE : FALSE); } - if (term->rows > 0) - term->curs.y += newrows - term->rows; + /* Check that the cursor positions are still valid. */ + if (term->savecurs.y < 0) + term->savecurs.y = 0; + if (term->savecurs.y >= newrows) + term->savecurs.y = newrows - 1; if (term->curs.y < 0) term->curs.y = 0; if (term->curs.y >= newrows) @@ -482,6 +1176,25 @@ void term_provide_resize_fn(Terminal *term, resize_fn(resize_ctx, term->cols, term->rows); } +/* Find the bottom line on the screen that has any content. + * If only the top line has content, returns 0. + * If no lines have content, return -1. + */ +static int find_last_nonempty_line(Terminal * term, tree234 * screen) +{ + int i; + for (i = count234(screen) - 1; i >= 0; i--) { + termline *line = index234(screen, i); + int j; + for (j = 0; j < line->cols; j++) { + if (line->chars[j].chr != term->erase_char.chr || + line->chars[j].attr != term->erase_char.attr) break; + } + if (j != line->cols) break; + } + return i; +} + /* * Swap screens. If `reset' is TRUE and we have been asked to * switch to the alternate screen, we must bring most of its @@ -503,6 +1216,7 @@ static void swap_screen(Terminal *term, int which, int reset, int keep_cur_pos) ttr = term->alt_screen; term->alt_screen = term->screen; term->screen = ttr; + term->alt_sblines = find_last_nonempty_line(term, term->alt_screen) + 1; t = term->curs.x; if (!reset && !keep_cur_pos) term->curs.x = term->alt_x; @@ -560,10 +1274,7 @@ static void swap_screen(Terminal *term, int which, int reset, int keep_cur_pos) */ static void update_sbar(Terminal *term) { - int nscroll; - - nscroll = count234(term->scrollback); - + int nscroll = sblines(term); set_sbar(term->frontend, nscroll + term->rows, nscroll + term->disptop, term->rows); } @@ -590,32 +1301,34 @@ static void check_selection(Terminal *term, pos from, pos to) */ static void scroll(Terminal *term, int topline, int botline, int lines, int sb) { - unsigned long *line, *line2; - int i, seltop; + termline *line; + int i, seltop, olddisptop, shift; if (topline != 0 || term->alt_which != 0) sb = FALSE; + olddisptop = term->disptop; + shift = lines; if (lines < 0) { while (lines < 0) { line = delpos234(term->screen, botline); - line = resizeline(line, term->cols); + resizeline(term, line, term->cols); for (i = 0; i < term->cols; i++) - line[i + 1] = term->erase_char; - line[term->cols + 1] = 0; + line->chars[i] = term->erase_char; + line->lattr = LATTR_NORM; addpos234(term->screen, line, topline); if (term->selstart.y >= topline && term->selstart.y <= botline) { term->selstart.y++; if (term->selstart.y > botline) { - term->selstart.y = botline; + term->selstart.y = botline + 1; term->selstart.x = 0; } } if (term->selend.y >= topline && term->selend.y <= botline) { term->selend.y++; if (term->selend.y > botline) { - term->selend.y = botline; + term->selend.y = botline + 1; term->selend.x = 0; } } @@ -629,18 +1342,21 @@ static void scroll(Terminal *term, int topline, int botline, int lines, int sb) int sblen = count234(term->scrollback); /* * We must add this line to the scrollback. We'll - * remove a line from the top of the scrollback to - * replace it, or allocate a new one if the - * scrollback isn't full. + * remove a line from the top of the scrollback if + * the scrollback is full. */ if (sblen == term->savelines) { - sblen--, line2 = delpos234(term->scrollback, 0); - } else { - line2 = smalloc(TSIZE * (term->cols + 2)); - line2[0] = term->cols; - } - addpos234(term->scrollback, line, sblen); - line = line2; + unsigned char *cline; + + sblen--; + cline = delpos234(term->scrollback, 0); + sfree(cline); + } else + term->tempsblines += 1; + + addpos234(term->scrollback, compressline(line), sblen); + + line = newline(term, term->cols, TRUE); /* * If the user is currently looking at part of the @@ -659,10 +1375,10 @@ static void scroll(Terminal *term, int topline, int botline, int lines, int sb) if (term->disptop > -term->savelines && term->disptop < 0) term->disptop--; } - line = resizeline(line, term->cols); + resizeline(term, line, term->cols); for (i = 0; i < term->cols; i++) - line[i + 1] = term->erase_char; - line[term->cols + 1] = 0; + line->chars[i] = term->erase_char; + line->lattr = LATTR_NORM; addpos234(term->screen, line, botline); /* @@ -678,57 +1394,107 @@ static void scroll(Terminal *term, int topline, int botline, int lines, int sb) */ seltop = sb ? -term->savelines : topline; - if (term->selstart.y >= seltop && - term->selstart.y <= botline) { - term->selstart.y--; - if (term->selstart.y < seltop) { - term->selstart.y = seltop; - term->selstart.x = 0; + if (term->selstate != NO_SELECTION) { + if (term->selstart.y >= seltop && + term->selstart.y <= botline) { + term->selstart.y--; + if (term->selstart.y < seltop) { + term->selstart.y = seltop; + term->selstart.x = 0; + } } - } - if (term->selend.y >= seltop && term->selend.y <= botline) { - term->selend.y--; - if (term->selend.y < seltop) { - term->selend.y = seltop; - term->selend.x = 0; + if (term->selend.y >= seltop && term->selend.y <= botline) { + term->selend.y--; + if (term->selend.y < seltop) { + term->selend.y = seltop; + term->selend.x = 0; + } } - } - if (term->selanchor.y >= seltop && term->selanchor.y <= botline) { - term->selanchor.y--; - if (term->selanchor.y < seltop) { - term->selanchor.y = seltop; - term->selanchor.x = 0; + if (term->selanchor.y >= seltop && + term->selanchor.y <= botline) { + term->selanchor.y--; + if (term->selanchor.y < seltop) { + term->selanchor.y = seltop; + term->selanchor.x = 0; + } } } lines--; } } +#ifdef OPTIMISE_SCROLL + shift += term->disptop - olddisptop; + if (shift < term->rows && shift > -term->rows && shift != 0) + scroll_display(term, topline, botline, shift); +#endif /* OPTIMISE_SCROLL */ } #ifdef OPTIMISE_SCROLL /* + * Add a scroll of a region on the screen into the pending scroll list. + * `lines' is +ve for scrolling forward, -ve for backward. + * + * If the scroll is on the same area as the last scroll in the list, + * merge them. + */ +static void save_scroll(Terminal *term, int topline, int botline, int lines) +{ + struct scrollregion *newscroll; + if (term->scrolltail && + term->scrolltail->topline == topline && + term->scrolltail->botline == botline) { + term->scrolltail->lines += lines; + } else { + newscroll = snew(struct scrollregion); + newscroll->topline = topline; + newscroll->botline = botline; + newscroll->lines = lines; + newscroll->next = NULL; + + if (!term->scrollhead) + term->scrollhead = newscroll; + else + term->scrolltail->next = newscroll; + term->scrolltail = newscroll; + } +} + +/* * Scroll the physical display, and our conception of it in disptext. */ static void scroll_display(Terminal *term, int topline, int botline, int lines) { - unsigned long *start, *end; - int distance, size, i; + int distance, nlines, i; - start = term->disptext + topline * (term->cols + 1); - end = term->disptext + (botline + 1) * (term->cols + 1); - distance = (lines > 0 ? lines : -lines) * (term->cols + 1); - size = end - start - distance; + distance = lines > 0 ? lines : -lines; + nlines = botline - topline + 1 - distance; if (lines > 0) { - memmove(start, start + distance, size * TSIZE); + for (i = 0; i < nlines; i++) + memcpy(term->disptext[start+i]->chars, + term->disptext[start+i+distance]->chars, + term->cols * TSIZE); + if (term->dispcursy >= 0 && + term->dispcursy >= topline + distance && + term->dispcursy < topline + distance + nlines) + term->dispcursy -= distance; for (i = 0; i < distance; i++) - (start + size)[i] |= ATTR_INVALID; + for (j = 0; j < term->cols; j++) + term->disptext[start+nlines+i]->chars[j].attr |= ATTR_INVALID; } else { - memmove(start + distance, start, size * TSIZE); + for (i = nlines; i-- ;) + memcpy(term->disptext[start+i+distance]->chars, + term->disptext[start+i]->chars, + term->cols * TSIZE); + if (term->dispcursy >= 0 && + term->dispcursy >= topline && + term->dispcursy < topline + nlines) + term->dispcursy += distance; for (i = 0; i < distance; i++) - start[i] |= ATTR_INVALID; + for (j = 0; j < term->cols; j++) + term->disptext[start+i]->chars[j].attr |= ATTR_INVALID; } - do_scroll(term->frontend, topline, botline, lines); + save_scroll(term, topline, botline, lines); } #endif /* OPTIMISE_SCROLL */ @@ -796,10 +1562,45 @@ static void save_cursor(Terminal *term, int save) term->cset_attr[term->cset] = term->save_csattr; term->sco_acs = term->save_sco_acs; fix_cpos; - if (term->use_bce) - term->erase_char = (' ' | ATTR_ASCII | - (term->curr_attr & - (ATTR_FGMASK | ATTR_BGMASK))); + set_erase_char(term); + } +} + +/* + * This function is called before doing _anything_ which affects + * only part of a line of text. It is used to mark the boundary + * between two character positions, and it indicates that some sort + * of effect is going to happen on only one side of that boundary. + * + * The effect of this function is to check whether a CJK + * double-width character is straddling the boundary, and to remove + * it and replace it with two spaces if so. (Of course, one or + * other of those spaces is then likely to be replaced with + * something else again, as a result of whatever happens next.) + * + * Also, if the boundary is at the right-hand _edge_ of the screen, + * it implies something deliberate is being done to the rightmost + * column position; hence we must clear LATTR_WRAPPED2. + * + * The input to the function is the coordinates of the _second_ + * character of the pair. + */ +static void check_boundary(Terminal *term, int x, int y) +{ + termline *ldata; + + /* Validate input coordinates, just in case. */ + if (x == 0 || x > term->cols) + return; + + ldata = scrlineptr(y); + if (x == term->cols) { + ldata->lattr &= ~LATTR_WRAPPED2; + } else { + if (ldata->chars[x].chr == UCSWIDE) { + ldata->chars[x-1].chr = ' ' | CSET_ASCII; + ldata->chars[x] = ldata->chars[x-1]; + } } } @@ -812,7 +1613,7 @@ static void erase_lots(Terminal *term, { pos start, end; int erase_lattr; - unsigned long *ldata; + int erasing_lines_from_top = 0; if (line_only) { start.y = term->curs.y; @@ -834,21 +1635,53 @@ static void erase_lots(Terminal *term, end = term->curs; incpos(end); } + if (!from_begin || !to_end) + check_boundary(term, term->curs.x, term->curs.y); check_selection(term, start, end); /* Clear screen also forces a full window redraw, just in case. */ if (start.y == 0 && start.x == 0 && end.y == term->rows) term_invalidate(term); - ldata = lineptr(start.y); - while (poslt(start, end)) { - if (start.x == term->cols && !erase_lattr) - ldata[start.x] &= ~LATTR_WRAPPED; - else - ldata[start.x] = term->erase_char; - if (incpos(start) && start.y < term->rows) - ldata = lineptr(start.y); + /* Lines scrolled away shouldn't be brought back on if the terminal + * resizes. */ + if (start.y == 0 && start.x == 0 && end.x == 0 && erase_lattr) + erasing_lines_from_top = 1; + + if (term->cfg.erase_to_scrollback && erasing_lines_from_top) { + /* If it's a whole number of lines, starting at the top, and + * we're fully erasing them, erase by scrolling and keep the + * lines in the scrollback. */ + int scrolllines = end.y; + if (end.y == term->rows) { + /* Shrink until we find a non-empty row.*/ + scrolllines = find_last_nonempty_line(term, term->screen) + 1; + } + if (scrolllines > 0) + scroll(term, 0, scrolllines - 1, scrolllines, TRUE); + fix_cpos; + } else { + termline *ldata = scrlineptr(start.y); + while (poslt(start, end)) { + if (start.x == term->cols) { + if (!erase_lattr) + ldata->lattr &= ~(LATTR_WRAPPED | LATTR_WRAPPED2); + else + ldata->lattr = LATTR_NORM; + } else { + ldata->chars[start.x] = term->erase_char; + } + if (incpos(start) && start.y < term->rows) { + ldata = scrlineptr(start.y); + } + } } + + /* After an erase of lines from the top of the screen, we shouldn't + * bring the lines back again if the terminal enlarges (since the user or + * application has explictly thrown them away). */ + if (erasing_lines_from_top && !(term->alt_which)) + term->tempsblines = 0; } /* @@ -860,7 +1693,7 @@ static void insch(Terminal *term, int n) int dir = (n < 0 ? -1 : +1); int m; pos cursplus; - unsigned long *ldata; + termline *ldata; n = (n < 0 ? -n : n); if (n > term->cols - term->curs.x) @@ -869,15 +1702,20 @@ static void insch(Terminal *term, int n) cursplus.y = term->curs.y; cursplus.x = term->curs.x + n; check_selection(term, term->curs, cursplus); - ldata = lineptr(term->curs.y); + check_boundary(term, term->curs.x, term->curs.y); + if (dir < 0) + check_boundary(term, term->curs.x + n, term->curs.y); + ldata = scrlineptr(term->curs.y); if (dir < 0) { - memmove(ldata + term->curs.x, ldata + term->curs.x + n, m * TSIZE); + memmove(ldata->chars + term->curs.x, ldata->chars + term->curs.x + n, + m * TSIZE); while (n--) - ldata[term->curs.x + m++] = term->erase_char; + ldata->chars[term->curs.x + m++] = term->erase_char; } else { - memmove(ldata + term->curs.x + n, ldata + term->curs.x, m * TSIZE); + memmove(ldata->chars + term->curs.x + n, ldata->chars + term->curs.x, + m * TSIZE); while (n--) - ldata[term->curs.x + n] = term->erase_char; + ldata->chars[term->curs.x + n] = term->erase_char; } } @@ -891,25 +1729,29 @@ static void toggle_mode(Terminal *term, int mode, int query, int state) if (query) switch (mode) { - case 1: /* application cursor keys */ + case 1: /* DECCKM: application cursor keys */ term->app_cursor_keys = state; break; - case 2: /* VT52 mode */ + case 2: /* DECANM: VT52 mode */ term->vt52_mode = !state; if (term->vt52_mode) { term->blink_is_real = FALSE; term->vt52_bold = FALSE; } else { - term->blink_is_real = cfg.blinktext; + term->blink_is_real = term->cfg.blinktext; } break; - case 3: /* 80/132 columns */ + case 3: /* DECCOLM: 80/132 columns */ deselect(term); - if (!cfg.no_remote_resize) + if (!term->cfg.no_remote_resize) request_resize(term->frontend, state ? 132 : 80, term->rows); term->reset_132 = state; + term->alt_t = term->marg_t = 0; + term->alt_b = term->marg_b = term->rows - 1; + move(term, 0, 0, 0); + erase_lots(term, FALSE, TRUE, TRUE); break; - case 5: /* reverse video */ + case 5: /* DECSCNM: reverse video */ /* * Toggle reverse video. If we receive an OFF within the * visual bell timeout period after an ON, we trigger an @@ -938,21 +1780,21 @@ static void toggle_mode(Terminal *term, int mode, int query, int state) if (state) term_update(term); break; - case 6: /* DEC origin mode */ + case 6: /* DECOM: DEC origin mode */ term->dec_om = state; break; - case 7: /* auto wrap */ + case 7: /* DECAWM: auto wrap */ term->wrap = state; break; - case 8: /* auto key repeat */ + case 8: /* DECARM: auto key repeat */ term->repeat_off = !state; break; - case 10: /* set local edit mode */ + case 10: /* DECEDM: set local edit mode */ term->term_editing = state; if (term->ldisc) /* cause ldisc to notice changes */ ldisc_send(term->ldisc, NULL, 0, 0); break; - case 25: /* enable/disable cursor */ + case 25: /* DECTCEM: enable/disable cursor */ compatibility2(OTHER, VT220); term->cursor_on = state; term->seen_disp_event = TRUE; @@ -960,7 +1802,7 @@ static void toggle_mode(Terminal *term, int mode, int query, int state) case 47: /* alternate screen */ compatibility(OTHER); deselect(term); - swap_screen(term, cfg.no_alt_screen ? 0 : state, FALSE, FALSE); + swap_screen(term, term->cfg.no_alt_screen ? 0 : state, FALSE, FALSE); term->disptop = 0; break; case 1000: /* xterm mouse 1 */ @@ -974,39 +1816,40 @@ static void toggle_mode(Terminal *term, int mode, int query, int state) case 1047: /* alternate screen */ compatibility(OTHER); deselect(term); - swap_screen(term, cfg.no_alt_screen ? 0 : state, TRUE, TRUE); + swap_screen(term, term->cfg.no_alt_screen ? 0 : state, TRUE, TRUE); term->disptop = 0; break; case 1048: /* save/restore cursor */ - save_cursor(term, state); + if (!term->cfg.no_alt_screen) + save_cursor(term, state); if (!state) term->seen_disp_event = TRUE; break; case 1049: /* cursor & alternate screen */ - if (state) + if (state && !term->cfg.no_alt_screen) save_cursor(term, state); if (!state) term->seen_disp_event = TRUE; compatibility(OTHER); deselect(term); - swap_screen(term, cfg.no_alt_screen ? 0 : state, TRUE, FALSE); - if (!state) + swap_screen(term, term->cfg.no_alt_screen ? 0 : state, TRUE, FALSE); + if (!state && !term->cfg.no_alt_screen) save_cursor(term, state); term->disptop = 0; break; } else switch (mode) { - case 4: /* set insert mode */ + case 4: /* IRM: set insert mode */ compatibility(VT102); term->insert = state; break; - case 12: /* set echo mode */ + case 12: /* SRM: set echo mode */ term->term_echoing = !state; if (term->ldisc) /* cause ldisc to notice changes */ ldisc_send(term->ldisc, NULL, 0, 0); break; - case 20: /* Return sends ... */ + case 20: /* LNM: Return sends ... */ term->cr_lf_return = state; break; - case 34: /* Make cursor BIG */ + case 34: /* WYULCURM: Make cursor BIG */ compatibility2(OTHER, VT220); term->big_cursor = !state; } @@ -1026,14 +1869,14 @@ static void do_osc(Terminal *term) switch (term->esc_args[0]) { case 0: case 1: - if (!cfg.no_remote_wintitle) + if (!term->cfg.no_remote_wintitle) set_icon(term->frontend, term->osc_string); if (term->esc_args[0] == 1) break; /* fall through: parameter 0 means set both */ case 2: case 21: - if (!cfg.no_remote_wintitle) + if (!term->cfg.no_remote_wintitle) set_title(term->frontend, term->osc_string); break; } @@ -1046,7 +1889,7 @@ static void do_osc(Terminal *term) static void term_print_setup(Terminal *term) { bufchain_clear(&term->printer_buf); - term->print_job = printer_start_job(cfg.printer); + term->print_job = printer_start_job(term->cfg.printer); } static void term_print_flush(Terminal *term) { @@ -1094,7 +1937,8 @@ static void term_print_finish(Terminal *term) */ void term_out(Terminal *term) { - int c, unget; + unsigned long c; + int unget; unsigned char localbuf[256], *chars; int nchars = 0; @@ -1120,7 +1964,7 @@ void term_out(Terminal *term) * Optionally log the session traffic to a file. Useful for * debugging and possibly also useful for actual logging. */ - if (cfg.logtype == LGTYP_DEBUG && term->logctx) + if (term->cfg.logtype == LGTYP_DEBUG && term->logctx) logtraffic(term->logctx, (unsigned char) c, LGTYP_DEBUG); } else { c = unget; @@ -1171,9 +2015,9 @@ void term_out(Terminal *term) case 0: if (c < 0x80) { /* UTF-8 must be stateless so we ignore iso2022. */ - if (unitab_ctrl[c] != 0xFF) - c = unitab_ctrl[c]; - else c = ((unsigned char)c) | ATTR_ASCII; + if (term->ucsdata->unitab_ctrl[c] != 0xFF) + c = term->ucsdata->unitab_ctrl[c]; + else c = ((unsigned char)c) | CSET_ASCII; break; } else if ((c & 0xe0) == 0xc0) { term->utf_size = term->utf_state = 1; @@ -1249,17 +2093,14 @@ void term_out(Terminal *term) if (c == 0xFFFE || c == 0xFFFF) c = UCSERR; - /* Oops this is a 16bit implementation */ - if (c >= 0x10000) - c = 0xFFFD; break; } /* Are we in the nasty ACS mode? Note: no sco in utf mode. */ else if(term->sco_acs && (c!='\033' && c!='\012' && c!='\015' && c!='\b')) { - if (term->sco_acs == 2) c ^= 0x80; - c |= ATTR_SCOACS; + if (term->sco_acs == 2) c |= 0x80; + c |= CSET_SCOACS; } else { switch (term->cset_attr[term->cset]) { /* @@ -1268,27 +2109,27 @@ void term_out(Terminal *term) * range, make sure we use the same font as well as * the same encoding. */ - case ATTR_LINEDRW: - if (unitab_ctrl[c] != 0xFF) - c = unitab_ctrl[c]; + case CSET_LINEDRW: + if (term->ucsdata->unitab_ctrl[c] != 0xFF) + c = term->ucsdata->unitab_ctrl[c]; else - c = ((unsigned char) c) | ATTR_LINEDRW; + c = ((unsigned char) c) | CSET_LINEDRW; break; - case ATTR_GBCHR: + case CSET_GBCHR: /* If UK-ASCII, make the '#' a LineDraw Pound */ if (c == '#') { - c = '}' | ATTR_LINEDRW; + c = '}' | CSET_LINEDRW; break; } - /*FALLTHROUGH*/ case ATTR_ASCII: - if (unitab_ctrl[c] != 0xFF) - c = unitab_ctrl[c]; + /*FALLTHROUGH*/ case CSET_ASCII: + if (term->ucsdata->unitab_ctrl[c] != 0xFF) + c = term->ucsdata->unitab_ctrl[c]; else - c = ((unsigned char) c) | ATTR_ASCII; + c = ((unsigned char) c) | CSET_ASCII; break; - case ATTR_SCOACS: - if (c>=' ') c = ((unsigned char)c) | ATTR_SCOACS; + case CSET_SCOACS: + if (c>=' ') c = ((unsigned char)c) | CSET_SCOACS; break; } } @@ -1308,13 +2149,16 @@ void term_out(Terminal *term) term->curs.x--; term->wrapnext = FALSE; fix_cpos; - if (!cfg.no_dbackspace) /* destructive bksp might be disabled */ - *term->cpos = (' ' | term->curr_attr | ATTR_ASCII); + /* destructive backspace might be disabled */ + if (!term->cfg.no_dbackspace) { + term->cpos->chr = ' ' | CSET_ASCII; + term->cpos->attr = term->curr_attr; + } } else /* Or normal C0 controls. */ - if ((c & -32) == 0 && term->termstate < DO_CTRLS) { + if ((c & ~0x1F) == 0 && term->termstate < DO_CTRLS) { switch (c) { - case '\005': /* terminal type query */ + case '\005': /* ENQ: terminal type query */ /* Strictly speaking this is VT100 but a VT100 defaults to * no response. Other terminals respond at their option. * @@ -1327,7 +2171,7 @@ void term_out(Terminal *term) if (term->ldisc) { char abuf[256], *s, *d; int state = 0; - for (s = cfg.answerback, d = abuf; *s; s++) { + for (s = term->cfg.answerback, d = abuf; *s; s++) { if (state) { if (*s >= 'a' && *s <= 'z') *d++ = (*s - ('a' - 1)); @@ -1346,7 +2190,7 @@ void term_out(Terminal *term) abuf, d - abuf, 0); } break; - case '\007': + case '\007': /* BEL: Bell */ { struct beeptime *newbeep; unsigned long ticks; @@ -1354,7 +2198,7 @@ void term_out(Terminal *term) ticks = GETTICKCOUNT(); if (!term->beep_overloaded) { - newbeep = smalloc(sizeof(struct beeptime)); + newbeep = snew(struct beeptime); newbeep->ticks = ticks; newbeep->next = NULL; if (!term->beephead) @@ -1370,7 +2214,7 @@ void term_out(Terminal *term) * t seconds ago. */ while (term->beephead && - term->beephead->ticks < ticks - cfg.bellovl_t) { + term->beephead->ticks < ticks - term->cfg.bellovl_t) { struct beeptime *tmp = term->beephead; term->beephead = tmp->next; sfree(tmp); @@ -1379,16 +2223,16 @@ void term_out(Terminal *term) term->nbeeps--; } - if (cfg.bellovl && term->beep_overloaded && - ticks - term->lastbeep >= (unsigned)cfg.bellovl_s) { + if (term->cfg.bellovl && term->beep_overloaded && + ticks - term->lastbeep >= (unsigned)term->cfg.bellovl_s) { /* * If we're currently overloaded and the * last beep was more than s seconds ago, * leave overload mode. */ term->beep_overloaded = FALSE; - } else if (cfg.bellovl && !term->beep_overloaded && - term->nbeeps >= cfg.bellovl_n) { + } else if (term->cfg.bellovl && !term->beep_overloaded && + term->nbeeps >= term->cfg.bellovl_n) { /* * Now, if we have n or more beeps * remaining in the queue, go into overload @@ -1401,18 +2245,18 @@ void term_out(Terminal *term) /* * Perform an actual beep if we're not overloaded. */ - if (!cfg.bellovl || !term->beep_overloaded) { - beep(term->frontend, cfg.beep); - if (cfg.beep == BELL_VISUAL) { + if (!term->cfg.bellovl || !term->beep_overloaded) { + beep(term->frontend, term->cfg.beep); + if (term->cfg.beep == BELL_VISUAL) { term->in_vbell = TRUE; term->vbell_startpoint = ticks; term_update(term); } } - term->disptop = 0; + term->seen_disp_event = TRUE; } break; - case '\b': + case '\b': /* BS: Back space */ if (term->curs.x == 0 && (term->curs.y == 0 || term->wrap == 0)) /* do nothing */ ; @@ -1425,15 +2269,15 @@ void term_out(Terminal *term) fix_cpos; term->seen_disp_event = TRUE; break; - case '\016': + case '\016': /* LS1: Locking-shift one */ compatibility(VT100); term->cset = 1; break; - case '\017': + case '\017': /* LS0: Locking-shift zero */ compatibility(VT100); term->cset = 0; break; - case '\033': + case '\033': /* ESC: Escape */ if (term->vt52_mode) term->termstate = VT52_ESC; else { @@ -1442,7 +2286,7 @@ void term_out(Terminal *term) term->esc_query = FALSE; } break; - case '\015': + case '\015': /* CR: Carriage return */ term->curs.x = 0; term->wrapnext = FALSE; fix_cpos; @@ -1451,7 +2295,7 @@ void term_out(Terminal *term) if (term->logctx) logtraffic(term->logctx, (unsigned char) c, LGTYP_ASCII); break; - case '\014': + case '\014': /* FF: Form feed */ if (has_compat(SCOANSI)) { move(term, 0, 0, 0); erase_lots(term, FALSE, FALSE, TRUE); @@ -1460,14 +2304,14 @@ void term_out(Terminal *term) term->seen_disp_event = 1; break; } - case '\013': + case '\013': /* VT: Line tabulation */ compatibility(VT100); - case '\012': + case '\012': /* LF: Line feed */ if (term->curs.y == term->marg_b) scroll(term, term->marg_t, term->marg_b, 1, TRUE); else if (term->curs.y < term->rows - 1) term->curs.y++; - if (cfg.lfhascr) + if (term->cfg.lfhascr) term->curs.x = 0; fix_cpos; term->wrapnext = FALSE; @@ -1476,17 +2320,17 @@ void term_out(Terminal *term) if (term->logctx) logtraffic(term->logctx, (unsigned char) c, LGTYP_ASCII); break; - case '\t': + case '\t': /* HT: Character tabulation */ { pos old_curs = term->curs; - unsigned long *ldata = lineptr(term->curs.y); + termline *ldata = scrlineptr(term->curs.y); do { term->curs.x++; } while (term->curs.x < term->cols - 1 && !term->tabs[term->curs.x]); - if ((ldata[term->cols] & LATTR_MODE) != LATTR_NORM) { + if ((ldata->lattr & LATTR_MODE) != LATTR_NORM) { if (term->curs.x >= term->cols / 2) term->curs.x = term->cols / 2 - 1; } else { @@ -1506,7 +2350,7 @@ void term_out(Terminal *term) /* Only graphic characters get this far; * ctrls are stripped above */ if (term->wrapnext && term->wrap) { - term->cpos[1] |= LATTR_WRAPPED; + scrlineptr(term->curs.y)->lattr |= LATTR_WRAPPED; if (term->curs.y == term->marg_b) scroll(term, term->marg_t, term->marg_b, 1, TRUE); else if (term->curs.y < term->rows - 1) @@ -1522,11 +2366,10 @@ void term_out(Terminal *term) incpos(cursplus); check_selection(term, term->curs, cursplus); } - if (((c & CSET_MASK) == ATTR_ASCII || (c & CSET_MASK) == 0) && + if (((c & CSET_MASK) == CSET_ASCII || (c & CSET_MASK) == 0) && term->logctx) logtraffic(term->logctx, (unsigned char) c, LGTYP_ASCII); { - extern int wcwidth(wchar_t ucs); int width = 0; if (DIRECT_CHAR(c)) width = 1; @@ -1534,9 +2377,32 @@ void term_out(Terminal *term) width = wcwidth((wchar_t) c); switch (width) { case 2: - *term->cpos++ = c | term->curr_attr; - if (++term->curs.x == term->cols) { - *term->cpos |= LATTR_WRAPPED; + /* + * If we're about to display a double-width + * character starting in the rightmost + * column, then we do something special + * instead. We must print a space in the + * last column of the screen, then wrap; + * and we also set LATTR_WRAPPED2 which + * instructs subsequent cut-and-pasting not + * only to splice this line to the one + * after it, but to ignore the space in the + * last character position as well. + * (Because what was actually output to the + * terminal was presumably just a sequence + * of CJK characters, and we don't want a + * space to be pasted in the middle of + * those just because they had the + * misfortune to start in the wrong parity + * column. xterm concurs.) + */ + check_boundary(term, term->curs.x, term->curs.y); + check_boundary(term, term->curs.x+2, term->curs.y); + if (term->curs.x == term->cols-1) { + term->cpos->chr = CSET_ASCII | ' '; + term->cpos->attr = term->curr_attr; + scrlineptr(term->curs.y)->lattr |= + LATTR_WRAPPED | LATTR_WRAPPED2; if (term->curs.y == term->marg_b) scroll(term, term->marg_t, term->marg_b, 1, TRUE); @@ -1544,11 +2410,23 @@ void term_out(Terminal *term) term->curs.y++; term->curs.x = 0; fix_cpos; + /* Now we must check_boundary again, of course. */ + check_boundary(term, term->curs.x, term->curs.y); + check_boundary(term, term->curs.x+2, term->curs.y); } - *term->cpos++ = UCSWIDE | term->curr_attr; + term->cpos->chr = c; + term->cpos->attr = term->curr_attr; + term->cpos++; + term->cpos->chr = UCSWIDE; + term->cpos->attr = term->curr_attr; + term->curs.x++; break; case 1: - *term->cpos++ = c | term->curr_attr; + check_boundary(term, term->curs.x, term->curs.y); + check_boundary(term, term->curs.x+1, term->curs.y); + term->cpos->chr = c; + term->cpos->attr = term->curr_attr; + term->cpos++; break; default: continue; @@ -1560,7 +2438,7 @@ void term_out(Terminal *term) term->curs.x--; term->wrapnext = TRUE; if (term->wrap && term->vt52_mode) { - term->cpos[1] |= LATTR_WRAPPED; + scrlineptr(term->curs.y)->lattr |= LATTR_WRAPPED; if (term->curs.y == term->marg_b) scroll(term, term->marg_t, term->marg_b, 1, TRUE); else if (term->curs.y < term->rows - 1) @@ -1595,36 +2473,36 @@ void term_out(Terminal *term) } term->termstate = TOPLEVEL; switch (ANSI(c, term->esc_query)) { - case '[': /* enter CSI mode */ + case '[': /* enter CSI mode */ term->termstate = SEEN_CSI; term->esc_nargs = 1; term->esc_args[0] = ARG_DEFAULT; term->esc_query = FALSE; break; - case ']': /* xterm escape sequences */ + case ']': /* OSC: xterm escape sequences */ /* Compatibility is nasty here, xterm, linux, decterm yuk! */ compatibility(OTHER); term->termstate = SEEN_OSC; term->esc_args[0] = 0; break; - case '7': /* save cursor */ + case '7': /* DECSC: save cursor */ compatibility(VT100); save_cursor(term, TRUE); break; - case '8': /* restore cursor */ + case '8': /* DECRC: restore cursor */ compatibility(VT100); save_cursor(term, FALSE); term->seen_disp_event = TRUE; break; - case '=': + case '=': /* DECKPAM: Keypad application mode */ compatibility(VT100); term->app_keypad_keys = TRUE; break; - case '>': + case '>': /* DECKPNM: Keypad numeric mode */ compatibility(VT100); term->app_keypad_keys = FALSE; break; - case 'D': /* exactly equivalent to LF */ + case 'D': /* IND: exactly equivalent to LF */ compatibility(VT100); if (term->curs.y == term->marg_b) scroll(term, term->marg_t, term->marg_b, 1, TRUE); @@ -1634,7 +2512,7 @@ void term_out(Terminal *term) term->wrapnext = FALSE; term->seen_disp_event = TRUE; break; - case 'E': /* exactly equivalent to CR-LF */ + case 'E': /* NEL: exactly equivalent to CR-LF */ compatibility(VT100); term->curs.x = 0; if (term->curs.y == term->marg_b) @@ -1645,7 +2523,7 @@ void term_out(Terminal *term) term->wrapnext = FALSE; term->seen_disp_event = TRUE; break; - case 'M': /* reverse index - backwards LF */ + case 'M': /* RI: reverse index - backwards LF */ compatibility(VT100); if (term->curs.y == term->marg_t) scroll(term, term->marg_t, term->marg_b, -1, TRUE); @@ -1655,19 +2533,19 @@ void term_out(Terminal *term) term->wrapnext = FALSE; term->seen_disp_event = TRUE; break; - case 'Z': /* terminal type query */ + case 'Z': /* DECID: terminal type query */ compatibility(VT100); if (term->ldisc) ldisc_send(term->ldisc, term->id_string, strlen(term->id_string), 0); break; - case 'c': /* restore power-on settings */ + case 'c': /* RIS: restore power-on settings */ compatibility(VT100); power_on(term); if (term->ldisc) /* cause ldisc to notice changes */ ldisc_send(term->ldisc, NULL, 0, 0); if (term->reset_132) { - if (!cfg.no_remote_resize) + if (!term->cfg.no_remote_resize) request_resize(term->frontend, 80, term->rows); term->reset_132 = 0; } @@ -1675,23 +2553,25 @@ void term_out(Terminal *term) term->disptop = 0; term->seen_disp_event = TRUE; break; - case 'H': /* set a tab */ + case 'H': /* HTS: set a tab */ compatibility(VT100); term->tabs[term->curs.x] = TRUE; break; - case ANSI('8', '#'): /* ESC # 8 fills screen with Es :-) */ + case ANSI('8', '#'): /* DECALN: fills screen with Es :-) */ compatibility(VT100); { - unsigned long *ldata; + termline *ldata; int i, j; pos scrtop, scrbot; for (i = 0; i < term->rows; i++) { - ldata = lineptr(i); - for (j = 0; j < term->cols; j++) - ldata[j] = ATTR_DEFAULT | 'E'; - ldata[term->cols] = 0; + ldata = scrlineptr(i); + for (j = 0; j < term->cols; j++) { + ldata->chars[j] = term->basic_erase_char; + ldata->chars[j].chr = 'E'; + } + ldata->lattr = LATTR_NORM; } term->disptop = 0; term->seen_disp_event = TRUE; @@ -1708,79 +2588,77 @@ void term_out(Terminal *term) case ANSI('6', '#'): compatibility(VT100); { - unsigned long nlattr; - unsigned long *ldata; + int nlattr; + switch (ANSI(c, term->esc_query)) { - case ANSI('3', '#'): + case ANSI('3', '#'): /* DECDHL: 2*height, top */ nlattr = LATTR_TOP; break; - case ANSI('4', '#'): + case ANSI('4', '#'): /* DECDHL: 2*height, bottom */ nlattr = LATTR_BOT; break; - case ANSI('5', '#'): + case ANSI('5', '#'): /* DECSWL: normal */ nlattr = LATTR_NORM; break; - default: /* spiritually case ANSI('6', '#'): */ + default: /* case ANSI('6', '#'): DECDWL: 2*width */ nlattr = LATTR_WIDE; break; } - ldata = lineptr(term->curs.y); - ldata[term->cols] &= ~LATTR_MODE; - ldata[term->cols] |= nlattr; + scrlineptr(term->curs.y)->lattr = nlattr; } break; - + /* GZD4: G0 designate 94-set */ case ANSI('A', '('): compatibility(VT100); - if (!cfg.no_remote_charset) - term->cset_attr[0] = ATTR_GBCHR; + if (!term->cfg.no_remote_charset) + term->cset_attr[0] = CSET_GBCHR; break; case ANSI('B', '('): compatibility(VT100); - if (!cfg.no_remote_charset) - term->cset_attr[0] = ATTR_ASCII; + if (!term->cfg.no_remote_charset) + term->cset_attr[0] = CSET_ASCII; break; case ANSI('0', '('): compatibility(VT100); - if (!cfg.no_remote_charset) - term->cset_attr[0] = ATTR_LINEDRW; + if (!term->cfg.no_remote_charset) + term->cset_attr[0] = CSET_LINEDRW; break; case ANSI('U', '('): compatibility(OTHER); - if (!cfg.no_remote_charset) - term->cset_attr[0] = ATTR_SCOACS; + if (!term->cfg.no_remote_charset) + term->cset_attr[0] = CSET_SCOACS; break; - + /* G1D4: G1-designate 94-set */ case ANSI('A', ')'): compatibility(VT100); - if (!cfg.no_remote_charset) - term->cset_attr[1] = ATTR_GBCHR; + if (!term->cfg.no_remote_charset) + term->cset_attr[1] = CSET_GBCHR; break; case ANSI('B', ')'): compatibility(VT100); - if (!cfg.no_remote_charset) - term->cset_attr[1] = ATTR_ASCII; + if (!term->cfg.no_remote_charset) + term->cset_attr[1] = CSET_ASCII; break; case ANSI('0', ')'): compatibility(VT100); - if (!cfg.no_remote_charset) - term->cset_attr[1] = ATTR_LINEDRW; + if (!term->cfg.no_remote_charset) + term->cset_attr[1] = CSET_LINEDRW; break; case ANSI('U', ')'): compatibility(OTHER); - if (!cfg.no_remote_charset) - term->cset_attr[1] = ATTR_SCOACS; + if (!term->cfg.no_remote_charset) + term->cset_attr[1] = CSET_SCOACS; break; - + /* DOCS: Designate other coding system */ case ANSI('8', '%'): /* Old Linux code */ case ANSI('G', '%'): compatibility(OTHER); - if (!cfg.no_remote_charset) + if (!term->cfg.no_remote_charset) term->utf = 1; break; case ANSI('@', '%'): compatibility(OTHER); - if (!cfg.no_remote_charset) + if (!term->cfg.no_remote_charset) term->utf = 0; break; } @@ -1809,59 +2687,59 @@ void term_out(Terminal *term) term->termstate = SEEN_CSI; } else switch (ANSI(c, term->esc_query)) { - case 'A': /* move up N lines */ + case 'A': /* CUU: move up N lines */ move(term, term->curs.x, term->curs.y - def(term->esc_args[0], 1), 1); term->seen_disp_event = TRUE; break; - case 'e': /* move down N lines */ + case 'e': /* VPR: move down N lines */ compatibility(ANSI); /* FALLTHROUGH */ - case 'B': + case 'B': /* CUD: Cursor down */ move(term, term->curs.x, term->curs.y + def(term->esc_args[0], 1), 1); term->seen_disp_event = TRUE; break; - case ANSI('c', '>'): /* report xterm version */ + case ANSI('c', '>'): /* DA: report xterm version */ compatibility(OTHER); /* this reports xterm version 136 so that VIM can use the drag messages from the mouse reporting */ if (term->ldisc) ldisc_send(term->ldisc, "\033[>0;136;0c", 11, 0); break; - case 'a': /* move right N cols */ + case 'a': /* HPR: move right N cols */ compatibility(ANSI); /* FALLTHROUGH */ - case 'C': + case 'C': /* CUF: Cursor right */ move(term, term->curs.x + def(term->esc_args[0], 1), term->curs.y, 1); term->seen_disp_event = TRUE; break; - case 'D': /* move left N cols */ + case 'D': /* CUB: move left N cols */ move(term, term->curs.x - def(term->esc_args[0], 1), term->curs.y, 1); term->seen_disp_event = TRUE; break; - case 'E': /* move down N lines and CR */ + case 'E': /* CNL: move down N lines and CR */ compatibility(ANSI); move(term, 0, term->curs.y + def(term->esc_args[0], 1), 1); term->seen_disp_event = TRUE; break; - case 'F': /* move up N lines and CR */ + case 'F': /* CPL: move up N lines and CR */ compatibility(ANSI); move(term, 0, term->curs.y - def(term->esc_args[0], 1), 1); term->seen_disp_event = TRUE; break; - case 'G': - case '`': /* set horizontal posn */ + case 'G': /* CHA */ + case '`': /* HPA: set horizontal posn */ compatibility(ANSI); move(term, def(term->esc_args[0], 1) - 1, term->curs.y, 0); term->seen_disp_event = TRUE; break; - case 'd': /* set vertical posn */ + case 'd': /* VPA: set vertical posn */ compatibility(ANSI); move(term, term->curs.x, ((term->dec_om ? term->marg_t : 0) + @@ -1869,8 +2747,8 @@ void term_out(Terminal *term) (term->dec_om ? 2 : 0)); term->seen_disp_event = TRUE; break; - case 'H': - case 'f': /* set horz and vert posns at once */ + case 'H': /* CUP */ + case 'f': /* HVP: set horz and vert posns at once */ if (term->esc_nargs < 2) term->esc_args[1] = ARG_DEFAULT; move(term, def(term->esc_args[1], 1) - 1, @@ -1879,7 +2757,7 @@ void term_out(Terminal *term) (term->dec_om ? 2 : 0)); term->seen_disp_event = TRUE; break; - case 'J': /* erase screen or parts of it */ + case 'J': /* ED: erase screen or parts of it */ { unsigned int i = def(term->esc_args[0], 0) + 1; if (i > 3) @@ -1889,7 +2767,7 @@ void term_out(Terminal *term) term->disptop = 0; term->seen_disp_event = TRUE; break; - case 'K': /* erase line or parts of it */ + case 'K': /* EL: erase line or parts of it */ { unsigned int i = def(term->esc_args[0], 0) + 1; if (i > 3) @@ -1898,7 +2776,7 @@ void term_out(Terminal *term) } term->seen_disp_event = TRUE; break; - case 'L': /* insert lines */ + case 'L': /* IL: insert lines */ compatibility(VT102); if (term->curs.y <= term->marg_b) scroll(term, term->curs.y, term->marg_b, @@ -1906,7 +2784,7 @@ void term_out(Terminal *term) fix_cpos; term->seen_disp_event = TRUE; break; - case 'M': /* delete lines */ + case 'M': /* DL: delete lines */ compatibility(VT102); if (term->curs.y <= term->marg_b) scroll(term, term->curs.y, term->marg_b, @@ -1915,25 +2793,25 @@ void term_out(Terminal *term) fix_cpos; term->seen_disp_event = TRUE; break; - case '@': /* insert chars */ + case '@': /* ICH: insert chars */ /* XXX VTTEST says this is vt220, vt510 manual says vt102 */ compatibility(VT102); insch(term, def(term->esc_args[0], 1)); term->seen_disp_event = TRUE; break; - case 'P': /* delete chars */ + case 'P': /* DCH: delete chars */ compatibility(VT102); insch(term, -def(term->esc_args[0], 1)); term->seen_disp_event = TRUE; break; - case 'c': /* terminal type query */ + case 'c': /* DA: terminal type query */ compatibility(VT100); /* This is the response for a VT102 */ if (term->ldisc) ldisc_send(term->ldisc, term->id_string, strlen(term->id_string), 0); break; - case 'n': /* cursor position query */ + case 'n': /* DSR: cursor position query */ if (term->ldisc) { if (term->esc_args[0] == 6) { char buf[32]; @@ -1945,7 +2823,7 @@ void term_out(Terminal *term) } } break; - case 'h': /* toggle modes to high */ + case 'h': /* SM: toggle modes to high */ case ANSI_QUE('h'): compatibility(VT100); { @@ -1955,12 +2833,12 @@ void term_out(Terminal *term) term->esc_query, TRUE); } break; - case 'i': + case 'i': /* MC: Media copy */ case ANSI_QUE('i'): compatibility(VT100); { if (term->esc_nargs != 1) break; - if (term->esc_args[0] == 5 && *cfg.printer) { + if (term->esc_args[0] == 5 && *term->cfg.printer) { term->printing = TRUE; term->only_printing = !term->esc_query; term->print_state = 0; @@ -1971,7 +2849,7 @@ void term_out(Terminal *term) } } break; - case 'l': /* toggle modes to low */ + case 'l': /* RM: toggle modes to low */ case ANSI_QUE('l'): compatibility(VT100); { @@ -1981,7 +2859,7 @@ void term_out(Terminal *term) term->esc_query, FALSE); } break; - case 'g': /* clear tabs */ + case 'g': /* TBC: clear tabs */ compatibility(VT100); if (term->esc_nargs == 1) { if (term->esc_args[0] == 0) { @@ -1993,7 +2871,7 @@ void term_out(Terminal *term) } } break; - case 'r': /* set scroll margins */ + case 'r': /* DECSTBM: set scroll margins */ compatibility(VT100); if (term->esc_nargs <= 2) { int top, bot; @@ -2027,7 +2905,7 @@ void term_out(Terminal *term) } } break; - case 'm': /* set graphics rendition */ + case 'm': /* SGR: set graphics rendition */ { /* * A VT100 without the AVO only had one @@ -2061,7 +2939,7 @@ void term_out(Terminal *term) for (i = 0; i < term->esc_nargs; i++) { switch (def(term->esc_args[i], 0)) { case 0: /* restore defaults */ - term->curr_attr = ATTR_DEFAULT; + term->curr_attr = term->default_attr; break; case 1: /* enable bold */ compatibility(VT100AVO); @@ -2077,20 +2955,25 @@ void term_out(Terminal *term) compatibility(VT100AVO); term->curr_attr |= ATTR_BLINK; break; + case 6: /* SCO light bkgrd */ + compatibility(SCOANSI); + term->blink_is_real = FALSE; + term->curr_attr |= ATTR_BLINK; + break; case 7: /* enable reverse video */ term->curr_attr |= ATTR_REVERSE; break; case 10: /* SCO acs off */ compatibility(SCOANSI); - if (cfg.no_remote_charset) break; + if (term->cfg.no_remote_charset) break; term->sco_acs = 0; break; case 11: /* SCO acs on */ compatibility(SCOANSI); - if (cfg.no_remote_charset) break; + if (term->cfg.no_remote_charset) break; term->sco_acs = 1; break; - case 12: /* SCO acs on flipped */ + case 12: /* SCO acs on, |0x80 */ compatibility(SCOANSI); - if (cfg.no_remote_charset) break; + if (term->cfg.no_remote_charset) break; term->sco_acs = 2; break; case 22: /* disable bold */ compatibility2(OTHER, VT220); @@ -2121,6 +3004,20 @@ void term_out(Terminal *term) term->curr_attr |= (term->esc_args[i] - 30)<curr_attr &= ~ATTR_FGMASK; + term->curr_attr |= + ((term->esc_args[i] - 90 + 16) + << ATTR_FGSHIFT); + break; case 39: /* default-foreground */ term->curr_attr &= ~ATTR_FGMASK; term->curr_attr |= ATTR_DEFFG; @@ -2138,17 +3035,27 @@ void term_out(Terminal *term) term->curr_attr |= (term->esc_args[i] - 40)<curr_attr &= ~ATTR_BGMASK; + term->curr_attr |= + ((term->esc_args[i] - 100 + 16) + << ATTR_BGSHIFT); + break; case 49: /* default-background */ term->curr_attr &= ~ATTR_BGMASK; term->curr_attr |= ATTR_DEFBG; break; } } - if (term->use_bce) - term->erase_char = (' ' | ATTR_ASCII | - (term->curr_attr & - (ATTR_FGMASK | - ATTR_BGMASK))); + set_erase_char(term); } break; case 's': /* save cursor */ @@ -2158,7 +3065,7 @@ void term_out(Terminal *term) save_cursor(term, FALSE); term->seen_disp_event = TRUE; break; - case 't': /* set page size - ie window height */ + case 't': /* DECSLPP: set page size - ie window height */ /* * VT340/VT420 sequence DECSLPP, DEC only allows values * 24/25/36/48/72/144 other emulators (eg dtterm) use @@ -2169,7 +3076,7 @@ void term_out(Terminal *term) && (term->esc_args[0] < 1 || term->esc_args[0] >= 24)) { compatibility(VT340TEXT); - if (!cfg.no_remote_resize) + if (!term->cfg.no_remote_resize) request_resize(term->frontend, term->cols, def(term->esc_args[0], 24)); deselect(term); @@ -2189,7 +3096,7 @@ void term_out(Terminal *term) break; case 3: if (term->esc_nargs >= 3) { - if (!cfg.no_remote_resize) + if (!term->cfg.no_remote_resize) move_window(term->frontend, def(term->esc_args[1], 0), def(term->esc_args[2], 0)); @@ -2214,10 +3121,10 @@ void term_out(Terminal *term) break; case 8: if (term->esc_nargs >= 3) { - if (!cfg.no_remote_resize) + if (!term->cfg.no_remote_resize) request_resize(term->frontend, - def(term->esc_args[2], cfg.width), - def(term->esc_args[1], cfg.height)); + def(term->esc_args[2], term->cfg.width), + def(term->esc_args[1], term->cfg.height)); } break; case 9: @@ -2271,7 +3178,8 @@ void term_out(Terminal *term) */ break; case 20: - if (term->ldisc) { + if (term->ldisc && + !term->cfg.no_remote_qtitle) { p = get_window_title(term->frontend, TRUE); len = strlen(p); ldisc_send(term->ldisc, "\033]L", 3, 0); @@ -2280,7 +3188,8 @@ void term_out(Terminal *term) } break; case 21: - if (term->ldisc) { + if (term->ldisc && + !term->cfg.no_remote_qtitle) { p = get_window_title(term->frontend,FALSE); len = strlen(p); ldisc_send(term->ldisc, "\033]l", 3, 0); @@ -2291,7 +3200,7 @@ void term_out(Terminal *term) } } break; - case 'S': + case 'S': /* SU: Scroll up */ compatibility(SCOANSI); scroll(term, term->marg_t, term->marg_b, def(term->esc_args[0], 1), TRUE); @@ -2299,7 +3208,7 @@ void term_out(Terminal *term) term->wrapnext = FALSE; term->seen_disp_event = TRUE; break; - case 'T': + case 'T': /* SD: Scroll down */ compatibility(SCOANSI); scroll(term, term->marg_t, term->marg_b, -def(term->esc_args[0], 1), TRUE); @@ -2307,53 +3216,58 @@ void term_out(Terminal *term) term->wrapnext = FALSE; term->seen_disp_event = TRUE; break; - case ANSI('|', '*'): - /* VT420 sequence DECSNLS + case ANSI('|', '*'): /* DECSNLS */ + /* * Set number of lines on screen - * VT420 uses VGA like hardware and can support any size in - * reasonable range (24..49 AIUI) with no default specified. + * VT420 uses VGA like hardware and can + * support any size in reasonable range + * (24..49 AIUI) with no default specified. */ compatibility(VT420); if (term->esc_nargs == 1 && term->esc_args[0] > 0) { - if (!cfg.no_remote_resize) + if (!term->cfg.no_remote_resize) request_resize(term->frontend, term->cols, def(term->esc_args[0], - cfg.height)); + term->cfg.height)); deselect(term); } break; - case ANSI('|', '$'): - /* VT340/VT420 sequence DECSCPP + case ANSI('|', '$'): /* DECSCPP */ + /* * Set number of columns per page - * Docs imply range is only 80 or 132, but I'll allow any. + * Docs imply range is only 80 or 132, but + * I'll allow any. */ compatibility(VT340TEXT); if (term->esc_nargs <= 1) { - if (!cfg.no_remote_resize) + if (!term->cfg.no_remote_resize) request_resize(term->frontend, def(term->esc_args[0], - cfg.width), term->rows); + term->cfg.width), term->rows); deselect(term); } break; - case 'X': /* write N spaces w/o moving cursor */ - /* XXX VTTEST says this is vt220, vt510 manual says vt100 */ + case 'X': /* ECH: write N spaces w/o moving cursor */ + /* XXX VTTEST says this is vt220, vt510 manual + * says vt100 */ compatibility(ANSIMIN); { int n = def(term->esc_args[0], 1); pos cursplus; - unsigned long *p = term->cpos; + termchar *p = term->cpos; if (n > term->cols - term->curs.x) n = term->cols - term->curs.x; cursplus = term->curs; cursplus.x += n; + check_boundary(term, term->curs.x, term->curs.y); + check_boundary(term, term->curs.x+n, term->curs.y); check_selection(term, term->curs, cursplus); while (n--) *p++ = term->erase_char; term->seen_disp_event = TRUE; } break; - case 'x': /* report terminal characteristics */ + case 'x': /* DECREQTPARM: report terminal characteristics */ compatibility(VT100); if (term->ldisc) { char buf[32]; @@ -2365,7 +3279,7 @@ void term_out(Terminal *term) } } break; - case 'Z': /* BackTab for xterm */ + case 'Z': /* CBT: BackTab for xterm */ compatibility(OTHER); { int i = def(term->esc_args[0], 1); @@ -2381,20 +3295,81 @@ void term_out(Terminal *term) check_selection(term, old_curs, term->curs); } break; - case ANSI('L', '='): - compatibility(OTHER); - term->use_bce = (term->esc_args[0] <= 0); - term->erase_char = ERASE_CHAR; - if (term->use_bce) - term->erase_char = (' ' | ATTR_ASCII | - (term->curr_attr & - (ATTR_FGMASK | ATTR_BGMASK))); + case ANSI('c', '='): /* Hide or Show Cursor */ + compatibility(SCOANSI); + switch(term->esc_args[0]) { + case 0: /* hide cursor */ + term->cursor_on = FALSE; + break; + case 1: /* restore cursor */ + term->big_cursor = FALSE; + term->cursor_on = TRUE; + break; + case 2: /* block cursor */ + term->big_cursor = TRUE; + term->cursor_on = TRUE; + break; + } + break; + case ANSI('C', '='): + /* + * set cursor start on scanline esc_args[0] and + * end on scanline esc_args[1].If you set + * the bottom scan line to a value less than + * the top scan line, the cursor will disappear. + */ + compatibility(SCOANSI); + if (term->esc_nargs >= 2) { + if (term->esc_args[0] > term->esc_args[1]) + term->cursor_on = FALSE; + else + term->cursor_on = TRUE; + } + break; + case ANSI('D', '='): + compatibility(SCOANSI); + term->blink_is_real = FALSE; + if (term->esc_args[0]>=1) + term->curr_attr |= ATTR_BLINK; + else + term->curr_attr &= ~ATTR_BLINK; break; case ANSI('E', '='): - compatibility(OTHER); + compatibility(SCOANSI); term->blink_is_real = (term->esc_args[0] >= 1); break; - case ANSI('p', '"'): + case ANSI('F', '='): /* set normal foreground */ + compatibility(SCOANSI); + if (term->esc_args[0] >= 0 && term->esc_args[0] < 16) { + long colour = + (sco2ansicolour[term->esc_args[0] & 0x7] | + ((term->esc_args[0] & 0x8) << 1)) << + ATTR_FGSHIFT; + term->curr_attr &= ~ATTR_FGMASK; + term->curr_attr |= colour; + term->default_attr &= ~ATTR_FGMASK; + term->default_attr |= colour; + } + break; + case ANSI('G', '='): /* set normal background */ + compatibility(SCOANSI); + if (term->esc_args[0] >= 0 && term->esc_args[0] < 16) { + long colour = + (sco2ansicolour[term->esc_args[0] & 0x7] | + ((term->esc_args[0] & 0x8) << 1)) << + ATTR_BGSHIFT; + term->curr_attr &= ~ATTR_BGMASK; + term->curr_attr |= colour; + term->default_attr &= ~ATTR_BGMASK; + term->default_attr |= colour; + } + break; + case ANSI('L', '='): + compatibility(SCOANSI); + term->use_bce = (term->esc_args[0] <= 0); + set_erase_char(term); + break; + case ANSI('p', '"'): /* DECSCL: set compat level */ /* * Allow the host to make this emulator a * 'perfect' VT102. This first appeared in @@ -2464,7 +3439,7 @@ void term_out(Terminal *term) * Well we should do a soft reset at this point ... */ if (!has_compat(VT420) && has_compat(VT100)) { - if (!cfg.no_remote_resize) { + if (!term->cfg.no_remote_resize) { if (term->reset_132) request_resize(132, 24); else @@ -2544,17 +3519,17 @@ void term_out(Terminal *term) } else if (c == '\033') term->termstate = OSC_MAYBE_ST; else if (term->osc_strlen < OSC_STR_MAX) - term->osc_string[term->osc_strlen++] = c; + term->osc_string[term->osc_strlen++] = (char)c; break; case SEEN_OSC_P: { int max = (term->osc_strlen == 0 ? 21 : 16); int val; - if (c >= '0' && c <= '9') + if ((int)c >= '0' && (int)c <= '9') val = c - '0'; - else if (c >= 'A' && c <= 'A' + max - 10) + else if ((int)c >= 'A' && (int)c <= 'A' + max - 10) val = c - 'A' + 10; - else if (c >= 'a' && c <= 'a' + max - 10) + else if ((int)c >= 'a' && (int)c <= 'a' + max - 10) val = c - 'a' + 10; else { term->termstate = TOPLEVEL; @@ -2647,10 +3622,10 @@ void term_out(Terminal *term) * */ case 'F': - term->cset_attr[term->cset = 0] = ATTR_LINEDRW; + term->cset_attr[term->cset = 0] = CSET_LINEDRW; break; case 'G': - term->cset_attr[term->cset = 0] = ATTR_ASCII; + term->cset_attr[term->cset = 0] = CSET_ASCII; break; case 'H': move(term, 0, 0, 0); @@ -2700,7 +3675,7 @@ void term_out(Terminal *term) * emulation. */ term->vt52_mode = FALSE; - term->blink_is_real = cfg.blinktext; + term->blink_is_real = term->cfg.blinktext; break; #if 0 case '^': @@ -2786,10 +3761,7 @@ void term_out(Terminal *term) /* compatibility(OTHER) */ term->vt52_bold = FALSE; term->curr_attr = ATTR_DEFAULT; - if (term->use_bce) - term->erase_char = (' ' | ATTR_ASCII | - (term->curr_attr & - (ATTR_FGMASK | ATTR_BGMASK))); + set_erase_char(term); break; case 'S': /* compatibility(VI50) */ @@ -2830,10 +3802,7 @@ void term_out(Terminal *term) if ((c & 0x8) || term->vt52_bold) term->curr_attr |= ATTR_BOLD; - if (term->use_bce) - term->erase_char = (' ' | ATTR_ASCII | - (term->curr_attr & - (ATTR_FGMASK | ATTR_BGMASK))); + set_erase_char(term); break; case VT52_BG: term->termstate = TOPLEVEL; @@ -2845,10 +3814,7 @@ void term_out(Terminal *term) if (c & 0x8) term->curr_attr |= ATTR_BLINK; - if (term->use_bce) - term->erase_char = (' ' | ATTR_ASCII | - (term->curr_attr & - (ATTR_FGMASK | ATTR_BGMASK))); + set_erase_char(term); break; #endif default: break; /* placate gcc warning about enum use */ @@ -2861,23 +3827,59 @@ void term_out(Terminal *term) } term_print_flush(term); + logflush(term->logctx); } -#if 0 /* - * Compare two lines to determine whether they are sufficiently - * alike to scroll-optimise one to the other. Return the degree of - * similarity. + * To prevent having to run the reasonably tricky bidi algorithm + * too many times, we maintain a cache of the last lineful of data + * fed to the algorithm on each line of the display. */ -static int linecmp(Terminal *term, unsigned long *a, unsigned long *b) +static int term_bidi_cache_hit(Terminal *term, int line, + termchar *lbefore, int width) { - int i, n; + if (!term->pre_bidi_cache) + return FALSE; /* cache doesn't even exist yet! */ + + if (line >= term->bidi_cache_size) + return FALSE; /* cache doesn't have this many lines */ + + if (!term->pre_bidi_cache[line]) + return FALSE; /* cache doesn't contain _this_ line */ - for (i = n = 0; i < term->cols; i++) - n += (*a++ == *b++); - return n; + if (!memcmp(term->pre_bidi_cache[line], lbefore, width * TSIZE)) + return TRUE; /* aha! the line matches the cache */ + + return FALSE; /* it didn't match. */ +} + +static void term_bidi_cache_store(Terminal *term, int line, termchar *lbefore, + termchar *lafter, int width) +{ + if (!term->pre_bidi_cache || term->bidi_cache_size <= line) { + int j = term->bidi_cache_size; + term->bidi_cache_size = line+1; + term->pre_bidi_cache = sresize(term->pre_bidi_cache, + term->bidi_cache_size, + termchar *); + term->post_bidi_cache = sresize(term->post_bidi_cache, + term->bidi_cache_size, + termchar *); + while (j < term->bidi_cache_size) { + term->pre_bidi_cache[j] = term->post_bidi_cache[j] = NULL; + j++; + } + } + + sfree(term->pre_bidi_cache[line]); + sfree(term->post_bidi_cache[line]); + + term->pre_bidi_cache[line] = snewn(width, termchar); + term->post_bidi_cache[line] = snewn(width, termchar); + + memcpy(term->pre_bidi_cache[line], lbefore, width * TSIZE); + memcpy(term->post_bidi_cache[line], lafter, width * TSIZE); } -#endif /* * Given a context, update the window. Out of paranoia, we don't @@ -2885,12 +3887,17 @@ static int linecmp(Terminal *term, unsigned long *a, unsigned long *b) */ static void do_paint(Terminal *term, Context ctx, int may_optimise) { - int i, j, our_curs_y; - unsigned long rv, cursor; + int i, it, j, our_curs_y, our_curs_x; + int rv, cursor; pos scrpos; - char ch[1024]; - long cursor_background = ERASE_CHAR; + wchar_t ch[1024]; + termchar cursor_background; unsigned long ticks; +#ifdef OPTIMISE_SCROLL + struct scrollregion *sr; +#endif /* OPTIMISE_SCROLL */ + + cursor_background = term->basic_erase_char; /* * Check the visual bell state. @@ -2898,8 +3905,8 @@ static void do_paint(Terminal *term, Context ctx, int may_optimise) if (term->in_vbell) { ticks = GETTICKCOUNT(); if (ticks - term->vbell_startpoint >= VBELL_TIMEOUT) - term->in_vbell = FALSE; - } + term->in_vbell = FALSE; + } rv = (!term->rvideo ^ !term->in_vbell ? ATTR_REVERSE : 0); @@ -2913,7 +3920,7 @@ static void do_paint(Terminal *term, Context ctx, int may_optimise) /* Has the cursor position or type changed ? */ if (term->cursor_on) { if (term->has_focus) { - if (term->blinker || !cfg.blink_cur) + if (term->blinker || !term->cfg.blink_cur) cursor = TATTR_ACTCURS; else cursor = 0; @@ -2924,27 +3931,62 @@ static void do_paint(Terminal *term, Context ctx, int may_optimise) } else cursor = 0; our_curs_y = term->curs.y - term->disptop; + { + /* + * Adjust the cursor position in the case where it's + * resting on the right-hand half of a CJK wide character. + * xterm's behaviour here, which seems adequate to me, is + * to display the cursor covering the _whole_ character, + * exactly as if it were one space to the left. + */ + termline *ldata = lineptr(term->curs.y); + our_curs_x = term->curs.x; + if (our_curs_x > 0 && + ldata->chars[our_curs_x].chr == UCSWIDE) + our_curs_x--; + unlineptr(ldata); + } + + /* + * If the cursor is not where it was last time we painted, and + * its previous position is visible on screen, invalidate its + * previous position. + */ + if (term->dispcursy >= 0 && + (term->curstype != cursor || + term->dispcursy != our_curs_y || + term->dispcursx != our_curs_x)) { + termchar *dispcurs = term->disptext[term->dispcursy]->chars + + term->dispcursx; + + if (term->dispcursx > 0 && dispcurs->chr == UCSWIDE) + dispcurs[-1].attr |= ATTR_INVALID; + if (term->dispcursx < term->cols-1 && dispcurs[1].chr == UCSWIDE) + dispcurs[1].attr |= ATTR_INVALID; + dispcurs->attr |= ATTR_INVALID; - if (term->dispcurs && (term->curstype != cursor || - term->dispcurs != - term->disptext + our_curs_y * (term->cols + 1) + - term->curs.x)) { - if (term->dispcurs > term->disptext && - (*term->dispcurs & (CHAR_MASK | CSET_MASK)) == UCSWIDE) - term->dispcurs[-1] |= ATTR_INVALID; - if ( (term->dispcurs[1] & (CHAR_MASK | CSET_MASK)) == UCSWIDE) - term->dispcurs[1] |= ATTR_INVALID; - *term->dispcurs |= ATTR_INVALID; term->curstype = 0; } - term->dispcurs = NULL; + term->dispcursx = term->dispcursy = -1; + +#ifdef OPTIMISE_SCROLL + /* Do scrolls */ + sr = term->scrollhead; + while (sr) { + struct scrollregion *next = sr->next; + do_scroll(ctx, sr->topline, sr->botline, sr->lines); + sfree(sr); + sr = next; + } + term->scrollhead = term->scrolltail = NULL; +#endif /* OPTIMISE_SCROLL */ /* The normal screen data */ for (i = 0; i < term->rows; i++) { - unsigned long *ldata; - int lattr; - int idx, dirty_line, dirty_run, selected; - unsigned long attr = 0; + termline *ldata; + termchar *lchars; + int dirty_line, dirty_run, selected; + unsigned long attr = 0, cset = 0; int updated_line = 0; int start = 0; int ccount = 0; @@ -2952,36 +3994,96 @@ static void do_paint(Terminal *term, Context ctx, int may_optimise) scrpos.y = i + term->disptop; ldata = lineptr(scrpos.y); - lattr = (ldata[term->cols] & LATTR_MODE); - idx = i * (term->cols + 1); - dirty_run = dirty_line = (ldata[term->cols] != - term->disptext[idx + term->cols]); - term->disptext[idx + term->cols] = ldata[term->cols]; + dirty_run = dirty_line = (ldata->lattr != + term->disptext[i]->lattr); + term->disptext[i]->lattr = ldata->lattr; + + /* Do Arabic shaping and bidi. */ + if(!term->cfg.bidi || !term->cfg.arabicshaping) { + + if (!term_bidi_cache_hit(term, i, ldata->chars, term->cols)) { + + for(it=0; itcols ; it++) + { + unsigned long uc = (ldata->chars[it].chr); + + switch (uc & CSET_MASK) { + case CSET_LINEDRW: + if (!term->cfg.rawcnp) { + uc = term->ucsdata->unitab_xterm[uc & 0xFF]; + break; + } + case CSET_ASCII: + uc = term->ucsdata->unitab_line[uc & 0xFF]; + break; + case CSET_SCOACS: + uc = term->ucsdata->unitab_scoacs[uc&0xFF]; + break; + } + switch (uc & CSET_MASK) { + case CSET_ACP: + uc = term->ucsdata->unitab_font[uc & 0xFF]; + break; + case CSET_OEMCP: + uc = term->ucsdata->unitab_oemcp[uc & 0xFF]; + break; + } + + term->wcFrom[it].origwc = term->wcFrom[it].wc = + (wchar_t)uc; + term->wcFrom[it].index = it; + } + + if(!term->cfg.bidi) + do_bidi(term->wcFrom, term->cols); + + /* this is saved iff done from inside the shaping */ + if(!term->cfg.bidi && term->cfg.arabicshaping) + for(it=0; itcols; it++) + term->wcTo[it] = term->wcFrom[it]; + + if(!term->cfg.arabicshaping) + do_shape(term->wcFrom, term->wcTo, term->cols); + + for(it=0; itcols ; it++) + { + term->ltemp[it] = ldata->chars[term->wcTo[it].index]; + + if (term->wcTo[it].origwc != term->wcTo[it].wc) + term->ltemp[it].chr = term->wcTo[it].wc; + } + term_bidi_cache_store(term, i, ldata->chars, + term->ltemp, term->cols); + lchars = term->ltemp; + } else { + lchars = term->post_bidi_cache[i]; + } + } else + lchars = ldata->chars; - for (j = 0; j < term->cols; j++, idx++) { + for (j = 0; j < term->cols; j++) { unsigned long tattr, tchar; - unsigned long *d = ldata + j; + termchar *d = lchars + j; int break_run; scrpos.x = j; - tchar = (*d & (CHAR_MASK | CSET_MASK)); - tattr = (*d & (ATTR_MASK ^ CSET_MASK)); + tchar = d->chr; + tattr = d->attr; + switch (tchar & CSET_MASK) { - case ATTR_ASCII: - tchar = unitab_line[tchar & 0xFF]; + case CSET_ASCII: + tchar = term->ucsdata->unitab_line[tchar & 0xFF]; break; - case ATTR_LINEDRW: - tchar = unitab_xterm[tchar & 0xFF]; + case CSET_LINEDRW: + tchar = term->ucsdata->unitab_xterm[tchar & 0xFF]; break; - case ATTR_SCOACS: - tchar = unitab_scoacs[tchar&0xFF]; + case CSET_SCOACS: + tchar = term->ucsdata->unitab_scoacs[tchar&0xFF]; break; } - tattr |= (tchar & CSET_MASK); - tchar &= CHAR_MASK; - if ((d[1] & (CHAR_MASK | CSET_MASK)) == UCSWIDE) - tattr |= ATTR_WIDE; + if (j < term->cols-1 && d[1].chr == UCSWIDE) + tattr |= ATTR_WIDE; /* Video reversing things */ if (term->selstate == DRAGGING || term->selstate == SELECTED) { @@ -2999,9 +4101,7 @@ static void do_paint(Terminal *term, Context ctx, int may_optimise) /* 'Real' blinking ? */ if (term->blink_is_real && (tattr & ATTR_BLINK)) { if (term->has_focus && term->tblinker) { - tchar = ' '; - tattr &= ~CSET_MASK; - tattr |= ATTR_ACP; + tchar = term->ucsdata->unitab_line[(unsigned char)' ']; } tattr &= ~ATTR_BLINK; } @@ -3010,30 +4110,42 @@ static void do_paint(Terminal *term, Context ctx, int may_optimise) * Check the font we'll _probably_ be using to see if * the character is wide when we don't want it to be. */ - if ((tchar | tattr) != (term->disptext[idx]& ~ATTR_NARROW)) { - if ((tattr & ATTR_WIDE) == 0 && - char_width(ctx, (tchar | tattr) & 0xFFFF) == 2) + if (tchar != term->disptext[i]->chars[j].chr || + tattr != (term->disptext[i]->chars[j].attr &~ + ATTR_NARROW)) { + if ((tattr & ATTR_WIDE) == 0 && char_width(ctx, tchar) == 2) tattr |= ATTR_NARROW; - } else if (term->disptext[idx]&ATTR_NARROW) + } else if (term->disptext[i]->chars[j].attr & ATTR_NARROW) tattr |= ATTR_NARROW; /* Cursor here ? Save the 'background' */ - if (i == our_curs_y && j == term->curs.x) { - cursor_background = tattr | tchar; - term->dispcurs = term->disptext + idx; + if (i == our_curs_y && j == our_curs_x) { + cursor_background.chr = tchar; + cursor_background.attr = tattr; + term->dispcursx = j; + term->dispcursy = i; } - if ((term->disptext[idx] ^ tattr) & ATTR_WIDE) + if ((term->disptext[i]->chars[j].attr ^ tattr) & ATTR_WIDE) dirty_line = TRUE; - break_run = (tattr != attr || j - start >= sizeof(ch)); + break_run = (((tattr ^ attr) & term->attr_mask) || + j - start >= sizeof(ch)); /* Special hack for VT100 Linedraw glyphs */ - if ((attr & CSET_MASK) == 0x2300 && tchar >= 0xBA - && tchar <= 0xBD) break_run = TRUE; + if (tchar >= 0x23BA && tchar <= 0x23BD) + break_run = TRUE; + + /* + * Separate out sequences of characters that have the + * same CSET, if that CSET is a magic one. + */ + if (CSET_OF(tchar) != cset) + break_run = TRUE; - if (!dbcs_screenfont && !dirty_line) { - if ((tchar | tattr) == term->disptext[idx]) + if (!term->ucsdata->dbcs_screenfont && !dirty_line) { + if (term->disptext[i]->chars[j].chr == tchar && + term->disptext[i]->chars[j].attr == tattr) break_run = TRUE; else if (!dirty_run && ccount == 1) break_run = TRUE; @@ -3041,50 +4153,56 @@ static void do_paint(Terminal *term, Context ctx, int may_optimise) if (break_run) { if ((dirty_run || last_run_dirty) && ccount > 0) { - do_text(ctx, start, i, ch, ccount, attr, lattr); + do_text(ctx, start, i, ch, ccount, attr, ldata->lattr); updated_line = 1; } start = j; ccount = 0; attr = tattr; - if (dbcs_screenfont) + cset = CSET_OF(tchar); + if (term->ucsdata->dbcs_screenfont) last_run_dirty = dirty_run; dirty_run = dirty_line; } - if ((tchar | tattr) != term->disptext[idx]) + if (term->disptext[i]->chars[j].chr != tchar || + term->disptext[i]->chars[j].attr != tattr) dirty_run = TRUE; - ch[ccount++] = (char) tchar; - term->disptext[idx] = tchar | tattr; + ch[ccount++] = (wchar_t) tchar; + term->disptext[i]->chars[j].chr = tchar; + term->disptext[i]->chars[j].attr = tattr; /* If it's a wide char step along to the next one. */ if (tattr & ATTR_WIDE) { if (++j < term->cols) { - idx++; d++; - /* Cursor is here ? Ouch! */ - if (i == our_curs_y && j == term->curs.x) { - cursor_background = *d; - term->dispcurs = term->disptext + idx; - } - if (term->disptext[idx] != *d) + /* + * By construction above, the cursor should not + * be on the right-hand half of this character. + * Ever. + */ + assert(!(i == our_curs_y && j == our_curs_x)); + if (memcmp(&term->disptext[i]->chars[j], + d, sizeof(*d))) dirty_run = TRUE; - term->disptext[idx] = *d; + term->disptext[i]->chars[j] = *d; } } } if (dirty_run && ccount > 0) { - do_text(ctx, start, i, ch, ccount, attr, lattr); + do_text(ctx, start, i, ch, ccount, attr, ldata->lattr); updated_line = 1; } /* Cursor on this line ? (and changed) */ if (i == our_curs_y && (term->curstype != cursor || updated_line)) { - ch[0] = (char) (cursor_background & CHAR_MASK); - attr = (cursor_background & ATTR_MASK) | cursor; - do_cursor(ctx, term->curs.x, i, ch, 1, attr, lattr); + ch[0] = (wchar_t) cursor_background.chr; + attr = cursor_background.attr | cursor; + do_cursor(ctx, our_curs_x, i, ch, 1, attr, ldata->lattr); term->curstype = cursor; } + + unlineptr(ldata); } } @@ -3126,10 +4244,11 @@ void term_blink(Terminal *term, int flg) */ void term_invalidate(Terminal *term) { - int i; + int i, j; - for (i = 0; i < term->rows * (term->cols + 1); i++) - term->disptext[i] = ATTR_INVALID; + for (i = 0; i < term->rows; i++) + for (j = 0; j < term->cols; j++) + term->disptext[i]->chars[j].attr = ATTR_INVALID; } /* @@ -3145,13 +4264,12 @@ void term_paint(Terminal *term, Context ctx, if (bottom >= term->rows) bottom = term->rows-1; for (i = top; i <= bottom && i < term->rows; i++) { - if ((term->disptext[i * (term->cols + 1) + term->cols] & - LATTR_MODE) == LATTR_NORM) + if (term->disptext[i]->lattr == LATTR_NORM) for (j = left; j <= right && j < term->cols; j++) - term->disptext[i * (term->cols + 1) + j] = ATTR_INVALID; + term->disptext[i]->chars[j].attr = ATTR_INVALID; else for (j = left / 2; j <= right / 2 + 1 && j < term->cols; j++) - term->disptext[i * (term->cols + 1) + j] = ATTR_INVALID; + term->disptext[i]->chars[j].attr = ATTR_INVALID; } /* This should happen soon enough, also for some reason it sometimes @@ -3171,7 +4289,7 @@ void term_paint(Terminal *term, Context ctx, */ void term_scroll(Terminal *term, int rel, int where) { - int sbtop = -count234(term->scrollback); + int sbtop = -sblines(term); #ifdef OPTIMISE_SCROLL int olddisptop = term->disptop; int shift; @@ -3191,7 +4309,7 @@ void term_scroll(Terminal *term, int rel, int where) term_update(term); } -static void clipme(Terminal *term, pos top, pos bottom, int rect) +static void clipme(Terminal *term, pos top, pos bottom, int rect, int desel) { wchar_t *workbuf; wchar_t *wbptr; /* where next char goes within workbuf */ @@ -3200,13 +4318,13 @@ static void clipme(Terminal *term, pos top, pos bottom, int rect) int buflen; /* amount of memory allocated to workbuf */ buflen = 5120; /* Default size */ - workbuf = smalloc(buflen * sizeof(wchar_t)); + workbuf = snewn(buflen, wchar_t); wbptr = workbuf; /* start filling here */ old_top_x = top.x; /* needed for rect==1 */ while (poslt(top, bottom)) { int nl = FALSE; - unsigned long *ldata = lineptr(top.y); + termline *ldata = lineptr(top.y); pos nlpos; /* @@ -3223,14 +4341,15 @@ static void clipme(Terminal *term, pos top, pos bottom, int rect) * because in normal selection mode this means we need a * newline at the end)... */ - if (!(ldata[term->cols] & LATTR_WRAPPED)) { - while (((ldata[nlpos.x - 1] & 0xFF) == 0x20 || - (DIRECT_CHAR(ldata[nlpos.x - 1]) && - (ldata[nlpos.x - 1] & CHAR_MASK) == 0x20)) - && poslt(top, nlpos)) + if (!(ldata->lattr & LATTR_WRAPPED)) { + while (IS_SPACE_CHR(ldata->chars[nlpos.x - 1].chr) && + poslt(top, nlpos)) decpos(nlpos); if (poslt(nlpos, bottom)) nl = TRUE; + } else if (ldata->lattr & LATTR_WRAPPED2) { + /* Ignore the last char on the line in a WRAPPED2 line. */ + decpos(nlpos); } /* @@ -3252,7 +4371,7 @@ static void clipme(Terminal *term, pos top, pos bottom, int rect) sprintf(cbuf, "", (ldata[top.x] & 0xFFFF)); #else wchar_t cbuf[16], *p; - int uc = (ldata[top.x] & 0xFFFF); + int uc = ldata->chars[top.x].chr; int set, c; if (uc == UCSWIDE) { @@ -3261,29 +4380,29 @@ static void clipme(Terminal *term, pos top, pos bottom, int rect) } switch (uc & CSET_MASK) { - case ATTR_LINEDRW: - if (!cfg.rawcnp) { - uc = unitab_xterm[uc & 0xFF]; + case CSET_LINEDRW: + if (!term->cfg.rawcnp) { + uc = term->ucsdata->unitab_xterm[uc & 0xFF]; break; } - case ATTR_ASCII: - uc = unitab_line[uc & 0xFF]; + case CSET_ASCII: + uc = term->ucsdata->unitab_line[uc & 0xFF]; break; - case ATTR_SCOACS: - uc = unitab_scoacs[uc&0xFF]; + case CSET_SCOACS: + uc = term->ucsdata->unitab_scoacs[uc&0xFF]; break; } switch (uc & CSET_MASK) { - case ATTR_ACP: - uc = unitab_font[uc & 0xFF]; + case CSET_ACP: + uc = term->ucsdata->unitab_font[uc & 0xFF]; break; - case ATTR_OEMCP: - uc = unitab_oemcp[uc & 0xFF]; + case CSET_OEMCP: + uc = term->ucsdata->unitab_oemcp[uc & 0xFF]; break; } set = (uc & CSET_MASK); - c = (uc & CHAR_MASK); + c = (uc & ~CSET_MASK); cbuf[0] = uc; cbuf[1] = 0; @@ -3292,14 +4411,14 @@ static void clipme(Terminal *term, pos top, pos bottom, int rect) char buf[4]; WCHAR wbuf[4]; int rv; - if (is_dbcs_leadbyte(font_codepage, (BYTE) c)) { + if (is_dbcs_leadbyte(term->ucsdata->font_codepage, (BYTE) c)) { buf[0] = c; - buf[1] = ldata[top.x + 1]; - rv = mb_to_wc(font_codepage, 0, buf, 2, wbuf, 4); + buf[1] = (char) (0xFF & ldata->chars[top.x + 1].chr); + rv = mb_to_wc(term->ucsdata->font_codepage, 0, buf, 2, wbuf, 4); top.x++; } else { buf[0] = c; - rv = mb_to_wc(font_codepage, 0, buf, 1, wbuf, 4); + rv = mb_to_wc(term->ucsdata->font_codepage, 0, buf, 1, wbuf, 4); } if (rv > 0) { @@ -3313,9 +4432,8 @@ static void clipme(Terminal *term, pos top, pos bottom, int rect) for (p = cbuf; *p; p++) { /* Enough overhead for trailing NL and nul */ if (wblen >= buflen - 16) { - workbuf = - srealloc(workbuf, - sizeof(wchar_t) * (buflen += 100)); + buflen += 100; + workbuf = sresize(workbuf, buflen, wchar_t); wbptr = workbuf + wblen; } wblen++; @@ -3332,12 +4450,14 @@ static void clipme(Terminal *term, pos top, pos bottom, int rect) } top.y++; top.x = rect ? old_top_x : 0; + + unlineptr(ldata); } #if SELECTION_NUL_TERMINATED wblen++; *wbptr++ = 0; #endif - write_clip(term->frontend, workbuf, wblen, FALSE); /* transfer to clipbd */ + write_clip(term->frontend, workbuf, wblen, desel); /* transfer to clipbd */ if (buflen > 0) /* indicates we allocated this buffer */ sfree(workbuf); } @@ -3345,9 +4465,13 @@ static void clipme(Terminal *term, pos top, pos bottom, int rect) void term_copyall(Terminal *term) { pos top; - top.y = -count234(term->scrollback); + pos bottom; + tree234 *screen = term->screen; + top.y = -sblines(term); top.x = 0; - clipme(term, top, term->curs, 0); + bottom.y = find_last_nonempty_line(term, screen); + bottom.x = term->cols; + clipme(term, top, bottom, 0, TRUE); } /* @@ -3425,32 +4549,31 @@ static int wordtype(Terminal *term, int uc) }; const struct ucsword *wptr; - uc &= (CSET_MASK | CHAR_MASK); - switch (uc & CSET_MASK) { - case ATTR_LINEDRW: - uc = unitab_xterm[uc & 0xFF]; + case CSET_LINEDRW: + uc = term->ucsdata->unitab_xterm[uc & 0xFF]; break; - case ATTR_ASCII: - uc = unitab_line[uc & 0xFF]; + case CSET_ASCII: + uc = term->ucsdata->unitab_line[uc & 0xFF]; break; - case ATTR_SCOACS: - uc = unitab_scoacs[uc&0xFF]; + case CSET_SCOACS: + uc = term->ucsdata->unitab_scoacs[uc&0xFF]; break; } switch (uc & CSET_MASK) { - case ATTR_ACP: - uc = unitab_font[uc & 0xFF]; + case CSET_ACP: + uc = term->ucsdata->unitab_font[uc & 0xFF]; break; - case ATTR_OEMCP: - uc = unitab_oemcp[uc & 0xFF]; + case CSET_OEMCP: + uc = term->ucsdata->unitab_oemcp[uc & 0xFF]; break; } - /* For DBCS font's I can't do anything usefull. Even this will sometimes + /* For DBCS fonts I can't do anything useful. Even this will sometimes * fail as there's such a thing as a double width space. :-( */ - if (dbcs_screenfont && font_codepage == line_codepage) + if (term->ucsdata->dbcs_screenfont && + term->ucsdata->font_codepage == term->ucsdata->line_codepage) return (uc != ' '); if (uc < 0x80) @@ -3469,9 +4592,9 @@ static int wordtype(Terminal *term, int uc) */ static pos sel_spread_half(Terminal *term, pos p, int dir) { - unsigned long *ldata; + termline *ldata; short wvalue; - int topy = -count234(term->scrollback); + int topy = -sblines(term); ldata = lineptr(p.y); @@ -3481,14 +4604,14 @@ static pos sel_spread_half(Terminal *term, pos p, int dir) * In this mode, every character is a separate unit, except * for runs of spaces at the end of a non-wrapping line. */ - if (!(ldata[term->cols] & LATTR_WRAPPED)) { - unsigned long *q = ldata + term->cols; - while (q > ldata && (q[-1] & CHAR_MASK) == 0x20) + if (!(ldata->lattr & LATTR_WRAPPED)) { + termchar *q = ldata->chars + term->cols; + while (q > ldata->chars && IS_SPACE_CHR(q[-1].chr)) q--; - if (q == ldata + term->cols) + if (q == ldata->chars + term->cols) q--; - if (p.x >= q - ldata) - p.x = (dir == -1 ? q - ldata : term->cols - 1); + if (p.x >= q - ldata->chars) + p.x = (dir == -1 ? q - ldata->chars : term->cols - 1); } break; case SM_WORD: @@ -3496,24 +4619,30 @@ static pos sel_spread_half(Terminal *term, pos p, int dir) * In this mode, the units are maximal runs of characters * whose `wordness' has the same value. */ - wvalue = wordtype(term, ldata[p.x]); + wvalue = wordtype(term, UCSGET(ldata->chars, p.x)); if (dir == +1) { while (1) { - if (p.x < term->cols-1) { - if (wordtype(term, ldata[p.x + 1]) == wvalue) + int maxcols = (ldata->lattr & LATTR_WRAPPED2 ? + term->cols-1 : term->cols); + if (p.x < maxcols-1) { + if (wordtype(term, UCSGET(ldata->chars, p.x+1)) == wvalue) p.x++; else break; } else { - if (ldata[term->cols] & LATTR_WRAPPED) { - unsigned long *ldata2; + if (ldata->lattr & LATTR_WRAPPED) { + termline *ldata2; ldata2 = lineptr(p.y+1); - if (wordtype(term, ldata2[0]) == wvalue) { + if (wordtype(term, UCSGET(ldata2->chars, 0)) + == wvalue) { p.x = 0; p.y++; + unlineptr(ldata); ldata = ldata2; - } else + } else { + unlineptr(ldata2); break; + } } else break; } @@ -3521,20 +4650,29 @@ static pos sel_spread_half(Terminal *term, pos p, int dir) } else { while (1) { if (p.x > 0) { - if (wordtype(term, ldata[p.x - 1]) == wvalue) + if (wordtype(term, UCSGET(ldata->chars, p.x-1)) == wvalue) p.x--; else break; } else { - unsigned long *ldata2; + termline *ldata2; + int maxcols; if (p.y <= topy) break; ldata2 = lineptr(p.y-1); - if ((ldata2[term->cols] & LATTR_WRAPPED) && - wordtype(term, ldata2[term->cols-1]) == wvalue) { - p.x = term->cols-1; - p.y--; - ldata = ldata2; + maxcols = (ldata2->lattr & LATTR_WRAPPED2 ? + term->cols-1 : term->cols); + if (ldata2->lattr & LATTR_WRAPPED) { + if (wordtype(term, UCSGET(ldata2->chars, maxcols-1)) + == wvalue) { + p.x = maxcols-1; + p.y--; + unlineptr(ldata); + ldata = ldata2; + } else { + unlineptr(ldata2); + break; + } } else break; } @@ -3548,6 +4686,8 @@ static pos sel_spread_half(Terminal *term, pos p, int dir) p.x = (dir == -1 ? 0 : term->cols - 1); break; } + + unlineptr(ldata); return p; } @@ -3575,7 +4715,7 @@ void term_do_paste(Terminal *term) if (term->paste_buffer) sfree(term->paste_buffer); term->paste_pos = term->paste_hold = term->paste_len = 0; - term->paste_buffer = smalloc(len * sizeof(wchar_t)); + term->paste_buffer = snewn(len, wchar_t); p = q = data; while (p < data + len) { @@ -3612,14 +4752,14 @@ void term_do_paste(Terminal *term) get_clip(term->frontend, NULL, NULL); } -void term_mouse(Terminal *term, Mouse_Button b, Mouse_Action a, int x, int y, - int shift, int ctrl, int alt) +void term_mouse(Terminal *term, Mouse_Button braw, Mouse_Button bcooked, + Mouse_Action a, int x, int y, int shift, int ctrl, int alt) { pos selpoint; - unsigned long *ldata; + termline *ldata; int raw_mouse = (term->xterm_mouse && - !cfg.no_mouse_rep && - !(cfg.mouse_override && shift)); + !term->cfg.no_mouse_rep && + !(term->cfg.mouse_override && shift)); int default_seltype; if (y < 0) { @@ -3645,8 +4785,9 @@ void term_mouse(Terminal *term, Mouse_Button b, Mouse_Action a, int x, int y, selpoint.y = y + term->disptop; selpoint.x = x; ldata = lineptr(selpoint.y); - if ((ldata[term->cols] & LATTR_MODE) != LATTR_NORM) + if ((ldata->lattr & LATTR_MODE) != LATTR_NORM) selpoint.x /= 2; + unlineptr(ldata); if (raw_mouse) { int encstate = 0, r, c; @@ -3654,7 +4795,7 @@ void term_mouse(Terminal *term, Mouse_Button b, Mouse_Action a, int x, int y, if (term->ldisc) { - switch (b) { + switch (braw) { case MBT_LEFT: encstate = 0x20; /* left button down */ break; @@ -3683,9 +4824,9 @@ void term_mouse(Terminal *term, Mouse_Button b, Mouse_Action a, int x, int y, term->mouse_is_down = 0; break; case MA_CLICK: - if (term->mouse_is_down == b) + if (term->mouse_is_down == braw) return; - term->mouse_is_down = b; + term->mouse_is_down = braw; break; default: break; /* placate gcc warning about enum use */ } @@ -3702,13 +4843,11 @@ void term_mouse(Terminal *term, Mouse_Button b, Mouse_Action a, int x, int y, return; } - b = translate_button(term->frontend, b); - /* * Set the selection type (rectangular or normal) at the start * of a selection attempt, from the state of Alt. */ - if (!alt ^ !cfg.rect_select) + if (!alt ^ !term->cfg.rect_select) default_seltype = RECTANGULAR; else default_seltype = LEXICOGRAPHIC; @@ -3717,13 +4856,13 @@ void term_mouse(Terminal *term, Mouse_Button b, Mouse_Action a, int x, int y, term->seltype = default_seltype; } - if (b == MBT_SELECT && a == MA_CLICK) { + if (bcooked == MBT_SELECT && a == MA_CLICK) { deselect(term); term->selstate = ABOUT_TO; term->seltype = default_seltype; term->selanchor = selpoint; term->selmode = SM_CHAR; - } else if (b == MBT_SELECT && (a == MA_2CLK || a == MA_3CLK)) { + } else if (bcooked == MBT_SELECT && (a == MA_2CLK || a == MA_3CLK)) { deselect(term); term->selmode = (a == MA_2CLK ? SM_WORD : SM_LINE); term->selstate = DRAGGING; @@ -3731,11 +4870,12 @@ void term_mouse(Terminal *term, Mouse_Button b, Mouse_Action a, int x, int y, term->selend = term->selstart; incpos(term->selend); sel_spread(term); - } else if ((b == MBT_SELECT && a == MA_DRAG) || - (b == MBT_EXTEND && a != MA_RELEASE)) { + } else if ((bcooked == MBT_SELECT && a == MA_DRAG) || + (bcooked == MBT_EXTEND && a != MA_RELEASE)) { if (term->selstate == ABOUT_TO && poseq(term->selanchor, selpoint)) return; - if (b == MBT_EXTEND && a != MA_DRAG && term->selstate == SELECTED) { + if (bcooked == MBT_EXTEND && a != MA_DRAG && + term->selstate == SELECTED) { if (term->seltype == LEXICOGRAPHIC) { /* * For normal selection, we extend by moving @@ -3796,18 +4936,19 @@ void term_mouse(Terminal *term, Mouse_Button b, Mouse_Action a, int x, int y, term->selend.y = max(term->selanchor.y, selpoint.y); } sel_spread(term); - } else if ((b == MBT_SELECT || b == MBT_EXTEND) && a == MA_RELEASE) { + } else if ((bcooked == MBT_SELECT || bcooked == MBT_EXTEND) && + a == MA_RELEASE) { if (term->selstate == DRAGGING) { /* * We've completed a selection. We now transfer the * data to the clipboard. */ clipme(term, term->selstart, term->selend, - (term->seltype == RECTANGULAR)); + (term->seltype == RECTANGULAR), FALSE); term->selstate = SELECTED; } else term->selstate = NO_SELECTION; - } else if (b == MBT_PASTE + } else if (bcooked == MBT_PASTE && (a == MA_CLICK #if MULTICLICK_ONLY_EVENT || a == MA_2CLK || a == MA_3CLK @@ -3819,6 +4960,446 @@ void term_mouse(Terminal *term, Mouse_Button b, Mouse_Action a, int x, int y, term_update(term); } +void term_key(Terminal *term, Key_Sym keysym, wchar_t *text, size_t tlen, + unsigned int modifiers, unsigned int flags) +{ + char output[10]; + char *p = output; + int prependesc = FALSE; +#if 0 + int i; + + fprintf(stderr, "keysym = %d, %d chars:", keysym, tlen); + for (i = 0; i < tlen; i++) + fprintf(stderr, " %04x", (unsigned)text[i]); + fprintf(stderr, "\n"); +#endif + + /* XXX Num Lock */ + if ((flags & PKF_REPEAT) && term->repeat_off) + return; + + /* Currently, Meta always just prefixes everything with ESC. */ + if (modifiers & PKM_META) + prependesc = TRUE; + modifiers &= ~PKM_META; + + /* + * Alt is only used for Alt+keypad, which isn't supported yet, so + * ignore it. + */ + modifiers &= ~PKM_ALT; + + /* Standard local function keys */ + switch (modifiers & (PKM_SHIFT | PKM_CONTROL)) { + case PKM_SHIFT: + if (keysym == PK_PAGEUP) + /* scroll up one page */; + if (keysym == PK_PAGEDOWN) + /* scroll down on page */; + if (keysym == PK_INSERT) + term_do_paste(term); + break; + case PKM_CONTROL: + if (keysym == PK_PAGEUP) + /* scroll up one line */; + if (keysym == PK_PAGEDOWN) + /* scroll down one line */; + /* Control-Numlock for app-keypad mode switch */ + if (keysym == PK_PF1) + term->app_keypad_keys ^= 1; + break; + } + + if (modifiers & PKM_ALT) { + /* Alt+F4 (close) */ + /* Alt+Return (full screen) */ + /* Alt+Space (system menu) */ + } + + if (keysym == PK_NULL && (modifiers & PKM_CONTROL) && tlen == 1 && + text[0] >= 0x20 && text[0] <= 0x7e) { + /* ASCII chars + Control */ + if ((text[0] >= 0x40 && text[0] <= 0x5f) || + (text[0] >= 0x61 && text[0] <= 0x7a)) + text[0] &= 0x1f; + else { + /* + * Control-2 should return ^@ (0x00), Control-6 should return + * ^^ (0x1E), and Control-Minus should return ^_ (0x1F). Since + * the DOS keyboard handling did it, and we have nothing better + * to do with the key combo in question, we'll also map + * Control-Backquote to ^\ (0x1C). + */ + switch (text[0]) { + case ' ': text[0] = 0x00; break; + case '-': text[0] = 0x1f; break; + case '/': text[0] = 0x1f; break; + case '2': text[0] = 0x00; break; + case '3': text[0] = 0x1b; break; + case '4': text[0] = 0x1c; break; + case '5': text[0] = 0x1d; break; + case '6': text[0] = 0x1e; break; + case '7': text[0] = 0x1f; break; + case '8': text[0] = 0x7f; break; + case '`': text[0] = 0x1c; break; + } + } + } + + /* Nethack keypad */ + if (term->cfg.nethack_keypad) { + char c = 0; + switch (keysym) { + case PK_KP1: c = 'b'; break; + case PK_KP2: c = 'j'; break; + case PK_KP3: c = 'n'; break; + case PK_KP4: c = 'h'; break; + case PK_KP5: c = '.'; break; + case PK_KP6: c = 'l'; break; + case PK_KP7: c = 'y'; break; + case PK_KP8: c = 'k'; break; + case PK_KP9: c = 'u'; break; + default: break; /* else gcc warns `enum value not used' */ + } + if (c != 0) { + if (c != '.') { + if (modifiers & PKM_CONTROL) + c &= 0x1f; + else if (modifiers & PKM_SHIFT) + c = toupper(c); + } + *p++ = c; + goto done; + } + } + + /* Numeric Keypad */ + if (PK_ISKEYPAD(keysym)) { + int xkey = 0; + + /* + * In VT400 mode, PFn always emits an escape sequence. In + * Linux and tilde modes, this only happens in app keypad mode. + */ + if (term->cfg.funky_type == FUNKY_VT400 || + ((term->cfg.funky_type == FUNKY_LINUX || + term->cfg.funky_type == FUNKY_TILDE) && + term->app_keypad_keys && !term->cfg.no_applic_k)) { + switch (keysym) { + case PK_PF1: xkey = 'P'; break; + case PK_PF2: xkey = 'Q'; break; + case PK_PF3: xkey = 'R'; break; + case PK_PF4: xkey = 'S'; break; + default: break; /* else gcc warns `enum value not used' */ + } + } + if (term->app_keypad_keys && !term->cfg.no_applic_k) { + switch (keysym) { + case PK_KP0: xkey = 'p'; break; + case PK_KP1: xkey = 'q'; break; + case PK_KP2: xkey = 'r'; break; + case PK_KP3: xkey = 's'; break; + case PK_KP4: xkey = 't'; break; + case PK_KP5: xkey = 'u'; break; + case PK_KP6: xkey = 'v'; break; + case PK_KP7: xkey = 'w'; break; + case PK_KP8: xkey = 'x'; break; + case PK_KP9: xkey = 'y'; break; + case PK_KPDECIMAL: xkey = 'n'; break; + case PK_KPENTER: xkey = 'M'; break; + default: break; /* else gcc warns `enum value not used' */ + } + if (term->cfg.funky_type == FUNKY_XTERM && tlen > 0) { + /* + * xterm can't see the layout of the keypad, so it has + * to rely on the X keysyms returned by the keys. + * Hence, we look at the strings here, not the PuTTY + * keysyms (which describe the layout). + */ + switch (text[0]) { + case '+': + if (modifiers & PKM_SHIFT) + xkey = 'l'; + else + xkey = 'k'; + break; + case '/': xkey = 'o'; break; + case '*': xkey = 'j'; break; + case '-': xkey = 'm'; break; + } + } else { + /* + * In all other modes, we try to retain the layout of + * the DEC keypad in application mode. + */ + switch (keysym) { + case PK_KPBIGPLUS: + /* This key covers the '-' and ',' keys on a VT220 */ + if (modifiers & PKM_SHIFT) + xkey = 'm'; /* VT220 '-' */ + else + xkey = 'l'; /* VT220 ',' */ + break; + case PK_KPMINUS: xkey = 'm'; break; + case PK_KPCOMMA: xkey = 'l'; break; + default: break; /* else gcc warns `enum value not used' */ + } + } + } + if (xkey) { + if (term->vt52_mode) { + if (xkey >= 'P' && xkey <= 'S') + p += sprintf((char *) p, "\x1B%c", xkey); + else + p += sprintf((char *) p, "\x1B?%c", xkey); + } else + p += sprintf((char *) p, "\x1BO%c", xkey); + goto done; + } + /* Not in application mode -- treat the number pad as arrow keys? */ + if ((flags & PKF_NUMLOCK) == 0) { + switch (keysym) { + case PK_KP0: keysym = PK_INSERT; break; + case PK_KP1: keysym = PK_END; break; + case PK_KP2: keysym = PK_DOWN; break; + case PK_KP3: keysym = PK_PAGEDOWN; break; + case PK_KP4: keysym = PK_LEFT; break; + case PK_KP5: keysym = PK_REST; break; + case PK_KP6: keysym = PK_RIGHT; break; + case PK_KP7: keysym = PK_HOME; break; + case PK_KP8: keysym = PK_UP; break; + case PK_KP9: keysym = PK_PAGEUP; break; + default: break; /* else gcc warns `enum value not used' */ + } + } + } + + /* Miscellaneous keys */ + switch (keysym) { + case PK_ESCAPE: + *p++ = 0x1b; + goto done; + case PK_BACKSPACE: + if (modifiers == 0) + *p++ = (term->cfg.bksp_is_delete ? 0x7F : 0x08); + else if (modifiers == PKM_SHIFT) + /* We do the opposite of what is configured */ + *p++ = (term->cfg.bksp_is_delete ? 0x08 : 0x7F); + else break; + goto done; + case PK_TAB: + if (modifiers == 0) + *p++ = 0x09; + else if (modifiers == PKM_SHIFT) + *p++ = 0x1B, *p++ = '[', *p++ = 'Z'; + else break; + goto done; + /* XXX window.c has ctrl+shift+space sending 0xa0 */ + case PK_PAUSE: + if (modifiers == PKM_CONTROL) + *p++ = 26; + else break; + goto done; + case PK_RETURN: + case PK_KPENTER: /* Odd keypad modes handled above */ + if (modifiers == 0) { + *p++ = 0x0d; + if (term->cr_lf_return) + *p++ = 0x0a; + goto done; + } + default: break; /* else gcc warns `enum value not used' */ + } + + /* SCO function keys and editing keys */ + if (term->cfg.funky_type == FUNKY_SCO) { + if (PK_ISFKEY(keysym) && keysym <= PK_F12) { + static char const codes[] = + "MNOPQRSTUVWX" "YZabcdefghij" "klmnopqrstuv" "wxyz@[\\]^_`{"; + int index = keysym - PK_F1; + + if (modifiers & PKM_SHIFT) index += 12; + if (modifiers & PKM_CONTROL) index += 24; + p += sprintf((char *) p, "\x1B[%c", codes[index]); + goto done; + } + if (PK_ISEDITING(keysym)) { + int xkey = 0; + + switch (keysym) { + case PK_DELETE: *p++ = 0x7f; goto done; + case PK_HOME: xkey = 'H'; break; + case PK_INSERT: xkey = 'L'; break; + case PK_END: xkey = 'F'; break; + case PK_PAGEUP: xkey = 'I'; break; + case PK_PAGEDOWN: xkey = 'G'; break; + default: break; /* else gcc warns `enum value not used' */ + } + p += sprintf((char *) p, "\x1B[%c", xkey); + } + } + + if (PK_ISEDITING(keysym) && (modifiers & PKM_SHIFT) == 0) { + int code; + + if (term->cfg.funky_type == FUNKY_XTERM) { + /* Xterm shuffles these keys, apparently. */ + switch (keysym) { + case PK_HOME: keysym = PK_INSERT; break; + case PK_INSERT: keysym = PK_HOME; break; + case PK_DELETE: keysym = PK_END; break; + case PK_END: keysym = PK_PAGEUP; break; + case PK_PAGEUP: keysym = PK_DELETE; break; + case PK_PAGEDOWN: keysym = PK_PAGEDOWN; break; + default: break; /* else gcc warns `enum value not used' */ + } + } + + /* RXVT Home/End */ + if (term->cfg.rxvt_homeend && + (keysym == PK_HOME || keysym == PK_END)) { + p += sprintf((char *) p, keysym == PK_HOME ? "\x1B[H" : "\x1BOw"); + goto done; + } + + if (term->vt52_mode) { + int xkey; + + /* + * A real VT52 doesn't have these, and a VT220 doesn't + * send anything for them in VT52 mode. + */ + switch (keysym) { + case PK_HOME: xkey = 'H'; break; + case PK_INSERT: xkey = 'L'; break; + case PK_DELETE: xkey = 'M'; break; + case PK_END: xkey = 'E'; break; + case PK_PAGEUP: xkey = 'I'; break; + case PK_PAGEDOWN: xkey = 'G'; break; + default: xkey=0; break; /* else gcc warns `enum value not used'*/ + } + p += sprintf((char *) p, "\x1B%c", xkey); + goto done; + } + + switch (keysym) { + case PK_HOME: code = 1; break; + case PK_INSERT: code = 2; break; + case PK_DELETE: code = 3; break; + case PK_END: code = 4; break; + case PK_PAGEUP: code = 5; break; + case PK_PAGEDOWN: code = 6; break; + default: code = 0; break; /* else gcc warns `enum value not used' */ + } + p += sprintf((char *) p, "\x1B[%d~", code); + goto done; + } + + if (PK_ISFKEY(keysym)) { + /* Map Shift+F1-F10 to F11-F20 */ + if (keysym >= PK_F1 && keysym <= PK_F10 && (modifiers & PKM_SHIFT)) + keysym += 10; + if ((term->vt52_mode || term->cfg.funky_type == FUNKY_VT100P) && + keysym <= PK_F14) { + /* XXX This overrides the XTERM/VT52 mode below */ + int offt = 0; + if (keysym >= PK_F6) offt++; + if (keysym >= PK_F12) offt++; + p += sprintf((char *) p, term->vt52_mode ? "\x1B%c" : "\x1BO%c", + 'P' + keysym - PK_F1 - offt); + goto done; + } + if (term->cfg.funky_type == FUNKY_LINUX && keysym <= PK_F5) { + p += sprintf((char *) p, "\x1B[[%c", 'A' + keysym - PK_F1); + goto done; + } + if (term->cfg.funky_type == FUNKY_XTERM && keysym <= PK_F4) { + if (term->vt52_mode) + p += sprintf((char *) p, "\x1B%c", 'P' + keysym - PK_F1); + else + p += sprintf((char *) p, "\x1BO%c", 'P' + keysym - PK_F1); + goto done; + } + p += sprintf((char *) p, "\x1B[%d~", 11 + keysym - PK_F1); + goto done; + } + + if (PK_ISCURSOR(keysym)) { + int xkey; + + switch (keysym) { + case PK_UP: xkey = 'A'; break; + case PK_DOWN: xkey = 'B'; break; + case PK_RIGHT: xkey = 'C'; break; + case PK_LEFT: xkey = 'D'; break; + case PK_REST: xkey = 'G'; break; /* centre key on number pad */ + default: xkey = 0; break; /* else gcc warns `enum value not used' */ + } + if (term->vt52_mode) + p += sprintf((char *) p, "\x1B%c", xkey); + else { + int app_flg = (term->app_cursor_keys && !term->cfg.no_applic_c); + + /* Useful mapping of Ctrl-arrows */ + if (modifiers == PKM_CONTROL) + app_flg = !app_flg; + + if (app_flg) + p += sprintf((char *) p, "\x1BO%c", xkey); + else + p += sprintf((char *) p, "\x1B[%c", xkey); + } + goto done; + } + + done: + if (p > output || tlen > 0) { + /* + * Interrupt an ongoing paste. I'm not sure + * this is sensible, but for the moment it's + * preferable to having to faff about buffering + * things. + */ + term_nopaste(term); + + /* + * We need not bother about stdin backlogs + * here, because in GUI PuTTY we can't do + * anything about it anyway; there's no means + * of asking Windows to hold off on KEYDOWN + * messages. We _have_ to buffer everything + * we're sent. + */ + term_seen_key_event(term); + + if (prependesc) { +#if 0 + fprintf(stderr, "sending ESC\n"); +#endif + ldisc_send(term->ldisc, "\x1b", 1, 1); + } + + if (p > output) { +#if 0 + fprintf(stderr, "sending %d bytes:", p - output); + for (i = 0; i < p - output; i++) + fprintf(stderr, " %02x", output[i]); + fprintf(stderr, "\n"); +#endif + ldisc_send(term->ldisc, output, p - output, 1); + } else if (tlen > 0) { +#if 0 + fprintf(stderr, "sending %d unichars:", tlen); + for (i = 0; i < tlen; i++) + fprintf(stderr, " %04x", (unsigned) text[i]); + fprintf(stderr, "\n"); +#endif + luni_send(term->ldisc, text, tlen, 1); + } + } +} + void term_nopaste(Terminal *term) { if (term->paste_len == 0) @@ -3890,17 +5471,17 @@ int term_ldisc(Terminal *term, int option) return FALSE; } -/* - * from_backend(), to get data from the backend for the terminal. - */ -int from_backend(void *vterm, int is_stderr, char *data, int len) +int term_data(Terminal *term, int is_stderr, const char *data, int len) { - Terminal *term = (Terminal *)vterm; - - assert(len > 0); - bufchain_add(&term->inbuf, data, len); + if (!term->in_term_out) { + term->in_term_out = TRUE; + term_blink(term, 1); + term_out(term); + term->in_term_out = FALSE; + } + /* * term_out() always completely empties inbuf. Therefore, * there's no reason at all to return anything other than zero