cismonx
/
ctlseqs
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Update sixdraw and tcsgrep.

This commit is contained in:
CismonX 2021-01-06 21:31:25 +08:00
parent c20ca12750
commit decdf5738f
Signed by: cismonx
GPG Key ID: 3094873E29A482FB
2 changed files with 210 additions and 208 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

90
examples/sixdraw.c
View File

@ -38,14 +38,14 @@
#include <ctlseqs.h> #include <ctlseqs.h>
#ifndef SIXDRAW_DEFAULT_TIMEOUT_MILLIS #ifndef DEFAULT_TIMEOUT_MILLIS
# define SIXDRAW_DEFAULT_TIMEOUT_MILLIS 500 # define DEFAULT_TIMEOUT_MILLIS 500
#endif // !SIXDRAW_DEFAULT_TIMEOUT_MILLIS #endif // !DEFAULT_TIMEOUT_MILLIS
#define SIXDRAW_DECRQM_SET 1 #define DECRQM_SET 1
#define SIXDRAW_DECRQM_RST 2 #define DECRQM_RST 2
#define SIXDRAW_DECTCEM 25u #define DECTCEM 25u
#define SIXDRAW_ALT_SCRBUF 1049u #define ALT_SCRBUF 1049u
struct sixdraw_ctx { struct sixdraw_ctx {
struct termios termios; struct termios termios;
@ -66,7 +66,7 @@ struct sixdraw_ctx {
}; };
static inline void static inline void
sixdraw_print_error(struct sixdraw_ctx const *ctx, char const *format, ...) print_error(struct sixdraw_ctx const *ctx, char const *format, ...)
{ {
char msg[1024]; char msg[1024];
va_list args; va_list args;
@ -77,7 +77,7 @@ sixdraw_print_error(struct sixdraw_ctx const *ctx, char const *format, ...)
} }
static inline void static inline void
sixdraw_clear_signal(int signum) clear_signal(int signum)
{ {
sigset_t sigset; sigset_t sigset;
sigemptyset(&sigset); sigemptyset(&sigset);
@ -86,31 +86,31 @@ sixdraw_clear_signal(int signum)
} }
static bool static bool
sixdraw_handle_signals(struct sixdraw_ctx *ctx) handle_signals(struct sixdraw_ctx *ctx)
{ {
sigset_t sigset; sigset_t sigset;
sigpending(&sigset); sigpending(&sigset);
if (!sigismember(&sigset, SIGWINCH)) { if (!sigismember(&sigset, SIGWINCH)) {
return false; return false;
} }
sixdraw_clear_signal(SIGWINCH); clear_signal(SIGWINCH);
return true; return true;
} }
static void static void
sixdraw_terminate(struct sixdraw_ctx *ctx) terminate(struct sixdraw_ctx *ctx)
{ {
ctlseqs_matcher_free(ctx->matcher); ctlseqs_matcher_free(ctx->matcher);
ctlseqs_reader_free(ctx->reader); ctlseqs_reader_free(ctx->reader);
// Restore cursor status. // Restore cursor status.
if (ctx->show_cursor) { if (ctx->show_cursor) {
dprintf(ctx->out_fd, CTLSEQS_DECSET("%u"), SIXDRAW_DECTCEM); dprintf(ctx->out_fd, CTLSEQS_DECSET("%u"), DECTCEM);
} }
// Restore normal screen buffer. // Restore normal screen buffer.
if (ctx->normal_scrbuf) { if (ctx->normal_scrbuf) {
dprintf(ctx->out_fd, CTLSEQS_DECRST("%u"), SIXDRAW_ALT_SCRBUF); dprintf(ctx->out_fd, CTLSEQS_DECRST("%u"), ALT_SCRBUF);
} }
// Restore original terminal modes. // Restore original terminal modes.
@ -120,15 +120,15 @@ sixdraw_terminate(struct sixdraw_ctx *ctx)
} }
static bool static bool
sixdraw_get_winsize(struct sixdraw_ctx *ctx) get_winsize(struct sixdraw_ctx *ctx)
{ {
struct winsize ws = { 0 }; struct winsize ws = { 0 };
if (ioctl(ctx->in_fd, TIOCGWINSZ, &ws) != 0) { if (ioctl(ctx->in_fd, TIOCGWINSZ, &ws) != 0) {
sixdraw_print_error(ctx, "failed to get terminal window size"); print_error(ctx, "failed to get terminal window size");
return false; return false;
} }
if (ws.ws_xpixel == 0 || ws.ws_ypixel == 0) { if (ws.ws_xpixel == 0 || ws.ws_ypixel == 0) {
sixdraw_print_error(ctx, "failed to get terminal window size (in pixels)"); print_error(ctx, "failed to get terminal window size (in pixels)");
return false; return false;
} }
ctx->rows = ws.ws_row; ctx->rows = ws.ws_row;
@ -139,7 +139,7 @@ sixdraw_get_winsize(struct sixdraw_ctx *ctx)
} }
static bool static bool
sixdraw_decrqm(struct sixdraw_ctx *ctx, unsigned mode_id, char const *name) decrqm(struct sixdraw_ctx *ctx, unsigned mode_id, char const *name)
{ {
ssize_t retval; ssize_t retval;
union ctlseqs_value *result = ctx->result; union ctlseqs_value *result = ctx->result;
@ -148,24 +148,24 @@ sixdraw_decrqm(struct sixdraw_ctx *ctx, unsigned mode_id, char const *name)
retval = ctlseqs_read(ctx->reader, ctx->matcher, ctx->timeout); retval = ctlseqs_read(ctx->reader, ctx->matcher, ctx->timeout);
} while (retval == CTLSEQS_PARTIAL); } while (retval == CTLSEQS_PARTIAL);
if (retval != 1) { if (retval != 1) {
sixdraw_print_error(ctx, "failed to get %s status", name); print_error(ctx, "failed to get %s status", name);
return false; return false;
} }
if (result[0].num != mode_id || (result[1].num != SIXDRAW_DECRQM_SET && result[1].num != SIXDRAW_DECRQM_RST)) { if (result[0].num != mode_id || (result[1].num != DECRQM_SET && result[1].num != DECRQM_RST)) {
sixdraw_print_error(ctx, "%s status not recognizable", name); print_error(ctx, "%s status not recognizable", name);
return false; return false;
} }
return true; return true;
} }
static bool static bool
sixdraw_init(struct sixdraw_ctx *ctx, int argc, char **argv) init(struct sixdraw_ctx *ctx, int argc, char **argv)
{ {
*ctx = (struct sixdraw_ctx) { *ctx = (struct sixdraw_ctx) {
.prog_name = argc > 0 ? argv[0] : "sixdraw", .prog_name = argc > 0 ? argv[0] : "sixdraw",
.in_fd = STDIN_FILENO, .in_fd = STDIN_FILENO,
.out_fd = STDOUT_FILENO, .out_fd = STDOUT_FILENO,
.timeout = SIXDRAW_DEFAULT_TIMEOUT_MILLIS, .timeout = DEFAULT_TIMEOUT_MILLIS,
}; };
// Process command line arguments. // Process command line arguments.
@ -184,7 +184,7 @@ sixdraw_init(struct sixdraw_ctx *ctx, int argc, char **argv)
// Initialize control sequence matcher. // Initialize control sequence matcher.
ctx->matcher = ctlseqs_matcher_init(); ctx->matcher = ctlseqs_matcher_init();
if (ctx->matcher == NULL) { if (ctx->matcher == NULL) {
sixdraw_print_error(ctx, "failed to initialize matcher"); print_error(ctx, "failed to initialize matcher");
return false; return false;
} }
char const *patterns[] = { char const *patterns[] = {
@ -196,14 +196,14 @@ sixdraw_init(struct sixdraw_ctx *ctx, int argc, char **argv)
.npatterns = sizeof(patterns) / sizeof(char const *), .npatterns = sizeof(patterns) / sizeof(char const *),
}; };
if (ctlseqs_matcher_config(ctx->matcher, &matcher_options) != 0) { if (ctlseqs_matcher_config(ctx->matcher, &matcher_options) != 0) {
sixdraw_print_error(ctx, "failed to set matcher options"); print_error(ctx, "failed to set matcher options");
return false; return false;
} }
// Initialize control sequence reader. // Initialize control sequence reader.
ctx->reader = ctlseqs_reader_init(); ctx->reader = ctlseqs_reader_init();
if (ctx->reader == NULL) { if (ctx->reader == NULL) {
sixdraw_print_error(ctx, "failed to initialize reader"); print_error(ctx, "failed to initialize reader");
return false; return false;
} }
struct ctlseqs_reader_options reader_options = { struct ctlseqs_reader_options reader_options = {
@ -212,7 +212,7 @@ sixdraw_init(struct sixdraw_ctx *ctx, int argc, char **argv)
.maxlen = 4096, .maxlen = 4096,
}; };
if (ctlseqs_reader_config(ctx->reader, &reader_options) != CTLSEQS_OK) { if (ctlseqs_reader_config(ctx->reader, &reader_options) != CTLSEQS_OK) {
sixdraw_print_error(ctx, "failed to set reader options"); print_error(ctx, "failed to set reader options");
return false; return false;
} }
@ -227,17 +227,17 @@ sixdraw_init(struct sixdraw_ctx *ctx, int argc, char **argv)
} }
static bool static bool
sixdraw_prepare(struct sixdraw_ctx *ctx) prepare(struct sixdraw_ctx *ctx)
{ {
// Check whether we're running on a terminal. // Check whether we're running on a terminal.
if (!isatty(ctx->in_fd) || !isatty(ctx->out_fd)) { if (!isatty(ctx->in_fd) || !isatty(ctx->out_fd)) {
sixdraw_print_error(ctx, "this program can only run in a terminal"); print_error(ctx, "this program can only run in a terminal");
return false; return false;
} }
// Set terminal to noncanonical mode. // Set terminal to noncanonical mode.
if (tcgetattr(ctx->in_fd, &ctx->termios) != 0) { if (tcgetattr(ctx->in_fd, &ctx->termios) != 0) {
sixdraw_print_error(ctx, "failed to get terminal attributes"); print_error(ctx, "failed to get terminal attributes");
return false; return false;
} }
struct termios termios = ctx->termios; struct termios termios = ctx->termios;
@ -245,7 +245,7 @@ sixdraw_prepare(struct sixdraw_ctx *ctx)
termios.c_cc[VTIME] = 0; termios.c_cc[VTIME] = 0;
termios.c_lflag &= ~(ICANON | ISIG | ECHO); termios.c_lflag &= ~(ICANON | ISIG | ECHO);
if (tcsetattr(ctx->in_fd, TCSANOW, &termios) != 0) { if (tcsetattr(ctx->in_fd, TCSANOW, &termios) != 0) {
sixdraw_print_error(ctx, "failed to set terminal attributes"); print_error(ctx, "failed to set terminal attributes");
return false; return false;
} }
ctx->has_termios = true; ctx->has_termios = true;
@ -253,16 +253,16 @@ sixdraw_prepare(struct sixdraw_ctx *ctx)
// Set STDIN flags to nonblocking. // Set STDIN flags to nonblocking.
int flags = fcntl(ctx->in_fd, F_GETFL); int flags = fcntl(ctx->in_fd, F_GETFL);
if (flags == -1) { if (flags == -1) {
sixdraw_print_error(ctx, "failed to get file status flags"); print_error(ctx, "failed to get file status flags");
return false; return false;
} }
if (fcntl(ctx->in_fd, F_SETFL, flags | O_NONBLOCK) == -1) { if (fcntl(ctx->in_fd, F_SETFL, flags | O_NONBLOCK) == -1) {
sixdraw_print_error(ctx, "failed to set file status flags"); print_error(ctx, "failed to set file status flags");
return false; return false;
} }
// Get initial terminal window size. // Get initial terminal window size.
if (!sixdraw_get_winsize(ctx)) { if (!get_winsize(ctx)) {
return false; return false;
} }
@ -273,7 +273,7 @@ sixdraw_prepare(struct sixdraw_ctx *ctx)
retval = ctlseqs_read(ctx->reader, ctx->matcher, ctx->timeout); retval = ctlseqs_read(ctx->reader, ctx->matcher, ctx->timeout);
} while (retval == CTLSEQS_PARTIAL); } while (retval == CTLSEQS_PARTIAL);
if (retval != 0) { if (retval != 0) {
sixdraw_print_error(ctx, "failed to get terminal features"); print_error(ctx, "failed to get terminal features");
return false; return false;
} }
bool has_sixel = false; bool has_sixel = false;
@ -287,34 +287,34 @@ sixdraw_prepare(struct sixdraw_ctx *ctx)
} }
} }
if (!has_sixel) { if (!has_sixel) {
sixdraw_print_error(ctx, "terminal does not support sixel graphics"); print_error(ctx, "terminal does not support sixel graphics");
return false; return false;
} }
if (!has_dec_locator) { if (!has_dec_locator) {
sixdraw_print_error(ctx, "terminal does not support DEC locator mode"); print_error(ctx, "terminal does not support DEC locator mode");
return false; return false;
} }
// Get current cursor status. // Get current cursor status.
if (!sixdraw_decrqm(ctx, SIXDRAW_DECTCEM, "cursor")) { if (!decrqm(ctx, DECTCEM, "cursor")) {
return false; return false;
} }
ctx->show_cursor = result[1].num == SIXDRAW_DECRQM_SET; ctx->show_cursor = result[1].num == DECRQM_SET;
// Hide cursor. // Hide cursor.
if (ctx->show_cursor) { if (ctx->show_cursor) {
dprintf(ctx->out_fd, CTLSEQS_DECRST("%u"), SIXDRAW_DECTCEM); dprintf(ctx->out_fd, CTLSEQS_DECRST("%u"), DECTCEM);
} }
// Get current screen buffer status. // Get current screen buffer status.
if (!sixdraw_decrqm(ctx, SIXDRAW_ALT_SCRBUF, "screen buffer")) { if (!decrqm(ctx, ALT_SCRBUF, "screen buffer")) {
return false; return false;
} }
ctx->normal_scrbuf = result[1].num == SIXDRAW_DECRQM_RST; ctx->normal_scrbuf = result[1].num == DECRQM_RST;
// Switch to alternate screen buffer. // Switch to alternate screen buffer.
if (ctx->normal_scrbuf) { if (ctx->normal_scrbuf) {
dprintf(ctx->out_fd, CTLSEQS_DECSET("%u"), SIXDRAW_ALT_SCRBUF); dprintf(ctx->out_fd, CTLSEQS_DECSET("%u"), ALT_SCRBUF);
} }
return true; return true;
@ -326,12 +326,12 @@ main(int argc, char **argv)
int status = 0; int status = 0;
struct sixdraw_ctx ctx; struct sixdraw_ctx ctx;
if (!sixdraw_init(&ctx, argc, argv) || !sixdraw_prepare(&ctx)) { if (!init(&ctx, argc, argv) || !prepare(&ctx)) {
status = -1; status = -1;
goto terminate; goto terminate;
} }
terminate: terminate:
sixdraw_terminate(&ctx); terminate(&ctx);
return status; return status;
} }

