aniani/vim
0
0
Fork 1
mirror of https://github.com/vim/vim.git synced 2025-07-26 11:04:33 -04:00
Code

patch 8.0.1757: unnecessary changes in libvterm

Browse Source 
Problem:    Unnecessary changes in libvterm.
Solution:   Bring back // comments and trailing comma in enums.
This commit is contained in:
Bram Moolenaar 2018-04-24 18:39:14 +02:00
parent 73658317ba
commit b691de05f6
16 changed files with 318 additions and 318 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/libvterm/bin/unterm.c
View File

@ -9,7 +9,7 @@
#include "vterm.h" #include "vterm.h"
#define DEFINE_INLINES #define DEFINE_INLINES
#include "../src/utf8.h" /* fill_utf8 */ #include "../src/utf8.h" // fill_utf8
#define streq(a,b) (!strcmp(a,b)) #define streq(a,b) (!strcmp(a,b))
@ -21,7 +21,7 @@ static int rows;
static enum { static enum {
FORMAT_PLAIN, FORMAT_PLAIN,
FORMAT_SGR FORMAT_SGR,
} format = FORMAT_PLAIN; } format = FORMAT_PLAIN;
static int col2index(VTermColor target) static int col2index(VTermColor target)
@ -44,8 +44,8 @@ static void dump_cell(const VTermScreenCell *cell, const VTermScreenCell *prevce
break; break;
case FORMAT_SGR: case FORMAT_SGR:
{ {
/* If all 7 attributes change, that means 7 SGRs max */ // If all 7 attributes change, that means 7 SGRs max
/* Each colour could consume up to 3 */ // Each colour could consume up to 3
int sgr[7 + 2*3]; int sgri = 0; int sgr[7 + 2*3]; int sgri = 0;
if(!prevcell->attrs.bold && cell->attrs.bold) if(!prevcell->attrs.bold && cell->attrs.bold)

14
src/libvterm/bin/vterm-ctrl.c
View File

@ -35,7 +35,7 @@ static int getchoice(int *argip, int argc, char *argv[], const char *options[])
typedef enum { typedef enum {
OFF, OFF,
ON, ON,
QUERY QUERY,
} BoolQuery; } BoolQuery;
static BoolQuery getboolq(int *argip, int argc, char *argv[]) static BoolQuery getboolq(int *argip, int argc, char *argv[])
@ -105,7 +105,7 @@ static char *read_csi()
unsigned char csi[32]; unsigned char csi[32];
int i = 0; int i = 0;
await_c1(0x9B); /* CSI */ await_c1(0x9B); // CSI
/* TODO: This really should be a more robust CSI parser /* TODO: This really should be a more robust CSI parser
*/ */
@ -116,7 +116,7 @@ static char *read_csi()
} }
csi[++i] = 0; csi[++i] = 0;
/* TODO: returns longer than 32? */ // TODO: returns longer than 32?
return strdup((char *)csi); return strdup((char *)csi);
} }
@ -131,7 +131,7 @@ static char *read_dcs()
for(i = 0; i < sizeof(dcs)-1; ) { for(i = 0; i < sizeof(dcs)-1; ) {
char c = getchar(); char c = getchar();
if(c == 0x9c) /* ST */ if(c == 0x9c) // ST
break; break;
if(in_esc && c == 0x5c) if(in_esc && c == 0x5c)
break; break;
@ -301,12 +301,12 @@ int main(int argc, char *argv[])
do_dec_mode(12, getboolq(&argi, argc, argv), "curblink"); do_dec_mode(12, getboolq(&argi, argc, argv), "curblink");
} }
else if(streq(arg, "curshape")) { else if(streq(arg, "curshape")) {
/* TODO: This ought to query the current value of DECSCUSR because it */ // TODO: This ought to query the current value of DECSCUSR because it
/* may need blinking on or off */ // may need blinking on or off
const char *choices[] = {"block", "under", "bar", "query", NULL}; const char *choices[] = {"block", "under", "bar", "query", NULL};
int shape = getchoice(&argi, argc, argv, choices); int shape = getchoice(&argi, argc, argv, choices);
switch(shape) { switch(shape) {
case 3: /* query */ case 3: // query
shape = query_rqss_numeric(" q"); shape = query_rqss_numeric(" q");
switch(shape) { switch(shape) {
case 1: case 2: case 1: case 2:

22
src/libvterm/bin/vterm-dump.c
View File

@ -1,4 +1,4 @@
/* Require getopt(3) */ // Require getopt(3)
#define _XOPEN_SOURCE #define _XOPEN_SOURCE
#include <stdio.h> #include <stdio.h>
@ -22,28 +22,28 @@ static int parser_text(const char bytes[], size_t len, void *user)
int i; int i;
for(i = 0; i < len; /* none */) { for(i = 0; i < len; /* none */) {
if(b[i] < 0x20) /* C0 */ if(b[i] < 0x20) // C0
break; break;
else if(b[i] < 0x80) /* ASCII */ else if(b[i] < 0x80) // ASCII
i++; i++;
else if(b[i] < 0xa0) /* C1 */ else if(b[i] < 0xa0) // C1
break; break;
else if(b[i] < 0xc0) /* UTF-8 continuation */ else if(b[i] < 0xc0) // UTF-8 continuation
break; break;
else if(b[i] < 0xe0) { /* UTF-8 2-byte */ else if(b[i] < 0xe0) { // UTF-8 2-byte
/* 2-byte UTF-8 */ // 2-byte UTF-8
if(len < i+2) break; if(len < i+2) break;
i += 2; i += 2;
} }
else if(b[i] < 0xf0) { /* UTF-8 3-byte */ else if(b[i] < 0xf0) { // UTF-8 3-byte
if(len < i+3) break; if(len < i+3) break;
i += 3; i += 3;
} }
else if(b[i] < 0xf8) { /* UTF-8 4-byte */ else if(b[i] < 0xf8) { // UTF-8 4-byte
if(len < i+4) break; if(len < i+4) break;
i += 4; i += 4;
} }
else /* otherwise invalid */ else // otherwise invalid
break; break;
} }
@ -200,7 +200,7 @@ int main(int argc, char *argv[])
file = argv[optind++]; file = argv[optind++];
if(!file || streq(file, "-")) if(!file || streq(file, "-"))
fd = 0; /* stdin */ fd = 0; // stdin
else { else {
fd = open(file, O_RDONLY); fd = open(file, O_RDONLY);
if(fd == -1) { if(fd == -1) {

64
src/libvterm/include/vterm.h
View File

@ -110,30 +110,30 @@ typedef union {
typedef enum { typedef enum {
/* VTERM_ATTR_NONE = 0 */ /* VTERM_ATTR_NONE = 0 */
VTERM_ATTR_BOLD = 1, /* bool: 1, 22 */ VTERM_ATTR_BOLD = 1, // bool: 1, 22
VTERM_ATTR_UNDERLINE, /* number: 4, 21, 24 */ VTERM_ATTR_UNDERLINE, // number: 4, 21, 24
VTERM_ATTR_ITALIC, /* bool: 3, 23 */ VTERM_ATTR_ITALIC, // bool: 3, 23
VTERM_ATTR_BLINK, /* bool: 5, 25 */ VTERM_ATTR_BLINK, // bool: 5, 25
VTERM_ATTR_REVERSE, /* bool: 7, 27 */ VTERM_ATTR_REVERSE, // bool: 7, 27
VTERM_ATTR_STRIKE, /* bool: 9, 29 */ VTERM_ATTR_STRIKE, // bool: 9, 29
VTERM_ATTR_FONT, /* number: 10-19 */ VTERM_ATTR_FONT, // number: 10-19
VTERM_ATTR_FOREGROUND, /* color: 30-39 90-97 */ VTERM_ATTR_FOREGROUND, // color: 30-39 90-97
VTERM_ATTR_BACKGROUND, /* color: 40-49 100-107 */ VTERM_ATTR_BACKGROUND, // color: 40-49 100-107
VTERM_N_ATTRS VTERM_N_ATTRS
} VTermAttr; } VTermAttr;
typedef enum { typedef enum {
/* VTERM_PROP_NONE = 0 */ /* VTERM_PROP_NONE = 0 */
VTERM_PROP_CURSORVISIBLE = 1, /* bool */ VTERM_PROP_CURSORVISIBLE = 1, // bool
VTERM_PROP_CURSORBLINK, /* bool */ VTERM_PROP_CURSORBLINK, // bool
VTERM_PROP_ALTSCREEN, /* bool */ VTERM_PROP_ALTSCREEN, // bool
VTERM_PROP_TITLE, /* string */ VTERM_PROP_TITLE, // string
VTERM_PROP_ICONNAME, /* string */ VTERM_PROP_ICONNAME, // string
VTERM_PROP_REVERSE, /* bool */ VTERM_PROP_REVERSE, // bool
VTERM_PROP_CURSORSHAPE, /* number */ VTERM_PROP_CURSORSHAPE, // number
VTERM_PROP_MOUSE, /* number */ VTERM_PROP_MOUSE, // number
VTERM_PROP_CURSORCOLOR, /* string */ VTERM_PROP_CURSORCOLOR, // string
VTERM_N_PROPS VTERM_N_PROPS
} VTermProp; } VTermProp;
@ -211,9 +211,9 @@ void vterm_mouse_move(VTerm *vt, int row, int col, VTermModifier mod);
* Button 4 is scroll wheel down, button 5 is scroll wheel up. */ * Button 4 is scroll wheel down, button 5 is scroll wheel up. */
void vterm_mouse_button(VTerm *vt, int button, int pressed, VTermModifier mod); void vterm_mouse_button(VTerm *vt, int button, int pressed, VTermModifier mod);
/* ------------ // ------------
* Parser layer // Parser layer
* ------------ */ // ------------
/* Flag to indicate non-final subparameters in a single CSI parameter. /* Flag to indicate non-final subparameters in a single CSI parameter.
* Consider * Consider
@ -249,9 +249,9 @@ typedef struct {
void vterm_parser_set_callbacks(VTerm *vt, const VTermParserCallbacks *callbacks, void *user); void vterm_parser_set_callbacks(VTerm *vt, const VTermParserCallbacks *callbacks, void *user);
void *vterm_parser_get_cbdata(VTerm *vt); void *vterm_parser_get_cbdata(VTerm *vt);
/* ----------- // -----------
* State layer // State layer
* ----------- */ // -----------
typedef struct { typedef struct {
int (*putglyph)(VTermGlyphInfo *info, VTermPos pos, void *user); int (*putglyph)(VTermGlyphInfo *info, VTermPos pos, void *user);
@ -287,7 +287,7 @@ VTermState *vterm_obtain_state(VTerm *vt);
void vterm_state_set_callbacks(VTermState *state, const VTermStateCallbacks *callbacks, void *user); void vterm_state_set_callbacks(VTermState *state, const VTermStateCallbacks *callbacks, void *user);
void *vterm_state_get_cbdata(VTermState *state); void *vterm_state_get_cbdata(VTermState *state);
/* Only invokes control, csi, osc, dcs */ // Only invokes control, csi, osc, dcs
void vterm_state_set_unrecognised_fallbacks(VTermState *state, const VTermParserCallbacks *fallbacks, void *user); void vterm_state_set_unrecognised_fallbacks(VTermState *state, const VTermParserCallbacks *fallbacks, void *user);
void *vterm_state_get_unrecognised_fbdata(VTermState *state); void *vterm_state_get_unrecognised_fbdata(VTermState *state);
@ -307,9 +307,9 @@ void vterm_state_focus_in(VTermState *state);
void vterm_state_focus_out(VTermState *state); void vterm_state_focus_out(VTermState *state);
const VTermLineInfo *vterm_state_get_lineinfo(const VTermState *state, int row); const VTermLineInfo *vterm_state_get_lineinfo(const VTermState *state, int row);
/* ------------ // ------------
* Screen layer // Screen layer
* ------------ */ // ------------
typedef struct { typedef struct {
unsigned int bold : 1; unsigned int bold : 1;
@ -356,7 +356,7 @@ VTermScreen *vterm_obtain_screen(VTerm *vt);
void vterm_screen_set_callbacks(VTermScreen *screen, const VTermScreenCallbacks *callbacks, void *user); void vterm_screen_set_callbacks(VTermScreen *screen, const VTermScreenCallbacks *callbacks, void *user);
void *vterm_screen_get_cbdata(VTermScreen *screen); void *vterm_screen_get_cbdata(VTermScreen *screen);
/* Only invokes control, csi, osc, dcs */ // Only invokes control, csi, osc, dcs
void vterm_screen_set_unrecognised_fallbacks(VTermScreen *screen, const VTermParserCallbacks *fallbacks, void *user); void vterm_screen_set_unrecognised_fallbacks(VTermScreen *screen, const VTermParserCallbacks *fallbacks, void *user);
void *vterm_screen_get_unrecognised_fbdata(VTermScreen *screen); void *vterm_screen_get_unrecognised_fbdata(VTermScreen *screen);
@ -409,9 +409,9 @@ int vterm_screen_get_cell(const VTermScreen *screen, VTermPos pos, VTermScreenCe
int vterm_screen_is_eol(const VTermScreen *screen, VTermPos pos); int vterm_screen_is_eol(const VTermScreen *screen, VTermPos pos);
/* --------- // ---------
* Utilities // Utilities
* --------- */ // ---------
VTermValueType vterm_get_attr_type(VTermAttr attr); VTermValueType vterm_get_attr_type(VTermAttr attr);
VTermValueType vterm_get_prop_type(VTermProp prop); VTermValueType vterm_get_prop_type(VTermProp prop);

2
src/libvterm/include/vterm_keycodes.h
View File

@ -55,7 +55,7 @@ typedef enum {
VTERM_KEY_KP_ENTER, VTERM_KEY_KP_ENTER,
VTERM_KEY_KP_EQUAL, VTERM_KEY_KP_EQUAL,
VTERM_KEY_MAX, /* Must be last */ VTERM_KEY_MAX, // Must be last
VTERM_N_KEYS = VTERM_KEY_MAX VTERM_N_KEYS = VTERM_KEY_MAX
} VTermKey; } VTermKey;

14
src/libvterm/src/encoding.c
View File

@ -7,11 +7,11 @@
#endif #endif
struct UTF8DecoderData { struct UTF8DecoderData {
/* number of bytes remaining in this codepoint */ // number of bytes remaining in this codepoint
int bytes_remaining; int bytes_remaining;
/* number of bytes total in this codepoint once it's finished // number of bytes total in this codepoint once it's finished
(for detecting overlongs) */ // (for detecting overlongs)
int bytes_total; int bytes_total;
int this_cp; int this_cp;
@ -42,7 +42,7 @@ static void decode_utf8(VTermEncoding *enc UNUSED, void *data_,
printf(" pos=%zd c=%02x rem=%d\n", *pos, c, data->bytes_remaining); printf(" pos=%zd c=%02x rem=%d\n", *pos, c, data->bytes_remaining);
#endif #endif
if(c < 0x20) /* C0 */ if(c < 0x20) // C0
return; return;
else if(c >= 0x20 && c < 0x7f) { else if(c >= 0x20 && c < 0x7f) {
@ -58,7 +58,7 @@ static void decode_utf8(VTermEncoding *enc UNUSED, void *data_,
#endif #endif
} }
else if(c == 0x7f) /* DEL */ else if(c == 0x7f) // DEL
return; return;
else if(c >= 0x80 && c < 0xc0) { else if(c >= 0x80 && c < 0xc0) {
@ -75,7 +75,7 @@ static void decode_utf8(VTermEncoding *enc UNUSED, void *data_,
#ifdef DEBUG_PRINT_UTF8 #ifdef DEBUG_PRINT_UTF8
printf(" UTF-8 raw char U+%04x bytelen=%d ", data->this_cp, data->bytes_total); printf(" UTF-8 raw char U+%04x bytelen=%d ", data->this_cp, data->bytes_total);
#endif #endif
/* Check for overlong sequences */ // Check for overlong sequences
switch(data->bytes_total) { switch(data->bytes_total) {
case 2: case 2:
if(data->this_cp < 0x0080) data->this_cp = UNICODE_INVALID; if(data->this_cp < 0x0080) data->this_cp = UNICODE_INVALID;
@ -93,7 +93,7 @@ static void decode_utf8(VTermEncoding *enc UNUSED, void *data_,
if(data->this_cp < 0x4000000) data->this_cp = UNICODE_INVALID; if(data->this_cp < 0x4000000) data->this_cp = UNICODE_INVALID;
break; break;
} }
/* Now look for plain invalid ones */ // Now look for plain invalid ones
if((data->this_cp >= 0xD800 && data->this_cp <= 0xDFFF) || if((data->this_cp >= 0xD800 && data->this_cp <= 0xDFFF) ||
data->this_cp == 0xFFFE || data->this_cp == 0xFFFE ||
data->this_cp == 0xFFFF) data->this_cp == 0xFFFF)

96
src/libvterm/src/keyboard.c
View File

@ -15,7 +15,7 @@ void vterm_keyboard_unichar(VTerm *vt, uint32_t c, VTermModifier mod)
mod &= ~VTERM_MOD_SHIFT; mod &= ~VTERM_MOD_SHIFT;
if(mod == 0) { if(mod == 0) {
/* Normal text - ignore just shift */ // Normal text - ignore just shift
char str[6]; char str[6];
int seqlen = fill_utf8(c, str); int seqlen = fill_utf8(c, str);
vterm_push_output_bytes(vt, str, seqlen); vterm_push_output_bytes(vt, str, seqlen);
@ -62,7 +62,7 @@ typedef struct {
KEYCODE_CSI, KEYCODE_CSI,
KEYCODE_CSI_CURSOR, KEYCODE_CSI_CURSOR,
KEYCODE_CSINUM, KEYCODE_CSINUM,
KEYCODE_KEYPAD KEYCODE_KEYPAD,
} type; } type;
char literal; char literal;
int csinum; int csinum;
@ -70,61 +70,61 @@ typedef struct {
/* Order here must be exactly the same as VTermKey enum! */ /* Order here must be exactly the same as VTermKey enum! */
static keycodes_s keycodes[] = { static keycodes_s keycodes[] = {
{ KEYCODE_NONE, 0, 0 }, /* NONE */ { KEYCODE_NONE, 0, 0 }, // NONE
{ KEYCODE_ENTER, '\r', 0 }, /* ENTER */ { KEYCODE_ENTER, '\r', 0 }, // ENTER
{ KEYCODE_TAB, '\t', 0 }, /* TAB */ { KEYCODE_TAB, '\t', 0 }, // TAB
{ KEYCODE_LITERAL, '\x7f', 0 }, /* BACKSPACE == ASCII DEL */ { KEYCODE_LITERAL, '\x7f', 0 }, // BACKSPACE == ASCII DEL
{ KEYCODE_LITERAL, '\x1b', 0 }, /* ESCAPE */ { KEYCODE_LITERAL, '\x1b', 0 }, // ESCAPE
{ KEYCODE_CSI_CURSOR, 'A', 0 }, /* UP */ { KEYCODE_CSI_CURSOR, 'A', 0 }, // UP
{ KEYCODE_CSI_CURSOR, 'B', 0 }, /* DOWN */ { KEYCODE_CSI_CURSOR, 'B', 0 }, // DOWN
{ KEYCODE_CSI_CURSOR, 'D', 0 }, /* LEFT */ { KEYCODE_CSI_CURSOR, 'D', 0 }, // LEFT
{ KEYCODE_CSI_CURSOR, 'C', 0 }, /* RIGHT */ { KEYCODE_CSI_CURSOR, 'C', 0 }, // RIGHT
{ KEYCODE_CSINUM, '~', 2 }, /* INS */ { KEYCODE_CSINUM, '~', 2 }, // INS
{ KEYCODE_CSINUM, '~', 3 }, /* DEL */ { KEYCODE_CSINUM, '~', 3 }, // DEL
{ KEYCODE_CSI_CURSOR, 'H', 0 }, /* HOME */ { KEYCODE_CSI_CURSOR, 'H', 0 }, // HOME
{ KEYCODE_CSI_CURSOR, 'F', 0 }, /* END */ { KEYCODE_CSI_CURSOR, 'F', 0 }, // END
{ KEYCODE_CSINUM, '~', 5 }, /* PAGEUP */ { KEYCODE_CSINUM, '~', 5 }, // PAGEUP
{ KEYCODE_CSINUM, '~', 6 }, /* PAGEDOWN */ { KEYCODE_CSINUM, '~', 6 }, // PAGEDOWN
}; };
static keycodes_s keycodes_fn[] = { static keycodes_s keycodes_fn[] = {
{ KEYCODE_NONE, 0, 0 }, /* F0 - shouldn't happen */ { KEYCODE_NONE, 0, 0 }, // F0 - shouldn't happen
{ KEYCODE_CSI_CURSOR, 'P', 0 }, /* F1 */ { KEYCODE_CSI_CURSOR, 'P', 0 }, // F1
{ KEYCODE_CSI_CURSOR, 'Q', 0 }, /* F2 */ { KEYCODE_CSI_CURSOR, 'Q', 0 }, // F2
{ KEYCODE_CSI_CURSOR, 'R', 0 }, /* F3 */ { KEYCODE_CSI_CURSOR, 'R', 0 }, // F3
{ KEYCODE_CSI_CURSOR, 'S', 0 }, /* F4 */ { KEYCODE_CSI_CURSOR, 'S', 0 }, // F4
{ KEYCODE_CSINUM, '~', 15 }, /* F5 */ { KEYCODE_CSINUM, '~', 15 }, // F5
{ KEYCODE_CSINUM, '~', 17 }, /* F6 */ { KEYCODE_CSINUM, '~', 17 }, // F6
{ KEYCODE_CSINUM, '~', 18 }, /* F7 */ { KEYCODE_CSINUM, '~', 18 }, // F7
{ KEYCODE_CSINUM, '~', 19 }, /* F8 */ { KEYCODE_CSINUM, '~', 19 }, // F8
{ KEYCODE_CSINUM, '~', 20 }, /* F9 */ { KEYCODE_CSINUM, '~', 20 }, // F9
{ KEYCODE_CSINUM, '~', 21 }, /* F10 */ { KEYCODE_CSINUM, '~', 21 }, // F10
{ KEYCODE_CSINUM, '~', 23 }, /* F11 */ { KEYCODE_CSINUM, '~', 23 }, // F11
{ KEYCODE_CSINUM, '~', 24 }, /* F12 */ { KEYCODE_CSINUM, '~', 24 }, // F12
}; };
static keycodes_s keycodes_kp[] = { static keycodes_s keycodes_kp[] = {
{ KEYCODE_KEYPAD, '0', 'p' }, /* KP_0 */ { KEYCODE_KEYPAD, '0', 'p' }, // KP_0
{ KEYCODE_KEYPAD, '1', 'q' }, /* KP_1 */ { KEYCODE_KEYPAD, '1', 'q' }, // KP_1
{ KEYCODE_KEYPAD, '2', 'r' }, /* KP_2 */ { KEYCODE_KEYPAD, '2', 'r' }, // KP_2
{ KEYCODE_KEYPAD, '3', 's' }, /* KP_3 */ { KEYCODE_KEYPAD, '3', 's' }, // KP_3
{ KEYCODE_KEYPAD, '4', 't' }, /* KP_4 */ { KEYCODE_KEYPAD, '4', 't' }, // KP_4
{ KEYCODE_KEYPAD, '5', 'u' }, /* KP_5 */ { KEYCODE_KEYPAD, '5', 'u' }, // KP_5
{ KEYCODE_KEYPAD, '6', 'v' }, /* KP_6 */ { KEYCODE_KEYPAD, '6', 'v' }, // KP_6
{ KEYCODE_KEYPAD, '7', 'w' }, /* KP_7 */ { KEYCODE_KEYPAD, '7', 'w' }, // KP_7
{ KEYCODE_KEYPAD, '8', 'x' }, /* KP_8 */ { KEYCODE_KEYPAD, '8', 'x' }, // KP_8
{ KEYCODE_KEYPAD, '9', 'y' }, /* KP_9 */ { KEYCODE_KEYPAD, '9', 'y' }, // KP_9
{ KEYCODE_KEYPAD, '*', 'j' }, /* KP_MULT */ { KEYCODE_KEYPAD, '*', 'j' }, // KP_MULT
{ KEYCODE_KEYPAD, '+', 'k' }, /* KP_PLUS */ { KEYCODE_KEYPAD, '+', 'k' }, // KP_PLUS
{ KEYCODE_KEYPAD, ',', 'l' }, /* KP_COMMA */ { KEYCODE_KEYPAD, ',', 'l' }, // KP_COMMA
{ KEYCODE_KEYPAD, '-', 'm' }, /* KP_MINUS */ { KEYCODE_KEYPAD, '-', 'm' }, // KP_MINUS
{ KEYCODE_KEYPAD, '.', 'n' }, /* KP_PERIOD */ { KEYCODE_KEYPAD, '.', 'n' }, // KP_PERIOD
{ KEYCODE_KEYPAD, '/', 'o' }, /* KP_DIVIDE */ { KEYCODE_KEYPAD, '/', 'o' }, // KP_DIVIDE
{ KEYCODE_KEYPAD, '\n', 'M' }, /* KP_ENTER */ { KEYCODE_KEYPAD, '\n', 'M' }, // KP_ENTER
{ KEYCODE_KEYPAD, '=', 'X' }, /* KP_EQUAL */ { KEYCODE_KEYPAD, '=', 'X' }, // KP_EQUAL
}; };
void vterm_keyboard_key(VTerm *vt, VTermKey key, VTermModifier mod) void vterm_keyboard_key(VTerm *vt, VTermKey key, VTermModifier mod)

32
src/libvterm/src/parser.c
View File

@ -148,18 +148,18 @@ size_t vterm_input_write(VTerm *vt, const char *bytes, size_t len)
for( ; pos < len; pos++) { for( ; pos < len; pos++) {
unsigned char c = bytes[pos]; unsigned char c = bytes[pos];
if(c == 0x00 || c == 0x7f) { /* NUL, DEL */ if(c == 0x00 || c == 0x7f) { // NUL, DEL
if(vt->parser.state >= STRING) { if(vt->parser.state >= STRING) {
more_string(vt, string_start, bytes + pos - string_start); more_string(vt, string_start, bytes + pos - string_start);
string_start = bytes + pos + 1; string_start = bytes + pos + 1;
} }
continue; continue;
} }
if(c == 0x18 || c == 0x1a) { /* CAN, SUB */ if(c == 0x18 || c == 0x1a) { // CAN, SUB
ENTER_NORMAL_STATE(); ENTER_NORMAL_STATE();
continue; continue;
} }
else if(c == 0x1b) { /* ESC */ else if(c == 0x1b) { // ESC
vt->parser.intermedlen = 0; vt->parser.intermedlen = 0;
if(vt->parser.state == STRING) if(vt->parser.state == STRING)
vt->parser.state = ESC_IN_STRING; vt->parser.state = ESC_IN_STRING;
@ -167,11 +167,11 @@ size_t vterm_input_write(VTerm *vt, const char *bytes, size_t len)
ENTER_STATE(ESC); ENTER_STATE(ESC);
continue; continue;
} }
else if(c == 0x07 && /* BEL, can stand for ST in OSC or DCS state */ else if(c == 0x07 && // BEL, can stand for ST in OSC or DCS state
vt->parser.state == STRING) { vt->parser.state == STRING) {
/* fallthrough */ // fallthrough
} }
else if(c < 0x20) { /* other C0 */ else if(c < 0x20) { // other C0
if(vt->parser.state >= STRING) if(vt->parser.state >= STRING)
more_string(vt, string_start, bytes + pos - string_start); more_string(vt, string_start, bytes + pos - string_start);
do_control(vt, c); do_control(vt, c);
@ -179,30 +179,30 @@ size_t vterm_input_write(VTerm *vt, const char *bytes, size_t len)
string_start = bytes + pos + 1; string_start = bytes + pos + 1;
continue; continue;
} }
/* else fallthrough */ // else fallthrough
switch(vt->parser.state) { switch(vt->parser.state) {
case ESC_IN_STRING: case ESC_IN_STRING:
if(c == 0x5c) { /* ST */ if(c == 0x5c) { // ST
vt->parser.state = STRING; vt->parser.state = STRING;
done_string(vt, string_start, bytes + pos - string_start - 1); done_string(vt, string_start, bytes + pos - string_start - 1);
ENTER_NORMAL_STATE(); ENTER_NORMAL_STATE();
break; break;
} }
vt->parser.state = ESC; vt->parser.state = ESC;
/* else fallthrough */ // else fallthrough
case ESC: case ESC:
switch(c) { switch(c) {
case 0x50: /* DCS */ case 0x50: // DCS
start_string(vt, VTERM_PARSER_DCS); start_string(vt, VTERM_PARSER_DCS);
ENTER_STRING_STATE(); ENTER_STRING_STATE();
break; break;
case 0x5b: /* CSI */ case 0x5b: // CSI
vt->parser.csi_leaderlen = 0; vt->parser.csi_leaderlen = 0;
ENTER_STATE(CSI_LEADER); ENTER_STATE(CSI_LEADER);
break; break;
case 0x5d: /* OSC */ case 0x5d: // OSC
start_string(vt, VTERM_PARSER_OSC); start_string(vt, VTERM_PARSER_OSC);
ENTER_STRING_STATE(); ENTER_STRING_STATE();
break; break;
@ -298,14 +298,14 @@ size_t vterm_input_write(VTerm *vt, const char *bytes, size_t len)
case NORMAL: case NORMAL:
if(c >= 0x80 && c < 0xa0 && !vt->mode.utf8) { if(c >= 0x80 && c < 0xa0 && !vt->mode.utf8) {
switch(c) { switch(c) {
case 0x90: /* DCS */ case 0x90: // DCS
start_string(vt, VTERM_PARSER_DCS); start_string(vt, VTERM_PARSER_DCS);
ENTER_STRING_STATE(); ENTER_STRING_STATE();
break; break;
case 0x9b: /* CSI */ case 0x9b: // CSI
ENTER_STATE(CSI_LEADER); ENTER_STATE(CSI_LEADER);
break; break;
case 0x9d: /* OSC */ case 0x9d: // OSC
start_string(vt, VTERM_PARSER_OSC); start_string(vt, VTERM_PARSER_OSC);
ENTER_STRING_STATE(); ENTER_STRING_STATE();
break; break;
@ -325,7 +325,7 @@ size_t vterm_input_write(VTerm *vt, const char *bytes, size_t len)
eaten = 1; eaten = 1;
} }
pos += (eaten - 1); /* we'll ++ it again in a moment */ pos += (eaten - 1); // we'll ++ it again in a moment
} }
break; break;
} }

104
src/libvterm/src/pen.c
View File

@ -4,24 +4,24 @@
static const VTermColor ansi_colors[] = { static const VTermColor ansi_colors[] = {
/* R G B index */ /* R G B index */
{ 0, 0, 0, 1 }, /* black */ { 0, 0, 0, 1 }, // black
{ 224, 0, 0, 2 }, /* red */ { 224, 0, 0, 2 }, // red
{ 0, 224, 0, 3 }, /* green */ { 0, 224, 0, 3 }, // green
{ 224, 224, 0, 4 }, /* yellow */ { 224, 224, 0, 4 }, // yellow
{ 0, 0, 224, 5 }, /* blue */ { 0, 0, 224, 5 }, // blue
{ 224, 0, 224, 6 }, /* magenta */ { 224, 0, 224, 6 }, // magenta
{ 0, 224, 224, 7 }, /* cyan */ { 0, 224, 224, 7 }, // cyan
{ 224, 224, 224, 8 }, /* white == light grey */ { 224, 224, 224, 8 }, // white == light grey
/* high intensity */ // high intensity
{ 128, 128, 128, 9 }, /* black */ { 128, 128, 128, 9 }, // black
{ 255, 64, 64, 10 }, /* red */ { 255, 64, 64, 10 }, // red
{ 64, 255, 64, 11 }, /* green */ { 64, 255, 64, 11 }, // green
{ 255, 255, 64, 12 }, /* yellow */ { 255, 255, 64, 12 }, // yellow
{ 64, 64, 255, 13 }, /* blue */ { 64, 64, 255, 13 }, // blue
{ 255, 64, 255, 14 }, /* magenta */ { 255, 64, 255, 14 }, // magenta
{ 64, 255, 255, 15 }, /* cyan */ { 64, 255, 255, 15 }, // cyan
{ 255, 255, 255, 16 }, /* white for real */ { 255, 255, 255, 16 }, // white for real
}; };
static int ramp6[] = { static int ramp6[] = {
@ -47,11 +47,11 @@ static int lookup_colour_ansi(const VTermState *state, long index, VTermColor *c
static int lookup_colour_palette(const VTermState *state, long index, VTermColor *col) static int lookup_colour_palette(const VTermState *state, long index, VTermColor *col)
{ {
if(index >= 0 && index < 16) { if(index >= 0 && index < 16) {
/* Normal 8 colours or high intensity - parse as palette 0 */ // Normal 8 colours or high intensity - parse as palette 0
return lookup_colour_ansi(state, index, col); return lookup_colour_ansi(state, index, col);
} }
else if(index >= 16 && index < 232) { else if(index >= 16 && index < 232) {
/* 216-colour cube */ // 216-colour cube
index -= 16; index -= 16;
col->blue = ramp6[index % 6]; col->blue = ramp6[index % 6];
@ -62,7 +62,7 @@ static int lookup_colour_palette(const VTermState *state, long index, VTermColor
return TRUE; return TRUE;
} }
else if(index >= 232 && index < 256) { else if(index >= 232 && index < 256) {
/* 24 greyscales */ // 24 greyscales
index -= 232; index -= 232;
col->blue = ramp24[index]; col->blue = ramp24[index];
@ -79,7 +79,7 @@ static int lookup_colour_palette(const VTermState *state, long index, VTermColor
static int lookup_colour(const VTermState *state, int palette, const long args[], int argcount, VTermColor *col, int *index) static int lookup_colour(const VTermState *state, int palette, const long args[], int argcount, VTermColor *col, int *index)
{ {
switch(palette) { switch(palette) {
case 2: /* RGB mode - 3 args contain colour values directly */ case 2: // RGB mode - 3 args contain colour values directly
if(argcount < 3) if(argcount < 3)
return argcount; return argcount;
@ -90,7 +90,7 @@ static int lookup_colour(const VTermState *state, int palette, const long args[]
return 3; return 3;
case 5: /* XTerm 256-colour mode */ case 5: // XTerm 256-colour mode
if(index) if(index)
*index = CSI_ARG_OR(args[0], -1); *index = CSI_ARG_OR(args[0], -1);
@ -104,7 +104,7 @@ static int lookup_colour(const VTermState *state, int palette, const long args[]
} }
} }
/* Some conveniences */ // Some conveniences
static void setpenattr(VTermState *state, VTermAttr attr, VTermValueType type UNUSED, VTermValue *val) static void setpenattr(VTermState *state, VTermAttr attr, VTermValueType type UNUSED, VTermValue *val)
{ {
@ -153,7 +153,7 @@ INTERNAL void vterm_state_newpen(VTermState *state)
{ {
int col; int col;
/* 90% grey so that pure white is brighter */ // 90% grey so that pure white is brighter
state->default_fg.red = state->default_fg.green = state->default_fg.blue = 240; state->default_fg.red = state->default_fg.green = state->default_fg.blue = 240;
state->default_fg.ansi_index = VTERM_ANSI_INDEX_DEFAULT; state->default_fg.ansi_index = VTERM_ANSI_INDEX_DEFAULT;
state->default_bg.red = state->default_bg.green = state->default_bg.blue = 0; state->default_bg.red = state->default_bg.green = state->default_bg.blue = 0;
@ -232,98 +232,98 @@ void vterm_state_set_bold_highbright(VTermState *state, int bold_is_highbright)
INTERNAL void vterm_state_setpen(VTermState *state, const long args[], int argcount) INTERNAL void vterm_state_setpen(VTermState *state, const long args[], int argcount)
{ {
/* SGR - ECMA-48 8.3.117 */ // SGR - ECMA-48 8.3.117
int argi = 0; int argi = 0;
int value; int value;
while(argi < argcount) { while(argi < argcount) {
/* This logic is easier to do 'done' backwards; set it true, and make it // This logic is easier to do 'done' backwards; set it true, and make it
false again in the 'default' case */ // false again in the 'default' case
int done = 1; int done = 1;
long arg; long arg;
switch(arg = CSI_ARG(args[argi])) { switch(arg = CSI_ARG(args[argi])) {
case CSI_ARG_MISSING: case CSI_ARG_MISSING:
case 0: /* Reset */ case 0: // Reset
vterm_state_resetpen(state); vterm_state_resetpen(state);
break; break;
case 1: /* Bold on */ case 1: // Bold on
state->pen.bold = 1; state->pen.bold = 1;
setpenattr_bool(state, VTERM_ATTR_BOLD, 1); setpenattr_bool(state, VTERM_ATTR_BOLD, 1);
if(state->fg_index > -1 && state->fg_index < 8 && state->bold_is_highbright) if(state->fg_index > -1 && state->fg_index < 8 && state->bold_is_highbright)
set_pen_col_ansi(state, VTERM_ATTR_FOREGROUND, state->fg_index + (state->pen.bold ? 8 : 0)); set_pen_col_ansi(state, VTERM_ATTR_FOREGROUND, state->fg_index + (state->pen.bold ? 8 : 0));
break; break;
case 3: /* Italic on */ case 3: // Italic on
state->pen.italic = 1; state->pen.italic = 1;
setpenattr_bool(state, VTERM_ATTR_ITALIC, 1); setpenattr_bool(state, VTERM_ATTR_ITALIC, 1);
break; break;
case 4: /* Underline single */ case 4: // Underline single
state->pen.underline = 1; state->pen.underline = 1;
setpenattr_int(state, VTERM_ATTR_UNDERLINE, 1); setpenattr_int(state, VTERM_ATTR_UNDERLINE, 1);
break; break;
case 5: /* Blink */ case 5: // Blink
state->pen.blink = 1; state->pen.blink = 1;
setpenattr_bool(state, VTERM_ATTR_BLINK, 1); setpenattr_bool(state, VTERM_ATTR_BLINK, 1);
break; break;
case 7: /* Reverse on */ case 7: // Reverse on
state->pen.reverse = 1; state->pen.reverse = 1;
setpenattr_bool(state, VTERM_ATTR_REVERSE, 1); setpenattr_bool(state, VTERM_ATTR_REVERSE, 1);
break; break;
case 9: /* Strikethrough on */ case 9: // Strikethrough on
state->pen.strike = 1; state->pen.strike = 1;
setpenattr_bool(state, VTERM_ATTR_STRIKE, 1); setpenattr_bool(state, VTERM_ATTR_STRIKE, 1);
break; break;
case 10: case 11: case 12: case 13: case 14: case 10: case 11: case 12: case 13: case 14:
case 15: case 16: case 17: case 18: case 19: /* Select font */ case 15: case 16: case 17: case 18: case 19: // Select font
state->pen.font = CSI_ARG(args[argi]) - 10; state->pen.font = CSI_ARG(args[argi]) - 10;
setpenattr_int(state, VTERM_ATTR_FONT, state->pen.font); setpenattr_int(state, VTERM_ATTR_FONT, state->pen.font);
break; break;
case 21: /* Underline double */ case 21: // Underline double
state->pen.underline = 2; state->pen.underline = 2;
setpenattr_int(state, VTERM_ATTR_UNDERLINE, 2); setpenattr_int(state, VTERM_ATTR_UNDERLINE, 2);
break; break;
case 22: /* Bold off */ case 22: // Bold off
state->pen.bold = 0; state->pen.bold = 0;
setpenattr_bool(state, VTERM_ATTR_BOLD, 0); setpenattr_bool(state, VTERM_ATTR_BOLD, 0);
break; break;
case 23: /* Italic and Gothic (currently unsupported) off */ case 23: // Italic and Gothic (currently unsupported) off
state->pen.italic = 0; state->pen.italic = 0;
setpenattr_bool(state, VTERM_ATTR_ITALIC, 0); setpenattr_bool(state, VTERM_ATTR_ITALIC, 0);
break; break;
case 24: /* Underline off */ case 24: // Underline off
state->pen.underline = 0; state->pen.underline = 0;
setpenattr_int(state, VTERM_ATTR_UNDERLINE, 0); setpenattr_int(state, VTERM_ATTR_UNDERLINE, 0);
break; break;
case 25: /* Blink off */ case 25: // Blink off
state->pen.blink = 0; state->pen.blink = 0;
setpenattr_bool(state, VTERM_ATTR_BLINK, 0); setpenattr_bool(state, VTERM_ATTR_BLINK, 0);
break; break;
case 27: /* Reverse off */ case 27: // Reverse off
state->pen.reverse = 0; state->pen.reverse = 0;
setpenattr_bool(state, VTERM_ATTR_REVERSE, 0); setpenattr_bool(state, VTERM_ATTR_REVERSE, 0);
break; break;
case 29: /* Strikethrough off */ case 29: // Strikethrough off
state->pen.strike = 0; state->pen.strike = 0;
setpenattr_bool(state, VTERM_ATTR_STRIKE, 0); setpenattr_bool(state, VTERM_ATTR_STRIKE, 0);
break; break;
case 30: case 31: case 32: case 33: case 30: case 31: case 32: case 33:
case 34: case 35: case 36: case 37: /* Foreground colour palette */ case 34: case 35: case 36: case 37: // Foreground colour palette
value = CSI_ARG(args[argi]) - 30; value = CSI_ARG(args[argi]) - 30;
state->fg_index = value; state->fg_index = value;
if(state->pen.bold && state->bold_is_highbright) if(state->pen.bold && state->bold_is_highbright)
@ -331,7 +331,7 @@ INTERNAL void vterm_state_setpen(VTermState *state, const long args[], int argco
set_pen_col_ansi(state, VTERM_ATTR_FOREGROUND, value); set_pen_col_ansi(state, VTERM_ATTR_FOREGROUND, value);
break; break;
case 38: /* Foreground colour alternative palette */ case 38: // Foreground colour alternative palette
state->fg_index = -1; state->fg_index = -1;
if(argcount - argi < 1) if(argcount - argi < 1)
return; return;
@ -339,20 +339,20 @@ INTERNAL void vterm_state_setpen(VTermState *state, const long args[], int argco
setpenattr_col(state, VTERM_ATTR_FOREGROUND, state->pen.fg); setpenattr_col(state, VTERM_ATTR_FOREGROUND, state->pen.fg);
break; break;
case 39: /* Foreground colour default */ case 39: // Foreground colour default
state->fg_index = -1; state->fg_index = -1;
state->pen.fg = state->default_fg; state->pen.fg = state->default_fg;
setpenattr_col(state, VTERM_ATTR_FOREGROUND, state->pen.fg); setpenattr_col(state, VTERM_ATTR_FOREGROUND, state->pen.fg);
break; break;
case 40: case 41: case 42: case 43: case 40: case 41: case 42: case 43:
case 44: case 45: case 46: case 47: /* Background colour palette */ case 44: case 45: case 46: case 47: // Background colour palette
value = CSI_ARG(args[argi]) - 40; value = CSI_ARG(args[argi]) - 40;
state->bg_index = value; state->bg_index = value;
set_pen_col_ansi(state, VTERM_ATTR_BACKGROUND, value); set_pen_col_ansi(state, VTERM_ATTR_BACKGROUND, value);
break; break;
case 48: /* Background colour alternative palette */ case 48: // Background colour alternative palette
state->bg_index = -1; state->bg_index = -1;
if(argcount - argi < 1) if(argcount - argi < 1)
return; return;
@ -360,21 +360,21 @@ INTERNAL void vterm_state_setpen(VTermState *state, const long args[], int argco
setpenattr_col(state, VTERM_ATTR_BACKGROUND, state->pen.bg); setpenattr_col(state, VTERM_ATTR_BACKGROUND, state->pen.bg);
break; break;
case 49: /* Default background */ case 49: // Default background
state->bg_index = -1; state->bg_index = -1;
state->pen.bg = state->default_bg; state->pen.bg = state->default_bg;
setpenattr_col(state, VTERM_ATTR_BACKGROUND, state->pen.bg); setpenattr_col(state, VTERM_ATTR_BACKGROUND, state->pen.bg);
break; break;
case 90: case 91: case 92: case 93: case 90: case 91: case 92: case 93:
case 94: case 95: case 96: case 97: /* Foreground colour high-intensity palette */ case 94: case 95: case 96: case 97: // Foreground colour high-intensity palette
value = CSI_ARG(args[argi]) - 90 + 8; value = CSI_ARG(args[argi]) - 90 + 8;
state->fg_index = value; state->fg_index = value;
set_pen_col_ansi(state, VTERM_ATTR_FOREGROUND, value); set_pen_col_ansi(state, VTERM_ATTR_FOREGROUND, value);
break; break;
case 100: case 101: case 102: case 103: case 100: case 101: case 102: case 103:
case 104: case 105: case 106: case 107: /* Background colour high-intensity palette */ case 104: case 105: case 106: case 107: // Background colour high-intensity palette
value = CSI_ARG(args[argi]) - 100 + 8; value = CSI_ARG(args[argi]) - 100 + 8;
state->bg_index = value; state->bg_index = value;
set_pen_col_ansi(state, VTERM_ATTR_BACKGROUND, value); set_pen_col_ansi(state, VTERM_ATTR_BACKGROUND, value);
@ -432,7 +432,7 @@ INTERNAL int vterm_state_getpen(VTermState *state, long args[], int argcount UNU
args[argi++] = state->fg_index; args[argi++] = state->fg_index;
} }
else if(state->fg_index == -1) { else if(state->fg_index == -1) {
/* Send palette 2 if the actual FG colour is not default */ // Send palette 2 if the actual FG colour is not default
if(state->pen.fg.red != state->default_fg.red || if(state->pen.fg.red != state->default_fg.red ||
state->pen.fg.green != state->default_fg.green || state->pen.fg.green != state->default_fg.green ||
state->pen.fg.blue != state->default_fg.blue ) { state->pen.fg.blue != state->default_fg.blue ) {
@ -454,7 +454,7 @@ INTERNAL int vterm_state_getpen(VTermState *state, long args[], int argcount UNU
args[argi++] = state->bg_index; args[argi++] = state->bg_index;
} }
else if(state->bg_index == -1) { else if(state->bg_index == -1) {
/* Send palette 2 if the actual BG colour is not default */ // Send palette 2 if the actual BG colour is not default
if(state->pen.bg.red != state->default_bg.red || if(state->pen.bg.red != state->default_bg.red ||
state->pen.bg.green != state->default_bg.green || state->pen.bg.green != state->default_bg.green ||
state->pen.bg.blue != state->default_bg.blue ) { state->pen.bg.blue != state->default_bg.blue ) {

28
src/libvterm/src/screen.c
View File

@ -115,17 +115,17 @@ static void damagerect(VTermScreen *screen, VTermRect rect)
/* Emit damage longer than one row. Try to merge with existing damage in /* Emit damage longer than one row. Try to merge with existing damage in
* the same row */ * the same row */
if(rect.end_row > rect.start_row + 1) { if(rect.end_row > rect.start_row + 1) {
/* Bigger than 1 line - flush existing, emit this */ // Bigger than 1 line - flush existing, emit this
vterm_screen_flush_damage(screen); vterm_screen_flush_damage(screen);
emit = rect; emit = rect;
} }
else if(screen->damaged.start_row == -1) { else if(screen->damaged.start_row == -1) {
/* None stored yet */ // None stored yet
screen->damaged = rect; screen->damaged = rect;
return; return;
} }
else if(rect.start_row == screen->damaged.start_row) { else if(rect.start_row == screen->damaged.start_row) {
/* Merge with the stored line */ // Merge with the stored line
if(screen->damaged.start_col > rect.start_col) if(screen->damaged.start_col > rect.start_col)
screen->damaged.start_col = rect.start_col; screen->damaged.start_col = rect.start_col;
if(screen->damaged.end_col < rect.end_col) if(screen->damaged.end_col < rect.end_col)
@ -133,7 +133,7 @@ static void damagerect(VTermScreen *screen, VTermRect rect)
return; return;
} }
else { else {
/* Emit the currently stored line, store a new one */ // Emit the currently stored line, store a new one
emit = screen->damaged; emit = screen->damaged;
screen->damaged = rect; screen->damaged = rect;
} }
@ -208,9 +208,9 @@ static int moverect_internal(VTermRect dest, VTermRect src, void *user)
VTermScreen *screen = user; VTermScreen *screen = user;
if(screen->callbacks && screen->callbacks->sb_pushline && if(screen->callbacks && screen->callbacks->sb_pushline &&
dest.start_row == 0 && dest.start_col == 0 && /* starts top-left corner */ dest.start_row == 0 && dest.start_col == 0 && // starts top-left corner
dest.end_col == screen->cols && /* full width */ dest.end_col == screen->cols && // full width
screen->buffer == screen->buffers[0]) { /* not altscreen */ screen->buffer == screen->buffers[0]) { // not altscreen
VTermPos pos; VTermPos pos;
for(pos.row = 0; pos.row < src.start_row; pos.row++) { for(pos.row = 0; pos.row < src.start_row; pos.row++) {
for(pos.col = 0; pos.col < screen->cols; pos.col++) for(pos.col = 0; pos.col < screen->cols; pos.col++)
@ -252,7 +252,7 @@ static int moverect_user(VTermRect dest, VTermRect src, void *user)
if(screen->callbacks && screen->callbacks->moverect) { if(screen->callbacks && screen->callbacks->moverect) {
if(screen->damage_merge != VTERM_DAMAGE_SCROLL) if(screen->damage_merge != VTERM_DAMAGE_SCROLL)
/* Avoid an infinite loop */ // Avoid an infinite loop
vterm_screen_flush_damage(screen); vterm_screen_flush_damage(screen);
if((*screen->callbacks->moverect)(dest, src, screen->cbdata)) if((*screen->callbacks->moverect)(dest, src, screen->cbdata))
@ -488,11 +488,11 @@ static int resize(int new_rows, int new_cols, VTermPos *delta, void *user)
int first_blank_row; int first_blank_row;
if(!is_altscreen && new_rows < old_rows) { if(!is_altscreen && new_rows < old_rows) {
/* Fewer rows - determine if we're going to scroll at all, and if so, push // Fewer rows - determine if we're going to scroll at all, and if so, push
those lines to scrollback */ // those lines to scrollback
VTermPos pos = { 0, 0 }; VTermPos pos = { 0, 0 };
VTermPos cursor = screen->state->pos; VTermPos cursor = screen->state->pos;
/* Find the first blank row after the cursor. */ // Find the first blank row after the cursor.
for(pos.row = old_rows - 1; pos.row >= new_rows; pos.row--) for(pos.row = old_rows - 1; pos.row >= new_rows; pos.row--)
if(!vterm_screen_is_eol(screen, pos) || cursor.row == pos.row) if(!vterm_screen_is_eol(screen, pos) || cursor.row == pos.row)
break; break;
@ -702,10 +702,10 @@ static size_t _get_chars(const VTermScreen *screen, const int utf8, void *buffer
int i; int i;
if(cell->chars[0] == 0) if(cell->chars[0] == 0)
/* Erased cell, might need a space */ // Erased cell, might need a space
padding++; padding++;
else if(cell->chars[0] == (uint32_t)-1) else if(cell->chars[0] == (uint32_t)-1)
/* Gap behind a double-width char, do nothing */ // Gap behind a double-width char, do nothing
; ;
else { else {
while(padding) { while(padding) {
@ -912,7 +912,7 @@ int vterm_screen_get_attrs_extent(const VTermScreen *screen, VTermRect *extent,
ScreenCell *target = getcell(screen, pos.row, pos.col); ScreenCell *target = getcell(screen, pos.row, pos.col);
/* TODO: bounds check */ // TODO: bounds check
extent->start_row = pos.row; extent->start_row = pos.row;
extent->end_row = pos.row + 1; extent->end_row = pos.row + 1;

214
src/libvterm/src/state.c
View File

@ -101,7 +101,7 @@ static void scroll(VTermState *state, VTermRect rect, int downward, int rightwar
else if(rightward < -cols) else if(rightward < -cols)
rightward = -cols; rightward = -cols;
/* Update lineinfo if full line */ // Update lineinfo if full line
if(rect.start_col == 0 && rect.end_col == state->cols && rightward == 0) { if(rect.start_col == 0 && rect.end_col == state->cols && rightward == 0) {
int height = rect.end_row - rect.start_row - abs(downward); int height = rect.end_row - rect.start_row - abs(downward);
@ -221,7 +221,7 @@ static void set_lineinfo(VTermState *state, int row, int force, int dwl, int dhl
info.doublewidth = DWL_OFF; info.doublewidth = DWL_OFF;
else if(dwl == DWL_ON) else if(dwl == DWL_ON)
info.doublewidth = DWL_ON; info.doublewidth = DWL_ON;
/* else -1 to ignore */ // else -1 to ignore
if(dhl == DHL_OFF) if(dhl == DHL_OFF)
info.doubleheight = DHL_OFF; info.doubleheight = DHL_OFF;
@ -248,8 +248,8 @@ static int on_text(const char bytes[], size_t len, void *user)
VTermPos oldpos = state->pos; VTermPos oldpos = state->pos;
/* We'll have at most len codepoints, plus one from a previous incomplete // We'll have at most len codepoints, plus one from a previous incomplete
* sequence. */ // sequence.
codepoints = vterm_allocator_malloc(state->vt, (len + 1) * sizeof(uint32_t)); codepoints = vterm_allocator_malloc(state->vt, (len + 1) * sizeof(uint32_t));
encoding = encoding =
@ -317,7 +317,7 @@ static int on_text(const char bytes[], size_t len, void *user)
} }
for(; i < npoints; i++) { for(; i < npoints; i++) {
/* Try to find combining characters following this */ // Try to find combining characters following this
int glyph_starts = i; int glyph_starts = i;
int glyph_ends; int glyph_ends;
int width = 0; int width = 0;
@ -422,54 +422,54 @@ static int on_control(unsigned char control, void *user)
VTermPos oldpos = state->pos; VTermPos oldpos = state->pos;
switch(control) { switch(control) {
case 0x07: /* BEL - ECMA-48 8.3.3 */ case 0x07: // BEL - ECMA-48 8.3.3
if(state->callbacks && state->callbacks->bell) if(state->callbacks && state->callbacks->bell)
(*state->callbacks->bell)(state->cbdata); (*state->callbacks->bell)(state->cbdata);
break; break;
case 0x08: /* BS - ECMA-48 8.3.5 */ case 0x08: // BS - ECMA-48 8.3.5
if(state->pos.col > 0) if(state->pos.col > 0)
state->pos.col--; state->pos.col--;
break; break;
case 0x09: /* HT - ECMA-48 8.3.60 */ case 0x09: // HT - ECMA-48 8.3.60
tab(state, 1, +1); tab(state, 1, +1);
break; break;
case 0x0a: /* LF - ECMA-48 8.3.74 */ case 0x0a: // LF - ECMA-48 8.3.74
case 0x0b: /* VT */ case 0x0b: // VT
case 0x0c: /* FF */ case 0x0c: // FF
linefeed(state); linefeed(state);
if(state->mode.newline) if(state->mode.newline)
state->pos.col = 0; state->pos.col = 0;
break; break;
case 0x0d: /* CR - ECMA-48 8.3.15 */ case 0x0d: // CR - ECMA-48 8.3.15
state->pos.col = 0; state->pos.col = 0;
break; break;
case 0x0e: /* LS1 - ECMA-48 8.3.76 */ case 0x0e: // LS1 - ECMA-48 8.3.76
state->gl_set = 1; state->gl_set = 1;
break; break;
case 0x0f: /* LS0 - ECMA-48 8.3.75 */ case 0x0f: // LS0 - ECMA-48 8.3.75
state->gl_set = 0; state->gl_set = 0;
break; break;
case 0x84: /* IND - DEPRECATED but implemented for completeness */ case 0x84: // IND - DEPRECATED but implemented for completeness
linefeed(state); linefeed(state);
break; break;
case 0x85: /* NEL - ECMA-48 8.3.86 */ case 0x85: // NEL - ECMA-48 8.3.86
linefeed(state); linefeed(state);
state->pos.col = 0; state->pos.col = 0;
break; break;
case 0x88: /* HTS - ECMA-48 8.3.62 */ case 0x88: // HTS - ECMA-48 8.3.62
set_col_tabstop(state, state->pos.col); set_col_tabstop(state, state->pos.col);
break; break;
case 0x8d: /* RI - ECMA-48 8.3.104 */ case 0x8d: // RI - ECMA-48 8.3.104
if(state->pos.row == state->scrollregion_top) { if(state->pos.row == state->scrollregion_top) {
VTermRect rect; VTermRect rect;
rect.start_row = state->scrollregion_top; rect.start_row = state->scrollregion_top;
@ -483,11 +483,11 @@ static int on_control(unsigned char control, void *user)
state->pos.row--; state->pos.row--;
break; break;
case 0x8e: /* SS2 - ECMA-48 8.3.141 */ case 0x8e: // SS2 - ECMA-48 8.3.141
state->gsingle_set = 2; state->gsingle_set = 2;
break; break;
case 0x8f: /* SS3 - ECMA-48 8.3.142 */ case 0x8f: // SS3 - ECMA-48 8.3.142
state->gsingle_set = 3; state->gsingle_set = 3;
break; break;
@ -580,11 +580,11 @@ static int on_escape(const char *bytes, size_t len, void *user)
return 0; return 0;
switch(bytes[1]) { switch(bytes[1]) {
case 'F': /* S7C1T */ case 'F': // S7C1T
state->vt->mode.ctrl8bit = 0; state->vt->mode.ctrl8bit = 0;
break; break;
case 'G': /* S8C1T */ case 'G': // S8C1T
state->vt->mode.ctrl8bit = 1; state->vt->mode.ctrl8bit = 1;
break; break;
@ -598,31 +598,31 @@ static int on_escape(const char *bytes, size_t len, void *user)
return 0; return 0;
switch(bytes[1]) { switch(bytes[1]) {
case '3': /* DECDHL top */ case '3': // DECDHL top
if(state->mode.leftrightmargin) if(state->mode.leftrightmargin)
break; break;
set_lineinfo(state, state->pos.row, NO_FORCE, DWL_ON, DHL_TOP); set_lineinfo(state, state->pos.row, NO_FORCE, DWL_ON, DHL_TOP);
break; break;
case '4': /* DECDHL bottom */ case '4': // DECDHL bottom
if(state->mode.leftrightmargin) if(state->mode.leftrightmargin)
break; break;
set_lineinfo(state, state->pos.row, NO_FORCE, DWL_ON, DHL_BOTTOM); set_lineinfo(state, state->pos.row, NO_FORCE, DWL_ON, DHL_BOTTOM);
break; break;
case '5': /* DECSWL */ case '5': // DECSWL
if(state->mode.leftrightmargin) if(state->mode.leftrightmargin)
break; break;
set_lineinfo(state, state->pos.row, NO_FORCE, DWL_OFF, DHL_OFF); set_lineinfo(state, state->pos.row, NO_FORCE, DWL_OFF, DHL_OFF);
break; break;
case '6': /* DECDWL */ case '6': // DECDWL
if(state->mode.leftrightmargin) if(state->mode.leftrightmargin)
break; break;
set_lineinfo(state, state->pos.row, NO_FORCE, DWL_ON, DHL_OFF); set_lineinfo(state, state->pos.row, NO_FORCE, DWL_ON, DHL_OFF);
break; break;
case '8': /* DECALN */ case '8': // DECALN
{ {
VTermPos pos; VTermPos pos;
uint32_t E[] = { 'E', 0 }; uint32_t E[] = { 'E', 0 };
@ -637,7 +637,7 @@ static int on_escape(const char *bytes, size_t len, void *user)
} }
return 2; return 2;
case '(': case ')': case '*': case '+': /* SCS */ case '(': case ')': case '*': case '+': // SCS
if(len != 2) if(len != 2)
return 0; return 0;
@ -655,26 +655,26 @@ static int on_escape(const char *bytes, size_t len, void *user)
return 2; return 2;
case '7': /* DECSC */ case '7': // DECSC
savecursor(state, 1); savecursor(state, 1);
return 1; return 1;
case '8': /* DECRC */ case '8': // DECRC
savecursor(state, 0); savecursor(state, 0);
return 1; return 1;
case '<': /* Ignored by VT100. Used in VT52 mode to switch up to VT100 */ case '<': // Ignored by VT100. Used in VT52 mode to switch up to VT100
return 1; return 1;
case '=': /* DECKPAM */ case '=': // DECKPAM
state->mode.keypad = 1; state->mode.keypad = 1;
return 1; return 1;
case '>': /* DECKPNM */ case '>': // DECKPNM
state->mode.keypad = 0; state->mode.keypad = 0;
return 1; return 1;
case 'c': /* RIS - ECMA-48 8.3.105 */ case 'c': // RIS - ECMA-48 8.3.105
{ {
VTermPos oldpos = state->pos; VTermPos oldpos = state->pos;
vterm_state_reset(state, 1); vterm_state_reset(state, 1);
@ -683,23 +683,23 @@ static int on_escape(const char *bytes, size_t len, void *user)
return 1; return 1;
} }
case 'n': /* LS2 - ECMA-48 8.3.78 */ case 'n': // LS2 - ECMA-48 8.3.78
state->gl_set = 2; state->gl_set = 2;
return 1; return 1;
case 'o': /* LS3 - ECMA-48 8.3.80 */ case 'o': // LS3 - ECMA-48 8.3.80
state->gl_set = 3; state->gl_set = 3;
return 1; return 1;
case '~': /* LS1R - ECMA-48 8.3.77 */ case '~': // LS1R - ECMA-48 8.3.77
state->gr_set = 1; state->gr_set = 1;
return 1; return 1;
case '}': /* LS2R - ECMA-48 8.3.79 */ case '}': // LS2R - ECMA-48 8.3.79
state->gr_set = 2; state->gr_set = 2;
return 1; return 1;
case '|': /* LS3R - ECMA-48 8.3.81 */ case '|': // LS3R - ECMA-48 8.3.81
state->gr_set = 3; state->gr_set = 3;
return 1; return 1;
@ -711,11 +711,11 @@ static int on_escape(const char *bytes, size_t len, void *user)
static void set_mode(VTermState *state, int num, int val) static void set_mode(VTermState *state, int num, int val)
{ {
switch(num) { switch(num) {
case 4: /* IRM - ECMA-48 7.2.10 */ case 4: // IRM - ECMA-48 7.2.10
state->mode.insert = val; state->mode.insert = val;
break; break;
case 20: /* LNM - ANSI X3.4-1977 */ case 20: // LNM - ANSI X3.4-1977
state->mode.newline = val; state->mode.newline = val;
break; break;
@ -732,11 +732,11 @@ static void set_dec_mode(VTermState *state, int num, int val)
state->mode.cursor = val; state->mode.cursor = val;
break; break;
case 5: /* DECSCNM - screen mode */ case 5: // DECSCNM - screen mode
settermprop_bool(state, VTERM_PROP_REVERSE, val); settermprop_bool(state, VTERM_PROP_REVERSE, val);
break; break;
case 6: /* DECOM - origin mode */ case 6: // DECOM - origin mode
{ {
VTermPos oldpos = state->pos; VTermPos oldpos = state->pos;
state->mode.origin = val; state->mode.origin = val;
@ -758,13 +758,13 @@ static void set_dec_mode(VTermState *state, int num, int val)
settermprop_bool(state, VTERM_PROP_CURSORVISIBLE, val); settermprop_bool(state, VTERM_PROP_CURSORVISIBLE, val);
break; break;
case 69: /* DECVSSM - vertical split screen mode */ case 69: // DECVSSM - vertical split screen mode
/* DECLRMM - left/right margin mode */ // DECLRMM - left/right margin mode
state->mode.leftrightmargin = val; state->mode.leftrightmargin = val;
if(val) { if(val) {
int row; int row;
/* Setting DECVSSM must clear doublewidth/doubleheight state of every line */ // Setting DECVSSM must clear doublewidth/doubleheight state of every line
for(row = 0; row < state->rows; row++) for(row = 0; row < state->rows; row++)
set_lineinfo(state, row, FORCE, DWL_OFF, DHL_OFF); set_lineinfo(state, row, FORCE, DWL_OFF, DHL_OFF);
} }
@ -911,7 +911,7 @@ static int on_csi(const char *leader, const long args[], int argcount, const cha
int selective; int selective;
if(leader && leader[0]) { if(leader && leader[0]) {
if(leader[1]) /* longer than 1 char */ if(leader[1]) // longer than 1 char
return 0; return 0;
switch(leader[0]) { switch(leader[0]) {
@ -925,7 +925,7 @@ static int on_csi(const char *leader, const long args[], int argcount, const cha
} }
if(intermed && intermed[0]) { if(intermed && intermed[0]) {
if(intermed[1]) /* longer than 1 char */ if(intermed[1]) // longer than 1 char
return 0; return 0;
switch(intermed[0]) { switch(intermed[0]) {
@ -949,7 +949,7 @@ static int on_csi(const char *leader, const long args[], int argcount, const cha
#define INTERMED(i,b) ((i << 16) | b) #define INTERMED(i,b) ((i << 16) | b)
switch(intermed_byte << 16 | leader_byte << 8 | command) { switch(intermed_byte << 16 | leader_byte << 8 | command) {
case 0x40: /* ICH - ECMA-48 8.3.64 */ case 0x40: // ICH - ECMA-48 8.3.64
count = CSI_ARG_COUNT(args[0]); count = CSI_ARG_COUNT(args[0]);
if(!is_cursor_in_scrollregion(state)) if(!is_cursor_in_scrollregion(state))
@ -967,54 +967,54 @@ static int on_csi(const char *leader, const long args[], int argcount, const cha
break; break;
case 0x41: /* CUU - ECMA-48 8.3.22 */ case 0x41: // CUU - ECMA-48 8.3.22
count = CSI_ARG_COUNT(args[0]); count = CSI_ARG_COUNT(args[0]);
state->pos.row -= count; state->pos.row -= count;
state->at_phantom = 0; state->at_phantom = 0;
break; break;
case 0x42: /* CUD - ECMA-48 8.3.19 */ case 0x42: // CUD - ECMA-48 8.3.19
count = CSI_ARG_COUNT(args[0]); count = CSI_ARG_COUNT(args[0]);
state->pos.row += count; state->pos.row += count;
state->at_phantom = 0; state->at_phantom = 0;
break; break;
case 0x43: /* CUF - ECMA-48 8.3.20 */ case 0x43: // CUF - ECMA-48 8.3.20
count = CSI_ARG_COUNT(args[0]); count = CSI_ARG_COUNT(args[0]);
state->pos.col += count; state->pos.col += count;
state->at_phantom = 0; state->at_phantom = 0;
break; break;
case 0x44: /* CUB - ECMA-48 8.3.18 */ case 0x44: // CUB - ECMA-48 8.3.18
count = CSI_ARG_COUNT(args[0]); count = CSI_ARG_COUNT(args[0]);
state->pos.col -= count; state->pos.col -= count;
state->at_phantom = 0; state->at_phantom = 0;
break; break;
case 0x45: /* CNL - ECMA-48 8.3.12 */ case 0x45: // CNL - ECMA-48 8.3.12
count = CSI_ARG_COUNT(args[0]); count = CSI_ARG_COUNT(args[0]);
state->pos.col = 0; state->pos.col = 0;
state->pos.row += count; state->pos.row += count;
state->at_phantom = 0; state->at_phantom = 0;
break; break;
case 0x46: /* CPL - ECMA-48 8.3.13 */ case 0x46: // CPL - ECMA-48 8.3.13
count = CSI_ARG_COUNT(args[0]); count = CSI_ARG_COUNT(args[0]);
state->pos.col = 0; state->pos.col = 0;
state->pos.row -= count; state->pos.row -= count;
state->at_phantom = 0; state->at_phantom = 0;
break; break;
case 0x47: /* CHA - ECMA-48 8.3.9 */ case 0x47: // CHA - ECMA-48 8.3.9
val = CSI_ARG_OR(args[0], 1); val = CSI_ARG_OR(args[0], 1);
state->pos.col = val-1; state->pos.col = val-1;
state->at_phantom = 0; state->at_phantom = 0;
break; break;
case 0x48: /* CUP - ECMA-48 8.3.21 */ case 0x48: // CUP - ECMA-48 8.3.21
row = CSI_ARG_OR(args[0], 1); row = CSI_ARG_OR(args[0], 1);
col = argcount < 2 || CSI_ARG_IS_MISSING(args[1]) ? 1 : CSI_ARG(args[1]); col = argcount < 2 || CSI_ARG_IS_MISSING(args[1]) ? 1 : CSI_ARG(args[1]);
/* zero-based */ // zero-based
state->pos.row = row-1; state->pos.row = row-1;
state->pos.col = col-1; state->pos.col = col-1;
if(state->mode.origin) { if(state->mode.origin) {
@ -1024,13 +1024,13 @@ static int on_csi(const char *leader, const long args[], int argcount, const cha
state->at_phantom = 0; state->at_phantom = 0;
break; break;
case 0x49: /* CHT - ECMA-48 8.3.10 */ case 0x49: // CHT - ECMA-48 8.3.10
count = CSI_ARG_COUNT(args[0]); count = CSI_ARG_COUNT(args[0]);
tab(state, count, +1); tab(state, count, +1);
break; break;
case 0x4a: /* ED - ECMA-48 8.3.39 */ case 0x4a: // ED - ECMA-48 8.3.39
case LEADER('?', 0x4a): /* DECSED - Selective Erase in Display */ case LEADER('?', 0x4a): // DECSED - Selective Erase in Display
selective = (leader_byte == '?'); selective = (leader_byte == '?');
switch(CSI_ARG(args[0])) { switch(CSI_ARG(args[0])) {
case CSI_ARG_MISSING: case CSI_ARG_MISSING:
@ -1072,8 +1072,8 @@ static int on_csi(const char *leader, const long args[], int argcount, const cha
} }
break; break;
case 0x4b: /* EL - ECMA-48 8.3.41 */ case 0x4b: // EL - ECMA-48 8.3.41
case LEADER('?', 0x4b): /* DECSEL - Selective Erase in Line */ case LEADER('?', 0x4b): // DECSEL - Selective Erase in Line
selective = (leader_byte == '?'); selective = (leader_byte == '?');
rect.start_row = state->pos.row; rect.start_row = state->pos.row;
rect.end_row = state->pos.row + 1; rect.end_row = state->pos.row + 1;
@ -1095,7 +1095,7 @@ static int on_csi(const char *leader, const long args[], int argcount, const cha
break; break;
case 0x4c: /* IL - ECMA-48 8.3.67 */ case 0x4c: // IL - ECMA-48 8.3.67
count = CSI_ARG_COUNT(args[0]); count = CSI_ARG_COUNT(args[0]);
if(!is_cursor_in_scrollregion(state)) if(!is_cursor_in_scrollregion(state))
@ -1110,7 +1110,7 @@ static int on_csi(const char *leader, const long args[], int argcount, const cha
break; break;
case 0x4d: /* DL - ECMA-48 8.3.32 */ case 0x4d: // DL - ECMA-48 8.3.32
count = CSI_ARG_COUNT(args[0]); count = CSI_ARG_COUNT(args[0]);
if(!is_cursor_in_scrollregion(state)) if(!is_cursor_in_scrollregion(state))
@ -1125,7 +1125,7 @@ static int on_csi(const char *leader, const long args[], int argcount, const cha
break; break;
case 0x50: /* DCH - ECMA-48 8.3.26 */ case 0x50: // DCH - ECMA-48 8.3.26
count = CSI_ARG_COUNT(args[0]); count = CSI_ARG_COUNT(args[0]);
if(!is_cursor_in_scrollregion(state)) if(!is_cursor_in_scrollregion(state))
@ -1143,7 +1143,7 @@ static int on_csi(const char *leader, const long args[], int argcount, const cha
break; break;
case 0x53: /* SU - ECMA-48 8.3.147 */ case 0x53: // SU - ECMA-48 8.3.147
count = CSI_ARG_COUNT(args[0]); count = CSI_ARG_COUNT(args[0]);
rect.start_row = state->scrollregion_top; rect.start_row = state->scrollregion_top;
@ -1155,7 +1155,7 @@ static int on_csi(const char *leader, const long args[], int argcount, const cha
break; break;
case 0x54: /* SD - ECMA-48 8.3.113 */ case 0x54: // SD - ECMA-48 8.3.113
count = CSI_ARG_COUNT(args[0]); count = CSI_ARG_COUNT(args[0]);
rect.start_row = state->scrollregion_top; rect.start_row = state->scrollregion_top;
@ -1167,7 +1167,7 @@ static int on_csi(const char *leader, const long args[], int argcount, const cha
break; break;
case 0x58: /* ECH - ECMA-48 8.3.38 */ case 0x58: // ECH - ECMA-48 8.3.38
count = CSI_ARG_COUNT(args[0]); count = CSI_ARG_COUNT(args[0]);
rect.start_row = state->pos.row; rect.start_row = state->pos.row;
@ -1179,36 +1179,36 @@ static int on_csi(const char *leader, const long args[], int argcount, const cha
erase(state, rect, 0); erase(state, rect, 0);
break; break;
case 0x5a: /* CBT - ECMA-48 8.3.7 */ case 0x5a: // CBT - ECMA-48 8.3.7
count = CSI_ARG_COUNT(args[0]); count = CSI_ARG_COUNT(args[0]);
tab(state, count, -1); tab(state, count, -1);
break; break;
case 0x60: /* HPA - ECMA-48 8.3.57 */ case 0x60: // HPA - ECMA-48 8.3.57
col = CSI_ARG_OR(args[0], 1); col = CSI_ARG_OR(args[0], 1);
state->pos.col = col-1; state->pos.col = col-1;
state->at_phantom = 0; state->at_phantom = 0;
break; break;
case 0x61: /* HPR - ECMA-48 8.3.59 */ case 0x61: // HPR - ECMA-48 8.3.59
count = CSI_ARG_COUNT(args[0]); count = CSI_ARG_COUNT(args[0]);
state->pos.col += count; state->pos.col += count;
state->at_phantom = 0; state->at_phantom = 0;
break; break;
case 0x63: /* DA - ECMA-48 8.3.24 */ case 0x63: // DA - ECMA-48 8.3.24
val = CSI_ARG_OR(args[0], 0); val = CSI_ARG_OR(args[0], 0);
if(val == 0) if(val == 0)
/* DEC VT100 response */ // DEC VT100 response
vterm_push_output_sprintf_ctrl(state->vt, C1_CSI, "?1;2c"); vterm_push_output_sprintf_ctrl(state->vt, C1_CSI, "?1;2c");
break; break;
case LEADER('>', 0x63): /* DEC secondary Device Attributes */ case LEADER('>', 0x63): // DEC secondary Device Attributes
/* This returns xterm version number 100. */ // This returns xterm version number 100.
vterm_push_output_sprintf_ctrl(state->vt, C1_CSI, ">%d;%d;%dc", 0, 100, 0); vterm_push_output_sprintf_ctrl(state->vt, C1_CSI, ">%d;%d;%dc", 0, 100, 0);
break; break;
case 0x64: /* VPA - ECMA-48 8.3.158 */ case 0x64: // VPA - ECMA-48 8.3.158
row = CSI_ARG_OR(args[0], 1); row = CSI_ARG_OR(args[0], 1);
state->pos.row = row-1; state->pos.row = row-1;
if(state->mode.origin) if(state->mode.origin)
@ -1216,16 +1216,16 @@ static int on_csi(const char *leader, const long args[], int argcount, const cha
state->at_phantom = 0; state->at_phantom = 0;
break; break;
case 0x65: /* VPR - ECMA-48 8.3.160 */ case 0x65: // VPR - ECMA-48 8.3.160
count = CSI_ARG_COUNT(args[0]); count = CSI_ARG_COUNT(args[0]);
state->pos.row += count; state->pos.row += count;
state->at_phantom = 0; state->at_phantom = 0;
break; break;
case 0x66: /* HVP - ECMA-48 8.3.63 */ case 0x66: // HVP - ECMA-48 8.3.63
row = CSI_ARG_OR(args[0], 1); row = CSI_ARG_OR(args[0], 1);
col = argcount < 2 || CSI_ARG_IS_MISSING(args[1]) ? 1 : CSI_ARG(args[1]); col = argcount < 2 || CSI_ARG_IS_MISSING(args[1]) ? 1 : CSI_ARG(args[1]);
/* zero-based */ // zero-based
state->pos.row = row-1; state->pos.row = row-1;
state->pos.col = col-1; state->pos.col = col-1;
if(state->mode.origin) { if(state->mode.origin) {
@ -1235,7 +1235,7 @@ static int on_csi(const char *leader, const long args[], int argcount, const cha
state->at_phantom = 0; state->at_phantom = 0;
break; break;
case 0x67: /* TBC - ECMA-48 8.3.154 */ case 0x67: // TBC - ECMA-48 8.3.154
val = CSI_ARG_OR(args[0], 0); val = CSI_ARG_OR(args[0], 0);
switch(val) { switch(val) {
@ -1257,44 +1257,44 @@ static int on_csi(const char *leader, const long args[], int argcount, const cha
} }
break; break;
case 0x68: /* SM - ECMA-48 8.3.125 */ case 0x68: // SM - ECMA-48 8.3.125
if(!CSI_ARG_IS_MISSING(args[0])) if(!CSI_ARG_IS_MISSING(args[0]))
set_mode(state, CSI_ARG(args[0]), 1); set_mode(state, CSI_ARG(args[0]), 1);
break; break;
case LEADER('?', 0x68): /* DEC private mode set */ case LEADER('?', 0x68): // DEC private mode set
if(!CSI_ARG_IS_MISSING(args[0])) if(!CSI_ARG_IS_MISSING(args[0]))
set_dec_mode(state, CSI_ARG(args[0]), 1); set_dec_mode(state, CSI_ARG(args[0]), 1);
break; break;
case 0x6a: /* HPB - ECMA-48 8.3.58 */ case 0x6a: // HPB - ECMA-48 8.3.58
count = CSI_ARG_COUNT(args[0]); count = CSI_ARG_COUNT(args[0]);
state->pos.col -= count; state->pos.col -= count;
state->at_phantom = 0; state->at_phantom = 0;
break; break;
case 0x6b: /* VPB - ECMA-48 8.3.159 */ case 0x6b: // VPB - ECMA-48 8.3.159
count = CSI_ARG_COUNT(args[0]); count = CSI_ARG_COUNT(args[0]);
state->pos.row -= count; state->pos.row -= count;
state->at_phantom = 0; state->at_phantom = 0;
break; break;
case 0x6c: /* RM - ECMA-48 8.3.106 */ case 0x6c: // RM - ECMA-48 8.3.106
if(!CSI_ARG_IS_MISSING(args[0])) if(!CSI_ARG_IS_MISSING(args[0]))
set_mode(state, CSI_ARG(args[0]), 0); set_mode(state, CSI_ARG(args[0]), 0);
break; break;
case LEADER('?', 0x6c): /* DEC private mode reset */ case LEADER('?', 0x6c): // DEC private mode reset
if(!CSI_ARG_IS_MISSING(args[0])) if(!CSI_ARG_IS_MISSING(args[0]))
set_dec_mode(state, CSI_ARG(args[0]), 0); set_dec_mode(state, CSI_ARG(args[0]), 0);
break; break;
case 0x6d: /* SGR - ECMA-48 8.3.117 */ case 0x6d: // SGR - ECMA-48 8.3.117
vterm_state_setpen(state, args, argcount); vterm_state_setpen(state, args, argcount);
break; break;
case 0x6e: /* DSR - ECMA-48 8.3.35 */ case 0x6e: // DSR - ECMA-48 8.3.35
case LEADER('?', 0x6e): /* DECDSR */ case LEADER('?', 0x6e): // DECDSR
val = CSI_ARG_OR(args[0], 0); val = CSI_ARG_OR(args[0], 0);
{ {
@ -1302,12 +1302,12 @@ static int on_csi(const char *leader, const long args[], int argcount, const cha
switch(val) { switch(val) {
case 0: case 1: case 2: case 3: case 4: case 0: case 1: case 2: case 3: case 4:
/* ignore - these are replies */ // ignore - these are replies
break; break;
case 5: case 5:
vterm_push_output_sprintf_ctrl(state->vt, C1_CSI, "%s0n", qmark); vterm_push_output_sprintf_ctrl(state->vt, C1_CSI, "%s0n", qmark);
break; break;
case 6: /* CPR - cursor position report */ case 6: // CPR - cursor position report
vterm_push_output_sprintf_ctrl(state->vt, C1_CSI, "%s%d;%dR", qmark, state->pos.row + 1, state->pos.col + 1); vterm_push_output_sprintf_ctrl(state->vt, C1_CSI, "%s%d;%dR", qmark, state->pos.row + 1, state->pos.col + 1);
break; break;
} }
@ -1315,7 +1315,7 @@ static int on_csi(const char *leader, const long args[], int argcount, const cha
break; break;
case LEADER('!', 0x70): /* DECSTR - DEC soft terminal reset */ case LEADER('!', 0x70): // DECSTR - DEC soft terminal reset
vterm_state_reset(state, 0); vterm_state_reset(state, 0);
break; break;
@ -1323,7 +1323,7 @@ static int on_csi(const char *leader, const long args[], int argcount, const cha
request_dec_mode(state, CSI_ARG(args[0])); request_dec_mode(state, CSI_ARG(args[0]));
break; break;
case INTERMED(' ', 0x71): /* DECSCUSR - DEC set cursor shape */ case INTERMED(' ', 0x71): // DECSCUSR - DEC set cursor shape
val = CSI_ARG_OR(args[0], 1); val = CSI_ARG_OR(args[0], 1);
switch(val) { switch(val) {
@ -1355,7 +1355,7 @@ static int on_csi(const char *leader, const long args[], int argcount, const cha
break; break;
case INTERMED('"', 0x71): /* DECSCA - DEC select character protection attribute */ case INTERMED('"', 0x71): // DECSCA - DEC select character protection attribute
val = CSI_ARG_OR(args[0], 0); val = CSI_ARG_OR(args[0], 0);
switch(val) { switch(val) {
@ -1369,7 +1369,7 @@ static int on_csi(const char *leader, const long args[], int argcount, const cha
break; break;
case 0x72: /* DECSTBM - DEC custom */ case 0x72: // DECSTBM - DEC custom
state->scrollregion_top = CSI_ARG_OR(args[0], 1) - 1; state->scrollregion_top = CSI_ARG_OR(args[0], 1) - 1;
state->scrollregion_bottom = argcount < 2 || CSI_ARG_IS_MISSING(args[1]) ? -1 : CSI_ARG(args[1]); state->scrollregion_bottom = argcount < 2 || CSI_ARG_IS_MISSING(args[1]) ? -1 : CSI_ARG(args[1]);
LBOUND(state->scrollregion_top, 0); LBOUND(state->scrollregion_top, 0);
@ -1381,15 +1381,15 @@ static int on_csi(const char *leader, const long args[], int argcount, const cha
UBOUND(state->scrollregion_bottom, state->rows); UBOUND(state->scrollregion_bottom, state->rows);
if(SCROLLREGION_BOTTOM(state) <= state->scrollregion_top) { if(SCROLLREGION_BOTTOM(state) <= state->scrollregion_top) {
/* Invalid */ // Invalid
state->scrollregion_top = 0; state->scrollregion_top = 0;
state->scrollregion_bottom = -1; state->scrollregion_bottom = -1;
} }
break; break;
case 0x73: /* DECSLRM - DEC custom */ case 0x73: // DECSLRM - DEC custom
/* Always allow setting these margins, just they won't take effect without DECVSSM */ // Always allow setting these margins, just they won't take effect without DECVSSM
state->scrollregion_left = CSI_ARG_OR(args[0], 1) - 1; state->scrollregion_left = CSI_ARG_OR(args[0], 1) - 1;
state->scrollregion_right = argcount < 2 || CSI_ARG_IS_MISSING(args[1]) ? -1 : CSI_ARG(args[1]); state->scrollregion_right = argcount < 2 || CSI_ARG_IS_MISSING(args[1]) ? -1 : CSI_ARG(args[1]);
LBOUND(state->scrollregion_left, 0); LBOUND(state->scrollregion_left, 0);
@ -1402,7 +1402,7 @@ static int on_csi(const char *leader, const long args[], int argcount, const cha
if(state->scrollregion_right > -1 && if(state->scrollregion_right > -1 &&
state->scrollregion_right <= state->scrollregion_left) { state->scrollregion_right <= state->scrollregion_left) {
/* Invalid */ // Invalid
state->scrollregion_left = 0; state->scrollregion_left = 0;
state->scrollregion_right = -1; state->scrollregion_right = -1;
} }
@ -1417,7 +1417,7 @@ static int on_csi(const char *leader, const long args[], int argcount, const cha
} }
break; break;
case INTERMED('\'', 0x7D): /* DECIC */ case INTERMED('\'', 0x7D): // DECIC
count = CSI_ARG_COUNT(args[0]); count = CSI_ARG_COUNT(args[0]);
if(!is_cursor_in_scrollregion(state)) if(!is_cursor_in_scrollregion(state))
@ -1432,7 +1432,7 @@ static int on_csi(const char *leader, const long args[], int argcount, const cha
break; break;
case INTERMED('\'', 0x7E): /* DECDC */ case INTERMED('\'', 0x7E): // DECDC
count = CSI_ARG_COUNT(args[0]); count = CSI_ARG_COUNT(args[0]);
if(!is_cursor_in_scrollregion(state)) if(!is_cursor_in_scrollregion(state))
@ -1545,7 +1545,7 @@ static void request_status_string(VTermState *state, const char *command, size_t
{ {
if(cmdlen == 1) if(cmdlen == 1)
switch(command[0]) { switch(command[0]) {
case 'm': /* Query SGR */ case 'm': // Query SGR
{ {
long args[20]; long args[20];
int argc = vterm_state_getpen(state, args, sizeof(args)/sizeof(args[0])); int argc = vterm_state_getpen(state, args, sizeof(args)/sizeof(args[0]));
@ -1561,10 +1561,10 @@ static void request_status_string(VTermState *state, const char *command, size_t
vterm_push_output_sprintf_ctrl(state->vt, C1_ST, ""); vterm_push_output_sprintf_ctrl(state->vt, C1_ST, "");
} }
return; return;
case 'r': /* Query DECSTBM */ case 'r': // Query DECSTBM
vterm_push_output_sprintf_dcs(state->vt, "1$r%d;%dr", state->scrollregion_top+1, SCROLLREGION_BOTTOM(state)); vterm_push_output_sprintf_dcs(state->vt, "1$r%d;%dr", state->scrollregion_top+1, SCROLLREGION_BOTTOM(state));
return; return;
case 's': /* Query DECSLRM */ case 's': // Query DECSLRM
vterm_push_output_sprintf_dcs(state->vt, "1$r%d;%ds", SCROLLREGION_LEFT(state)+1, SCROLLREGION_RIGHT(state)); vterm_push_output_sprintf_dcs(state->vt, "1$r%d;%ds", SCROLLREGION_LEFT(state)+1, SCROLLREGION_RIGHT(state));
return; return;
} }
@ -1779,7 +1779,7 @@ void vterm_state_reset(VTermState *state, int hard)
state->protected_cell = 0; state->protected_cell = 0;
/* Initialise the props */ // Initialise the props
settermprop_bool(state, VTERM_PROP_CURSORVISIBLE, 1); settermprop_bool(state, VTERM_PROP_CURSORVISIBLE, 1);
settermprop_bool(state, VTERM_PROP_CURSORBLINK, 1); settermprop_bool(state, VTERM_PROP_CURSORBLINK, 1);
settermprop_int (state, VTERM_PROP_CURSORSHAPE, VTERM_PROP_CURSORSHAPE_BLOCK); settermprop_int (state, VTERM_PROP_CURSORSHAPE, VTERM_PROP_CURSORSHAPE_BLOCK);
@ -1859,7 +1859,7 @@ int vterm_state_set_termprop(VTermState *state, VTermProp prop, VTermValue *val)
case VTERM_PROP_TITLE: case VTERM_PROP_TITLE:
case VTERM_PROP_ICONNAME: case VTERM_PROP_ICONNAME:
case VTERM_PROP_CURSORCOLOR: case VTERM_PROP_CURSORCOLOR:
/* we don't store these, just transparently pass through */ // we don't store these, just transparently pass through
return 1; return 1;
case VTERM_PROP_CURSORVISIBLE: case VTERM_PROP_CURSORVISIBLE:
state->mode.cursor_visible = val->boolean; state->mode.cursor_visible = val->boolean;

16
src/libvterm/src/unicode.c
View File

@ -1,11 +1,10 @@
#include "vterm_internal.h" #include "vterm_internal.h"
/* ### The following from http://www.cl.cam.ac.uk/~mgk25/ucs/wcwidth.c // ### The following from http://www.cl.cam.ac.uk/~mgk25/ucs/wcwidth.c
* With modifications: // With modifications:
* made functions static // made functions static
* moved 'combining' table to file scope, so other functions can see it // moved 'combining' table to file scope, so other functions can see it
* ################################################################### // ###################################################################
*/
/* /*
* This is an implementation of wcwidth() and wcswidth() (defined in * This is an implementation of wcwidth() and wcswidth() (defined in
@ -336,9 +335,8 @@ vterm_is_combining(uint32_t codepoint)
} }
#endif #endif
// ################################
/* ################################ // ### The rest added by Paul Evans
* ### The rest added by Paul Evans */
INTERNAL int vterm_unicode_width(uint32_t codepoint) INTERNAL int vterm_unicode_width(uint32_t codepoint)
{ {

2
src/libvterm/src/utf8.h
View File

@ -24,7 +24,7 @@ INLINE int fill_utf8(long codepoint, char *str)
{ {
int nbytes = utf8_seqlen(codepoint); int nbytes = utf8_seqlen(codepoint);
/* This is easier done backwards */ // This is easier done backwards
int b = nbytes; int b = nbytes;
while(b > 1) { while(b > 1) {
b--; b--;

4
src/libvterm/src/vterm.c
View File

@ -27,8 +27,8 @@ static void default_free(void *ptr, void *allocdata UNUSED)
} }
static VTermAllocatorFunctions default_allocator = { static VTermAllocatorFunctions default_allocator = {
&default_malloc, /* malloc */ &default_malloc, // malloc
&default_free /* free */ &default_free // free
}; };
VTerm *vterm_new(int rows, int cols) VTerm *vterm_new(int rows, int cols)

14
src/libvterm/src/vterm_internal.h
View File

@ -37,7 +37,7 @@ typedef struct VTermEncoding VTermEncoding;
typedef struct { typedef struct {
VTermEncoding *enc; VTermEncoding *enc;
/* This size should be increased if required by other stateful encodings */ // This size should be increased if required by other stateful encodings
char data[4*sizeof(uint32_t)]; char data[4*sizeof(uint32_t)];
} VTermEncodingInstance; } VTermEncodingInstance;
@ -105,9 +105,9 @@ struct VTermState
/* Last glyph output, for Unicode recombining purposes */ /* Last glyph output, for Unicode recombining purposes */
uint32_t *combine_chars; uint32_t *combine_chars;
size_t combine_chars_size; /* Number of ELEMENTS in the above */ size_t combine_chars_size; // Number of ELEMENTS in the above
int combine_width; /* The width of the glyph above */ int combine_width; // The width of the glyph above
VTermPos combine_pos; /* Position before movement */ VTermPos combine_pos; // Position before movement
struct { struct {
unsigned int keypad:1; unsigned int keypad:1;
@ -133,7 +133,7 @@ struct VTermState
VTermColor default_fg; VTermColor default_fg;
VTermColor default_bg; VTermColor default_bg;
VTermColor colors[16]; /* Store the 8 ANSI and the 8 ANSI high-brights only */ VTermColor colors[16]; // Store the 8 ANSI and the 8 ANSI high-brights only
int fg_index; int fg_index;
int bg_index; int bg_index;
@ -183,7 +183,7 @@ struct VTerm
ESC, ESC,
/* below here are the "string states" */ /* below here are the "string states" */
STRING, STRING,
ESC_IN_STRING ESC_IN_STRING,
} state; } state;
int intermedlen; int intermedlen;
@ -248,7 +248,7 @@ enum {
C1_DCS = 0x90, C1_DCS = 0x90,
C1_CSI = 0x9b, C1_CSI = 0x9b,
C1_ST = 0x9c, C1_ST = 0x9c,
C1_OSC = 0x9d C1_OSC = 0x9d,
}; };
void vterm_state_push_output_sprintf_CSI(VTermState *vts, const char *format, ...); void vterm_state_push_output_sprintf_CSI(VTermState *vts, const char *format, ...);

2
src/version.c
View File

@ -761,6 +761,8 @@ static char *(features[]) =
static int included_patches[] = static int included_patches[] =
{ /* Add new patch number below this line */ { /* Add new patch number below this line */
/**/
1757,
/**/ /**/
1756, 1756,
/**/ /**/