328
tests/tcsgrep.c
View File

@ -33,24 +33,26 @@
#include <ctlseqs.h> #include <ctlseqs.h>
#define TCSGREP_NINTH_ARG_(a1, a2, a3, a4, a5, a6, a7, a8, a9, ...) a9 #define NINTH_ARG_(a1, a2, a3, a4, a5, a6, a7, a8, a9, ...) a9
#define TCSGREP_COUNT_ARGS_(...) TCSGREP_NINTH_ARG_(__VA_ARGS__, 8, 7, 6, 5, 4, 3, 2, 1, 0) #define COUNT_ARGS_(...) NINTH_ARG_(__VA_ARGS__, 8, 7, 6, 5, 4, 3, 2, 1, 0)
#define TCSGREP_CONCAT_1_(a1) a1 #define CONCAT_1_(a1) a1
#define TCSGREP_CONCAT_2_(a1, a2) a1 a2 #define CONCAT_2_(a1, a2) a1 a2
#define TCSGREP_CONCAT_3_(a1, a2, a3) a1 a2 a3 #define CONCAT_3_(a1, a2, a3) a1 a2 a3
#define TCSGREP_CONCAT_4_(a1, a2, a3, a4) a1 a2 a3 a4 #define CONCAT_4_(a1, a2, a3, a4) a1 a2 a3 a4
#define TCSGREP_CONCAT_5_(a1, a2, a3, a4, a5) a1 a2 a3 a4 a5 #define CONCAT_5_(a1, a2, a3, a4, a5) a1 a2 a3 a4 a5
#define TCSGREP_CONCAT_6_(a1, a2, a3, a4, a5, a6) a1 a2 a3 a4 a5 a6 #define CONCAT_6_(a1, a2, a3, a4, a5, a6) a1 a2 a3 a4 a5 a6
#define TCSGREP_CONCAT_7_(a1, a2, a3, a4, a5, a6, a7) a1 a2 a3 a4 a5 a6 a7 #define CONCAT_7_(a1, a2, a3, a4, a5, a6, a7) a1 a2 a3 a4 a5 a6 a7
#define TCSGREP_CONCAT_8_(a1, a2, a3, a4, a5, a6, a7, a8) a1 a2 a3 a4 a5 a6 a7 a8 #define CONCAT_8_(a1, a2, a3, a4, a5, a6, a7, a8) a1 a2 a3 a4 a5 a6 a7 a8
#define TCSGREP_CONCAT_(nargs) TCSGREP_CONCAT_##nargs##_ #define CONCAT_(nargs) CONCAT_##nargs##_
#define TCSGREP_DEFARGS_(nargs, ...) TCSGREP_CONCAT_(nargs)(__VA_ARGS__) #define DEFARGS_(nargs, ...) CONCAT_(nargs)(__VA_ARGS__)
#define TCSGREP_DEFSEQ_NOARGS(name) { #name, CTLSEQS_##name(), "" } #define DEFSEQ_NOARGS(name) { #name, CTLSEQS_##name(), "" }
#define TCSGREP_DEFSEQ(name, ...) \ #define DEFSEQ(name, ...) \
{ #name, CTLSEQS_##name(__VA_ARGS__), TCSGREP_DEFARGS_(TCSGREP_COUNT_ARGS_(__VA_ARGS__), __VA_ARGS__) } { #name, CTLSEQS_##name(__VA_ARGS__), DEFARGS_(COUNT_ARGS_(__VA_ARGS__), __VA_ARGS__) }
#define DEFAULT_MAX_BUFFER_LEN 4096
struct tcsgrep_sequence { struct tcsgrep_sequence {
char const *name; char const *name;
@ -101,7 +103,7 @@ print_char(int ch)
} else if (ch == 0x7f) { } else if (ch == 0x7f) {
printf(" DEL"); printf(" DEL");
} else if (!iscntrl(ch)) { } else if (!iscntrl(ch)) {
printf(" \\x%02x", ch); printf(" \\x%02x", (unsigned char)ch);
} else { } else {
printf(" %s", ascii_table[ch]); printf(" %s", ascii_table[ch]);
} }
@ -156,7 +158,7 @@ main(int argc, char **argv)
struct tcsgrep_ctx ctx = { struct tcsgrep_ctx ctx = {
.prog_name = argv[0], .prog_name = argv[0],
.timeout = -1, .timeout = -1,
.limit = 4096, .limit = DEFAULT_MAX_BUFFER_LEN,
}; };
int opt; int opt;
@ -203,154 +205,154 @@ main(int argc, char **argv)
return 1; return 1;
} }
static struct tcsgrep_sequence seqs[] = { static struct tcsgrep_sequence seqs[] = {
TCSGREP_DEFSEQ_NOARGS(S7C1T), DEFSEQ_NOARGS(S7C1T),
TCSGREP_DEFSEQ_NOARGS(S8C1T), DEFSEQ_NOARGS(S8C1T),
TCSGREP_DEFSEQ_NOARGS(DECDHL_TOP), DEFSEQ_NOARGS(DECDHL_TOP),
TCSGREP_DEFSEQ_NOARGS(DECDHL_BOTOM), DEFSEQ_NOARGS(DECDHL_BOTOM),
TCSGREP_DEFSEQ_NOARGS(DECSWL), DEFSEQ_NOARGS(DECSWL),
TCSGREP_DEFSEQ_NOARGS(DECDWL), DEFSEQ_NOARGS(DECDWL),
TCSGREP_DEFSEQ_NOARGS(DECALN), DEFSEQ_NOARGS(DECALN),
TCSGREP_DEFSEQ_NOARGS(DECBI), DEFSEQ_NOARGS(DECBI),
TCSGREP_DEFSEQ_NOARGS(DECSC), DEFSEQ_NOARGS(DECSC),
TCSGREP_DEFSEQ_NOARGS(DECRC), DEFSEQ_NOARGS(DECRC),
TCSGREP_DEFSEQ_NOARGS(DECFI), DEFSEQ_NOARGS(DECFI),
TCSGREP_DEFSEQ_NOARGS(DECKPAM), DEFSEQ_NOARGS(DECKPAM),
TCSGREP_DEFSEQ_NOARGS(DECKPNM), DEFSEQ_NOARGS(DECKPNM),
TCSGREP_DEFSEQ_NOARGS(RIS), DEFSEQ_NOARGS(RIS),
TCSGREP_DEFSEQ(DECUDK, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_STR), DEFSEQ(DECUDK, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_STR),
TCSGREP_DEFSEQ(DECRQSS, CTLSEQS_PH_STR), DEFSEQ(DECRQSS, CTLSEQS_PH_STR),
TCSGREP_DEFSEQ(DECRSPS, CTLSEQS_PH_NUM, CTLSEQS_PH_STR), DEFSEQ(DECRSPS, CTLSEQS_PH_NUM, CTLSEQS_PH_STR),
TCSGREP_DEFSEQ(XTGETXRES, CTLSEQS_PH_STR), DEFSEQ(XTGETXRES, CTLSEQS_PH_STR),
TCSGREP_DEFSEQ(XTSETTCAP, CTLSEQS_PH_STR), DEFSEQ(XTSETTCAP, CTLSEQS_PH_STR),
TCSGREP_DEFSEQ(XTGETTCAP, CTLSEQS_PH_STR), DEFSEQ(XTGETTCAP, CTLSEQS_PH_STR),
TCSGREP_DEFSEQ(ICH, CTLSEQS_PH_NUM), DEFSEQ(ICH, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(SL, CTLSEQS_PH_NUM), DEFSEQ(SL, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(CUU, CTLSEQS_PH_NUM), DEFSEQ(CUU, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(CUD, CTLSEQS_PH_NUM), DEFSEQ(CUD, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(CUF, CTLSEQS_PH_NUM), DEFSEQ(CUF, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(CUB, CTLSEQS_PH_NUM), DEFSEQ(CUB, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(CNL, CTLSEQS_PH_NUM), DEFSEQ(CNL, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(CPL, CTLSEQS_PH_NUM), DEFSEQ(CPL, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(CHA, CTLSEQS_PH_NUM), DEFSEQ(CHA, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(CUP, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM), DEFSEQ(CUP, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(CHT, CTLSEQS_PH_NUM), DEFSEQ(CHT, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(ED, CTLSEQS_PH_NUM), DEFSEQ(ED, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(DECSED, CTLSEQS_PH_NUM), DEFSEQ(DECSED, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(EL, CTLSEQS_PH_NUM), DEFSEQ(EL, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(DECSEL, CTLSEQS_PH_NUM), DEFSEQ(DECSEL, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(IL, CTLSEQS_PH_NUM), DEFSEQ(IL, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(DL, CTLSEQS_PH_NUM), DEFSEQ(DL, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(DCH, CTLSEQS_PH_NUM), DEFSEQ(DCH, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(SU, CTLSEQS_PH_NUM), DEFSEQ(SU, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(XTSMGRAPHICS, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUMS), DEFSEQ(XTSMGRAPHICS, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUMS),
TCSGREP_DEFSEQ(SD, CTLSEQS_PH_NUM), DEFSEQ(SD, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(XTHIMOUSE, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM), DEFSEQ(XTHIMOUSE, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(XTRMTITLE, CTLSEQS_PH_STR), DEFSEQ(XTRMTITLE, CTLSEQS_PH_STR),
TCSGREP_DEFSEQ(ECH, CTLSEQS_PH_NUM), DEFSEQ(ECH, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(CBT, CTLSEQS_PH_NUM), DEFSEQ(CBT, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(HPA, CTLSEQS_PH_NUM), DEFSEQ(HPA, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(HPR, CTLSEQS_PH_NUM), DEFSEQ(HPR, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(REP, CTLSEQS_PH_NUM), DEFSEQ(REP, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ_NOARGS(PRIMARY_DA), DEFSEQ_NOARGS(PRIMARY_DA),
TCSGREP_DEFSEQ_NOARGS(TERTIARY_DA), DEFSEQ_NOARGS(TERTIARY_DA),
TCSGREP_DEFSEQ_NOARGS(SECONDARY_DA), DEFSEQ_NOARGS(SECONDARY_DA),
TCSGREP_DEFSEQ(VPA, CTLSEQS_PH_NUM), DEFSEQ(VPA, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(VPR, CTLSEQS_PH_NUM), DEFSEQ(VPR, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(HVP, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM), DEFSEQ(HVP, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(TBC, CTLSEQS_PH_NUM), DEFSEQ(TBC, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(SM, CTLSEQS_PH_NUM), DEFSEQ(SM, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(DECSET, CTLSEQS_PH_NUM), DEFSEQ(DECSET, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(MC, CTLSEQS_PH_NUM), DEFSEQ(MC, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(MC_DEC, CTLSEQS_PH_NUM), DEFSEQ(MC_DEC, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(RM, CTLSEQS_PH_NUM), DEFSEQ(RM, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(DECRST, CTLSEQS_PH_NUM), DEFSEQ(DECRST, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(SGR, CTLSEQS_PH_NUM), DEFSEQ(SGR, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(XTMODKEYS, CTLSEQS_PH_NUMS), DEFSEQ(XTMODKEYS, CTLSEQS_PH_NUMS),
TCSGREP_DEFSEQ(DSR, CTLSEQS_PH_NUM), DEFSEQ(DSR, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(XTMODKEYS_DISABLE, CTLSEQS_PH_NUM), DEFSEQ(XTMODKEYS_DISABLE, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(DSR_DEC, CTLSEQS_PH_NUM), DEFSEQ(DSR_DEC, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(XTSMPOINTER, CTLSEQS_PH_NUM), DEFSEQ(XTSMPOINTER, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ_NOARGS(DECSTR), DEFSEQ_NOARGS(DECSTR),
TCSGREP_DEFSEQ(DECSCL, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM), DEFSEQ(DECSCL, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(DECRQM_ANSI, CTLSEQS_PH_NUM), DEFSEQ(DECRQM_ANSI, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(DECRQM, CTLSEQS_PH_NUM), DEFSEQ(DECRQM, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ_NOARGS(XTVERSION), DEFSEQ_NOARGS(XTVERSION),
TCSGREP_DEFSEQ(DECLL, CTLSEQS_PH_NUM), DEFSEQ(DECLL, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(DECSCUSR, CTLSEQS_PH_NUM), DEFSEQ(DECSCUSR, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(DECSCA, CTLSEQS_PH_NUM), DEFSEQ(DECSCA, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(DECSTBM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM), DEFSEQ(DECSTBM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(XTRESTORE, CTLSEQS_PH_NUMS), DEFSEQ(XTRESTORE, CTLSEQS_PH_NUMS),
TCSGREP_DEFSEQ(DECCARA, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM), DEFSEQ(DECCARA, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ_NOARGS(SCOSC), DEFSEQ_NOARGS(SCOSC),
TCSGREP_DEFSEQ(DECSLRM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM), DEFSEQ(DECSLRM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(XTSAVE, CTLSEQS_PH_NUMS), DEFSEQ(XTSAVE, CTLSEQS_PH_NUMS),
TCSGREP_DEFSEQ(XTWINOPS, CTLSEQS_PH_NUMS), DEFSEQ(XTWINOPS, CTLSEQS_PH_NUMS),
TCSGREP_DEFSEQ(XTSMTITLE, CTLSEQS_PH_NUMS), DEFSEQ(XTSMTITLE, CTLSEQS_PH_NUMS),
TCSGREP_DEFSEQ(DECSWBV, CTLSEQS_PH_NUM), DEFSEQ(DECSWBV, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(DECRARA, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM), DEFSEQ(DECRARA, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ_NOARGS(SCORC), DEFSEQ_NOARGS(SCORC),
TCSGREP_DEFSEQ(DECSMBV, CTLSEQS_PH_NUM), DEFSEQ(DECSMBV, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(DECCRA, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, DEFSEQ(DECCRA, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM,
CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM), CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(DECRQPSR, CTLSEQS_PH_NUM), DEFSEQ(DECRQPSR, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(DECEFR, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM), DEFSEQ(DECEFR, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(DECREQTPARM, CTLSEQS_PH_NUM), DEFSEQ(DECREQTPARM, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(DECEFR, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM), DEFSEQ(DECEFR, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(DECREQTPARM, CTLSEQS_PH_NUM), DEFSEQ(DECREQTPARM, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(DECSACE, CTLSEQS_PH_NUM), DEFSEQ(DECSACE, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(DECFRA, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM), DEFSEQ(DECFRA, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(XTCHECKSUM, CTLSEQS_PH_NUM), DEFSEQ(XTCHECKSUM, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(DECRQCRA, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, DEFSEQ(DECRQCRA, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM,
CTLSEQS_PH_NUM, CTLSEQS_PH_NUM), CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(DECELR, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM), DEFSEQ(DECELR, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(DECERA, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM), DEFSEQ(DECERA, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(DECSLE, CTLSEQS_PH_NUMS), DEFSEQ(DECSLE, CTLSEQS_PH_NUMS),
TCSGREP_DEFSEQ(XTPUSHSGR, CTLSEQS_PH_NUMS), DEFSEQ(XTPUSHSGR, CTLSEQS_PH_NUMS),
TCSGREP_DEFSEQ(DECSERA, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM), DEFSEQ(DECSERA, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(XTREPORTSGR, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM), DEFSEQ(XTREPORTSGR, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(DECSCPP, CTLSEQS_PH_NUM), DEFSEQ(DECSCPP, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ_NOARGS(DECRQLP), DEFSEQ_NOARGS(DECRQLP),
TCSGREP_DEFSEQ(DECSNLS, CTLSEQS_PH_NUM), DEFSEQ(DECSNLS, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ_NOARGS(XTPOPSGR), DEFSEQ_NOARGS(XTPOPSGR),
TCSGREP_DEFSEQ(DECIC, CTLSEQS_PH_NUM), DEFSEQ(DECIC, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(DECDC, CTLSEQS_PH_NUM), DEFSEQ(DECDC, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(OSC_SEQ, CTLSEQS_PH_NUM, CTLSEQS_PH_STR), DEFSEQ(OSC_SEQ, CTLSEQS_PH_NUM, CTLSEQS_PH_STR),
TCSGREP_DEFSEQ(RESP_DECRQSS, CTLSEQS_PH_NUM, CTLSEQS_PH_STR), DEFSEQ(RESP_DECRQSS, CTLSEQS_PH_NUM, CTLSEQS_PH_STR),
TCSGREP_DEFSEQ(RESP_XTGETXRES, CTLSEQS_PH_NUM, CTLSEQS_PH_STR), DEFSEQ(RESP_XTGETXRES, CTLSEQS_PH_NUM, CTLSEQS_PH_STR),
TCSGREP_DEFSEQ(RESP_XTGETTCAP, CTLSEQS_PH_NUM, CTLSEQS_PH_STR), DEFSEQ(RESP_XTGETTCAP, CTLSEQS_PH_NUM, CTLSEQS_PH_STR),
TCSGREP_DEFSEQ(RESP_PRIMARY_DA, CTLSEQS_PH_NUMS), DEFSEQ(RESP_PRIMARY_DA, CTLSEQS_PH_NUMS),
TCSGREP_DEFSEQ(RESP_SECONDARY_DA, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM), DEFSEQ(RESP_SECONDARY_DA, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(RESP_DECXCPR, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM), DEFSEQ(RESP_DECXCPR, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(RESP_DSR, CTLSEQS_PH_NUMS), DEFSEQ(RESP_DSR, CTLSEQS_PH_NUMS),
TCSGREP_DEFSEQ(RESP_DECRQM_ANSI, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM), DEFSEQ(RESP_DECRQM_ANSI, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(RESP_DECRQM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM), DEFSEQ(RESP_DECRQM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ(RESP_XTVERSION, CTLSEQS_PH_STR), DEFSEQ(RESP_XTVERSION, CTLSEQS_PH_STR),
TCSGREP_DEFSEQ(RESP_DECCIR, CTLSEQS_PH_STR), DEFSEQ(RESP_DECCIR, CTLSEQS_PH_STR),
TCSGREP_DEFSEQ(RESP_DECTABSR, CTLSEQS_PH_STR), DEFSEQ(RESP_DECTABSR, CTLSEQS_PH_STR),
TCSGREP_DEFSEQ(RESP_DECRQCRA, CTLSEQS_PH_NUM, CTLSEQS_PH_STR), DEFSEQ(RESP_DECRQCRA, CTLSEQS_PH_NUM, CTLSEQS_PH_STR),
TCSGREP_DEFSEQ(RESP_DECRQLP, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM), DEFSEQ(RESP_DECRQLP, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
TCSGREP_DEFSEQ_NOARGS(KEY_UP), DEFSEQ_NOARGS(KEY_UP),
TCSGREP_DEFSEQ_NOARGS(KEY_DOWN), DEFSEQ_NOARGS(KEY_DOWN),
TCSGREP_DEFSEQ_NOARGS(KEY_RIGHT), DEFSEQ_NOARGS(KEY_RIGHT),
TCSGREP_DEFSEQ_NOARGS(KEY_LEFT), DEFSEQ_NOARGS(KEY_LEFT),
TCSGREP_DEFSEQ_NOARGS(KEY_HOME), DEFSEQ_NOARGS(KEY_HOME),
TCSGREP_DEFSEQ_NOARGS(KEY_END), DEFSEQ_NOARGS(KEY_END),
TCSGREP_DEFSEQ_NOARGS(KEY_INSERT), DEFSEQ_NOARGS(KEY_INSERT),
TCSGREP_DEFSEQ_NOARGS(KEY_DELETE), DEFSEQ_NOARGS(KEY_DELETE),
TCSGREP_DEFSEQ_NOARGS(KEY_PGUP), DEFSEQ_NOARGS(KEY_PGUP),
TCSGREP_DEFSEQ_NOARGS(KEY_PGDN), DEFSEQ_NOARGS(KEY_PGDN),
TCSGREP_DEFSEQ_NOARGS(KEY_F1), DEFSEQ_NOARGS(KEY_F1),
TCSGREP_DEFSEQ_NOARGS(KEY_F2), DEFSEQ_NOARGS(KEY_F2),
TCSGREP_DEFSEQ_NOARGS(KEY_F3), DEFSEQ_NOARGS(KEY_F3),
TCSGREP_DEFSEQ_NOARGS(KEY_F4), DEFSEQ_NOARGS(KEY_F4),
TCSGREP_DEFSEQ_NOARGS(KEY_F5), DEFSEQ_NOARGS(KEY_F5),
TCSGREP_DEFSEQ_NOARGS(KEY_F6), DEFSEQ_NOARGS(KEY_F6),
TCSGREP_DEFSEQ_NOARGS(KEY_F7), DEFSEQ_NOARGS(KEY_F7),
TCSGREP_DEFSEQ_NOARGS(KEY_F8), DEFSEQ_NOARGS(KEY_F8),
TCSGREP_DEFSEQ_NOARGS(KEY_F9), DEFSEQ_NOARGS(KEY_F9),
TCSGREP_DEFSEQ_NOARGS(KEY_F10), DEFSEQ_NOARGS(KEY_F10),
TCSGREP_DEFSEQ_NOARGS(KEY_F11), DEFSEQ_NOARGS(KEY_F11),
TCSGREP_DEFSEQ_NOARGS(KEY_F12), DEFSEQ_NOARGS(KEY_F12),
}; };
size_t npatterns = sizeof(seqs) / sizeof(struct tcsgrep_sequence); size_t npatterns = sizeof(seqs) / sizeof(struct tcsgrep_sequence);
char const **patterns = malloc(sizeof(char const *) * npatterns); char const **patterns = malloc(sizeof(char const *) * npatterns);