2015-04-13 08:03:12 -04:00
|
|
|
|
/* See LICENSE for license details. */
|
2009-06-15 20:23:46 -04:00
|
|
|
|
#include <ctype.h>
|
|
|
|
|
#include <errno.h>
|
|
|
|
|
#include <fcntl.h>
|
2009-10-28 09:34:22 -04:00
|
|
|
|
#include <limits.h>
|
2009-06-15 20:23:46 -04:00
|
|
|
|
#include <locale.h>
|
2012-10-28 01:54:08 -04:00
|
|
|
|
#include <pwd.h>
|
2009-06-15 20:23:46 -04:00
|
|
|
|
#include <stdarg.h>
|
|
|
|
|
#include <stdio.h>
|
|
|
|
|
#include <stdlib.h>
|
|
|
|
|
#include <string.h>
|
|
|
|
|
#include <signal.h>
|
2013-11-25 10:06:22 -05:00
|
|
|
|
#include <stdint.h>
|
2009-06-15 20:23:46 -04:00
|
|
|
|
#include <sys/ioctl.h>
|
|
|
|
|
#include <sys/select.h>
|
|
|
|
|
#include <sys/stat.h>
|
2012-01-21 17:14:41 -05:00
|
|
|
|
#include <sys/time.h>
|
2009-06-15 20:23:46 -04:00
|
|
|
|
#include <sys/types.h>
|
|
|
|
|
#include <sys/wait.h>
|
2015-09-08 06:10:11 -04:00
|
|
|
|
#include <termios.h>
|
2012-01-21 17:14:41 -05:00
|
|
|
|
#include <time.h>
|
2009-06-15 20:23:46 -04:00
|
|
|
|
#include <unistd.h>
|
2013-06-06 13:09:18 -04:00
|
|
|
|
#include <libgen.h>
|
2012-10-04 16:59:45 -04:00
|
|
|
|
#include <fontconfig/fontconfig.h>
|
2013-09-07 06:41:36 -04:00
|
|
|
|
#include <wchar.h>
|
2012-11-11 13:38:41 -05:00
|
|
|
|
|
2017-01-20 03:06:39 -05:00
|
|
|
|
/* X11 */
|
|
|
|
|
#include <X11/cursorfont.h>
|
|
|
|
|
#include <X11/Xft/Xft.h>
|
2013-04-03 15:00:38 -04:00
|
|
|
|
|
|
|
|
|
char *argv0;
|
|
|
|
|
|
2012-09-24 04:20:45 -04:00
|
|
|
|
#define Glyph Glyph_
|
|
|
|
|
#define Font Font_
|
2009-06-15 20:23:46 -04:00
|
|
|
|
|
2017-01-20 03:06:39 -05:00
|
|
|
|
#include "win.h"
|
|
|
|
|
#include "st.h"
|
|
|
|
|
|
2010-08-30 07:04:19 -04:00
|
|
|
|
#if defined(__linux)
|
2010-08-27 21:18:22 -04:00
|
|
|
|
#include <pty.h>
|
2010-11-24 08:27:44 -05:00
|
|
|
|
#elif defined(__OpenBSD__) || defined(__NetBSD__) || defined(__APPLE__)
|
2010-08-27 21:18:22 -04:00
|
|
|
|
#include <util.h>
|
2010-08-30 07:04:19 -04:00
|
|
|
|
#elif defined(__FreeBSD__) || defined(__DragonFly__)
|
2010-08-27 21:18:22 -04:00
|
|
|
|
#include <libutil.h>
|
|
|
|
|
#endif
|
|
|
|
|
|
2009-06-15 20:23:46 -04:00
|
|
|
|
/* Arbitrary sizes */
|
2014-03-25 15:20:26 -04:00
|
|
|
|
#define UTF_INVALID 0xFFFD
|
2013-01-18 13:11:25 -05:00
|
|
|
|
#define ESC_BUF_SIZ (128*UTF_SIZ)
|
2010-02-08 17:16:55 -05:00
|
|
|
|
#define ESC_ARG_SIZ 16
|
2013-01-18 13:11:25 -05:00
|
|
|
|
#define STR_BUF_SIZ ESC_BUF_SIZ
|
|
|
|
|
#define STR_ARG_SIZ ESC_ARG_SIZ
|
2009-06-15 20:23:46 -04:00
|
|
|
|
|
2012-10-28 08:25:53 -04:00
|
|
|
|
/* macros */
|
2016-10-08 10:22:18 -04:00
|
|
|
|
#define NUMMAXLEN(x) ((int)(sizeof(x) * 2.56 + 0.5) + 1)
|
2015-07-10 08:21:52 -04:00
|
|
|
|
#define DEFAULT(a, b) (a) = (a) ? (a) : (b)
|
|
|
|
|
#define ISCONTROLC0(c) (BETWEEN(c, 0, 0x1f) || (c) == '\177')
|
|
|
|
|
#define ISCONTROLC1(c) (BETWEEN(c, 0x80, 0x9f))
|
|
|
|
|
#define ISCONTROL(c) (ISCONTROLC0(c) || ISCONTROLC1(c))
|
|
|
|
|
#define ISDELIM(u) (utf8strchr(worddelimiters, u) != NULL)
|
2013-07-19 14:34:36 -04:00
|
|
|
|
|
2016-10-08 10:22:18 -04:00
|
|
|
|
/* constants */
|
|
|
|
|
#define ISO14755CMD "dmenu -w %lu -p codepoint: </dev/null"
|
2013-07-19 14:34:36 -04:00
|
|
|
|
|
2012-02-15 18:33:11 -05:00
|
|
|
|
enum cursor_movement {
|
|
|
|
|
CURSOR_SAVE,
|
|
|
|
|
CURSOR_LOAD
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
enum cursor_state {
|
|
|
|
|
CURSOR_DEFAULT = 0,
|
2012-11-08 11:15:26 -05:00
|
|
|
|
CURSOR_WRAPNEXT = 1,
|
2013-06-22 17:07:00 -04:00
|
|
|
|
CURSOR_ORIGIN = 2
|
2012-02-15 18:33:11 -05:00
|
|
|
|
};
|
|
|
|
|
|
Add support for multiple charset definitions
vt100 has support for two defined charset, G0 and G1. Each charset
can be defined, but in each moment is selected only one of both
charset. This is usually used selecting a national charset in G0
and graphic charset in G1, so you can switch between graphic
charset and text charset without losing the national charset
already defined.
st hasn't support for national charsets, because it is an utf8
based terminal emulator, but it has support for graphic
charset because it is heavily used, but it only supports G0,
without understanding G1 selection sequences, which causes some
programs in some moments can print some garbage in the screen.
This patch adds a fake support for multiple charset definitions,
where we only support graphic charset and us-ascii charset, but
we allow more of one charset definition.
This patch allow define G0 until G3 charsets, but only accepts
select G0 or G1, and it accepts some national charset definitions
but all of them are mapped to us-ascii.
2013-10-01 15:23:11 -04:00
|
|
|
|
enum charset {
|
|
|
|
|
CS_GRAPHIC0,
|
|
|
|
|
CS_GRAPHIC1,
|
|
|
|
|
CS_UK,
|
|
|
|
|
CS_USA,
|
|
|
|
|
CS_MULTI,
|
|
|
|
|
CS_GER,
|
|
|
|
|
CS_FIN
|
|
|
|
|
};
|
|
|
|
|
|
2012-02-15 18:33:11 -05:00
|
|
|
|
enum escape_state {
|
|
|
|
|
ESC_START = 1,
|
2013-06-22 17:07:00 -04:00
|
|
|
|
ESC_CSI = 2,
|
2016-09-14 02:27:32 -04:00
|
|
|
|
ESC_STR = 4, /* OSC, PM, APC */
|
2012-08-29 17:14:20 -04:00
|
|
|
|
ESC_ALTCHARSET = 8,
|
|
|
|
|
ESC_STR_END = 16, /* a final string was encountered */
|
2012-10-07 05:06:17 -04:00
|
|
|
|
ESC_TEST = 32, /* Enter in test mode */
|
2016-09-13 08:01:18 -04:00
|
|
|
|
ESC_UTF8 = 64,
|
2016-09-14 02:27:32 -04:00
|
|
|
|
ESC_DCS =128,
|
2012-02-15 18:33:11 -05:00
|
|
|
|
};
|
|
|
|
|
|
2010-02-02 21:25:35 -05:00
|
|
|
|
/* CSI Escape sequence structs */
|
2015-03-18 16:12:47 -04:00
|
|
|
|
/* ESC '[' [[ [<priv>] <arg> [;]] <mode> [<mode>]] */
|
2009-06-15 20:23:46 -04:00
|
|
|
|
typedef struct {
|
2010-02-08 17:16:55 -05:00
|
|
|
|
char buf[ESC_BUF_SIZ]; /* raw string */
|
2013-06-22 17:07:00 -04:00
|
|
|
|
int len; /* raw string length */
|
2009-06-15 20:23:46 -04:00
|
|
|
|
char priv;
|
2010-02-08 17:16:55 -05:00
|
|
|
|
int arg[ESC_ARG_SIZ];
|
2013-06-22 17:07:00 -04:00
|
|
|
|
int narg; /* nb of args */
|
2015-03-18 16:12:47 -04:00
|
|
|
|
char mode[2];
|
2010-02-02 21:25:35 -05:00
|
|
|
|
} CSIEscape;
|
2009-06-15 20:23:46 -04:00
|
|
|
|
|
2012-08-29 17:14:20 -04:00
|
|
|
|
/* STR Escape sequence structs */
|
|
|
|
|
/* ESC type [[ [<priv>] <arg> [;]] <mode>] ESC '\' */
|
|
|
|
|
typedef struct {
|
2013-06-22 17:07:00 -04:00
|
|
|
|
char type; /* ESC type ... */
|
2012-08-29 17:14:20 -04:00
|
|
|
|
char buf[STR_BUF_SIZ]; /* raw string */
|
2013-06-22 17:07:00 -04:00
|
|
|
|
int len; /* raw string length */
|
2012-08-29 17:14:20 -04:00
|
|
|
|
char *args[STR_ARG_SIZ];
|
2013-06-22 17:07:00 -04:00
|
|
|
|
int narg; /* nb of args */
|
2012-08-29 17:14:20 -04:00
|
|
|
|
} STREscape;
|
|
|
|
|
|
2009-09-07 15:19:29 -04:00
|
|
|
|
typedef struct {
|
|
|
|
|
KeySym k;
|
2012-01-21 17:43:03 -05:00
|
|
|
|
uint mask;
|
2013-10-05 05:45:44 -04:00
|
|
|
|
char *s;
|
2012-11-13 14:04:45 -05:00
|
|
|
|
/* three valued logic variables: 0 indifferent, 1 on, -1 off */
|
2013-06-22 17:07:00 -04:00
|
|
|
|
signed char appkey; /* application keypad */
|
|
|
|
|
signed char appcursor; /* application cursor */
|
|
|
|
|
signed char crlf; /* crlf mode */
|
2009-09-07 15:19:29 -04:00
|
|
|
|
} Key;
|
|
|
|
|
|
2012-10-28 08:25:53 -04:00
|
|
|
|
/* function definitions used in config.h */
|
2015-03-14 02:41:59 -04:00
|
|
|
|
static void clipcopy(const Arg *);
|
2013-02-23 15:50:13 -05:00
|
|
|
|
static void clippaste(const Arg *);
|
2012-11-25 03:23:02 -05:00
|
|
|
|
static void numlock(const Arg *);
|
2013-02-23 15:50:13 -05:00
|
|
|
|
static void selpaste(const Arg *);
|
2017-01-20 03:06:39 -05:00
|
|
|
|
static void zoom(const Arg *);
|
|
|
|
|
static void zoomabs(const Arg *);
|
|
|
|
|
static void zoomreset(const Arg *);
|
2014-02-01 07:41:58 -05:00
|
|
|
|
static void printsel(const Arg *);
|
2014-01-31 17:05:42 -05:00
|
|
|
|
static void printscreen(const Arg *) ;
|
2016-10-08 10:22:18 -04:00
|
|
|
|
static void iso14755(const Arg *);
|
2014-01-31 17:05:42 -05:00
|
|
|
|
static void toggleprinter(const Arg *);
|
2015-09-08 06:10:11 -04:00
|
|
|
|
static void sendbreak(const Arg *);
|
2012-10-28 08:25:53 -04:00
|
|
|
|
|
2017-01-20 03:06:39 -05:00
|
|
|
|
/* config.h for applying patches and the configuration. */
|
2010-08-19 06:46:54 -04:00
|
|
|
|
#include "config.h"
|
|
|
|
|
|
2009-07-10 11:23:11 -04:00
|
|
|
|
static void execsh(void);
|
2015-04-13 13:03:53 -04:00
|
|
|
|
static void stty(void);
|
2009-07-10 11:23:11 -04:00
|
|
|
|
static void sigchld(int);
|
|
|
|
|
|
2010-02-02 21:25:35 -05:00
|
|
|
|
static void csidump(void);
|
|
|
|
|
static void csihandle(void);
|
|
|
|
|
static void csiparse(void);
|
|
|
|
|
static void csireset(void);
|
2015-04-08 19:16:57 -04:00
|
|
|
|
static int eschandle(uchar);
|
2012-08-29 17:14:20 -04:00
|
|
|
|
static void strdump(void);
|
|
|
|
|
static void strhandle(void);
|
|
|
|
|
static void strparse(void);
|
|
|
|
|
static void strreset(void);
|
2009-07-10 11:23:11 -04:00
|
|
|
|
|
2014-04-22 13:59:21 -04:00
|
|
|
|
static void tprinter(char *, size_t);
|
2014-02-01 07:41:58 -05:00
|
|
|
|
static void tdumpsel(void);
|
2014-01-31 15:53:53 -05:00
|
|
|
|
static void tdumpline(int);
|
2014-01-31 16:25:51 -05:00
|
|
|
|
static void tdump(void);
|
2013-04-14 12:30:10 -04:00
|
|
|
|
static void tclearregion(int, int, int, int);
|
2009-07-10 11:23:11 -04:00
|
|
|
|
static void tcursor(int);
|
|
|
|
|
static void tdeletechar(int);
|
|
|
|
|
static void tdeleteline(int);
|
|
|
|
|
static void tinsertblank(int);
|
|
|
|
|
static void tinsertblankline(int);
|
2014-06-27 03:15:56 -04:00
|
|
|
|
static int tlinelen(int);
|
2009-07-10 11:23:11 -04:00
|
|
|
|
static void tmoveto(int, int);
|
2014-04-22 13:59:21 -04:00
|
|
|
|
static void tmoveato(int, int);
|
2010-10-16 14:50:29 -04:00
|
|
|
|
static void tnewline(int);
|
2014-04-23 15:12:45 -04:00
|
|
|
|
static void tputtab(int);
|
2015-05-05 16:13:21 -04:00
|
|
|
|
static void tputc(Rune);
|
2010-03-11 17:50:50 -05:00
|
|
|
|
static void treset(void);
|
2014-04-27 18:03:04 -04:00
|
|
|
|
static void tresize(int, int);
|
2010-09-01 17:20:54 -04:00
|
|
|
|
static void tscrollup(int, int);
|
|
|
|
|
static void tscrolldown(int, int);
|
2014-04-22 13:59:21 -04:00
|
|
|
|
static void tsetattr(int *, int);
|
2015-05-05 16:13:21 -04:00
|
|
|
|
static void tsetchar(Rune, Glyph *, int, int);
|
2009-07-10 11:23:11 -04:00
|
|
|
|
static void tsetscroll(int, int);
|
2010-08-30 10:48:18 -04:00
|
|
|
|
static void tswapscreen(void);
|
2015-07-08 17:56:55 -04:00
|
|
|
|
static void tsetmode(int, int, int *, int);
|
2011-10-20 17:20:59 -04:00
|
|
|
|
static void tfulldirt(void);
|
2015-05-05 16:13:21 -04:00
|
|
|
|
static void techo(Rune);
|
2014-04-29 03:58:55 -04:00
|
|
|
|
static void tcontrolcode(uchar );
|
2014-04-26 03:24:04 -04:00
|
|
|
|
static void tdectest(char );
|
2016-09-13 08:01:18 -04:00
|
|
|
|
static void tdefutf8(char);
|
2013-11-25 08:09:53 -05:00
|
|
|
|
static int32_t tdefcolor(int *, int *, int);
|
Add support for multiple charset definitions
vt100 has support for two defined charset, G0 and G1. Each charset
can be defined, but in each moment is selected only one of both
charset. This is usually used selecting a national charset in G0
and graphic charset in G1, so you can switch between graphic
charset and text charset without losing the national charset
already defined.
st hasn't support for national charsets, because it is an utf8
based terminal emulator, but it has support for graphic
charset because it is heavily used, but it only supports G0,
without understanding G1 selection sequences, which causes some
programs in some moments can print some garbage in the screen.
This patch adds a fake support for multiple charset definitions,
where we only support graphic charset and us-ascii charset, but
we allow more of one charset definition.
This patch allow define G0 until G3 charsets, but only accepts
select G0 or G1, and it accepts some national charset definitions
but all of them are mapped to us-ascii.
2013-10-01 15:23:11 -04:00
|
|
|
|
static void tdeftran(char);
|
2015-04-08 19:16:57 -04:00
|
|
|
|
static void tstrsequence(uchar);
|
2009-07-10 11:23:11 -04:00
|
|
|
|
|
2011-09-16 12:48:16 -04:00
|
|
|
|
static void selscroll(int, int);
|
2015-04-30 16:51:35 -04:00
|
|
|
|
static void selsnap(int *, int *, int);
|
2009-07-10 11:23:11 -04:00
|
|
|
|
|
2015-05-05 16:13:21 -04:00
|
|
|
|
static Rune utf8decodebyte(char, size_t *);
|
|
|
|
|
static char utf8encodebyte(Rune, size_t);
|
2015-05-22 10:06:57 -04:00
|
|
|
|
static char *utf8strchr(char *s, Rune u);
|
2015-05-05 16:13:21 -04:00
|
|
|
|
static size_t utf8validate(Rune *, size_t);
|
2010-11-17 19:00:04 -05:00
|
|
|
|
|
2014-04-25 10:27:26 -04:00
|
|
|
|
static ssize_t xwrite(int, const char *, size_t);
|
2012-09-12 15:25:35 -04:00
|
|
|
|
static void *xrealloc(void *, size_t);
|
2009-06-15 20:23:46 -04:00
|
|
|
|
|
2009-05-10 08:17:09 -04:00
|
|
|
|
/* Globals */
|
2017-01-20 03:06:39 -05:00
|
|
|
|
TermWindow win;
|
|
|
|
|
Term term;
|
|
|
|
|
Selection sel;
|
|
|
|
|
int cmdfd;
|
|
|
|
|
pid_t pid;
|
|
|
|
|
char **opt_cmd = NULL;
|
|
|
|
|
char *opt_class = NULL;
|
|
|
|
|
char *opt_embed = NULL;
|
|
|
|
|
char *opt_font = NULL;
|
|
|
|
|
char *opt_io = NULL;
|
|
|
|
|
char *opt_line = NULL;
|
|
|
|
|
char *opt_name = NULL;
|
|
|
|
|
char *opt_title = NULL;
|
|
|
|
|
int oldbutton = 3; /* button event on startup: 3 = release */
|
|
|
|
|
|
2012-08-29 17:14:20 -04:00
|
|
|
|
static CSIEscape csiescseq;
|
|
|
|
|
static STREscape strescseq;
|
2015-07-08 17:49:25 -04:00
|
|
|
|
static int iofd = 1;
|
2017-01-20 03:06:39 -05:00
|
|
|
|
|
|
|
|
|
char *usedfont = NULL;
|
|
|
|
|
double usedfontsize = 0;
|
|
|
|
|
double defaultfontsize = 0;
|
2012-10-28 01:27:42 -04:00
|
|
|
|
|
2014-03-25 15:20:26 -04:00
|
|
|
|
static uchar utfbyte[UTF_SIZ + 1] = {0x80, 0, 0xC0, 0xE0, 0xF0};
|
|
|
|
|
static uchar utfmask[UTF_SIZ + 1] = {0xC0, 0x80, 0xE0, 0xF0, 0xF8};
|
2015-05-05 16:13:21 -04:00
|
|
|
|
static Rune utfmin[UTF_SIZ + 1] = { 0, 0, 0x80, 0x800, 0x10000};
|
|
|
|
|
static Rune utfmax[UTF_SIZ + 1] = {0x10FFFF, 0x7F, 0x7FF, 0xFFFF, 0x10FFFF};
|
2014-03-25 15:20:26 -04:00
|
|
|
|
|
2017-01-20 03:06:39 -05:00
|
|
|
|
/* config.h array lengths */
|
|
|
|
|
size_t colornamelen = LEN(colorname);
|
|
|
|
|
size_t mshortcutslen = LEN(mshortcuts);
|
|
|
|
|
size_t shortcutslen = LEN(shortcuts);
|
|
|
|
|
size_t selmaskslen = LEN(selmasks);
|
2012-12-28 17:52:04 -05:00
|
|
|
|
|
2012-10-28 01:27:42 -04:00
|
|
|
|
ssize_t
|
2015-07-09 17:59:50 -04:00
|
|
|
|
xwrite(int fd, const char *s, size_t len)
|
|
|
|
|
{
|
2015-07-24 05:52:17 -04:00
|
|
|
|
size_t aux = len;
|
|
|
|
|
ssize_t r;
|
2012-10-28 01:27:42 -04:00
|
|
|
|
|
2015-07-10 04:29:53 -04:00
|
|
|
|
while (len > 0) {
|
2015-07-10 08:19:31 -04:00
|
|
|
|
r = write(fd, s, len);
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (r < 0)
|
2012-10-28 01:27:42 -04:00
|
|
|
|
return r;
|
|
|
|
|
len -= r;
|
|
|
|
|
s += r;
|
|
|
|
|
}
|
2015-07-10 08:30:37 -04:00
|
|
|
|
|
2012-10-28 01:27:42 -04:00
|
|
|
|
return aux;
|
|
|
|
|
}
|
|
|
|
|
|
2012-09-12 15:25:35 -04:00
|
|
|
|
void *
|
2015-07-09 17:59:50 -04:00
|
|
|
|
xmalloc(size_t len)
|
|
|
|
|
{
|
2012-09-12 15:25:35 -04:00
|
|
|
|
void *p = malloc(len);
|
2012-10-06 03:58:45 -04:00
|
|
|
|
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (!p)
|
2012-09-17 16:11:28 -04:00
|
|
|
|
die("Out of memory\n");
|
2012-10-06 03:58:45 -04:00
|
|
|
|
|
2012-09-12 15:25:35 -04:00
|
|
|
|
return p;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void *
|
2015-07-09 17:59:50 -04:00
|
|
|
|
xrealloc(void *p, size_t len)
|
|
|
|
|
{
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if ((p = realloc(p, len)) == NULL)
|
2012-09-17 16:11:28 -04:00
|
|
|
|
die("Out of memory\n");
|
2012-10-06 03:58:45 -04:00
|
|
|
|
|
2012-09-12 15:25:35 -04:00
|
|
|
|
return p;
|
|
|
|
|
}
|
|
|
|
|
|
2014-02-01 05:12:47 -05:00
|
|
|
|
char *
|
2015-07-09 17:59:50 -04:00
|
|
|
|
xstrdup(char *s)
|
|
|
|
|
{
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if ((s = strdup(s)) == NULL)
|
2014-02-01 05:12:47 -05:00
|
|
|
|
die("Out of memory\n");
|
|
|
|
|
|
2014-04-22 13:59:48 -04:00
|
|
|
|
return s;
|
2014-02-01 05:12:47 -05:00
|
|
|
|
}
|
|
|
|
|
|
2014-03-25 15:20:26 -04:00
|
|
|
|
size_t
|
2015-07-09 17:59:50 -04:00
|
|
|
|
utf8decode(char *c, Rune *u, size_t clen)
|
|
|
|
|
{
|
2014-03-25 15:20:26 -04:00
|
|
|
|
size_t i, j, len, type;
|
2015-05-05 16:13:21 -04:00
|
|
|
|
Rune udecoded;
|
2010-11-17 19:00:04 -05:00
|
|
|
|
|
2014-03-25 15:20:26 -04:00
|
|
|
|
*u = UTF_INVALID;
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (!clen)
|
2014-03-25 15:20:26 -04:00
|
|
|
|
return 0;
|
|
|
|
|
udecoded = utf8decodebyte(c[0], &len);
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (!BETWEEN(len, 1, UTF_SIZ))
|
2010-11-17 19:00:04 -05:00
|
|
|
|
return 1;
|
2015-07-10 04:29:53 -04:00
|
|
|
|
for (i = 1, j = 1; i < clen && j < len; ++i, ++j) {
|
2014-03-25 15:20:26 -04:00
|
|
|
|
udecoded = (udecoded << 6) | utf8decodebyte(c[i], &type);
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (type != 0)
|
2014-03-25 15:20:26 -04:00
|
|
|
|
return j;
|
2010-11-17 19:00:04 -05:00
|
|
|
|
}
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (j < len)
|
2014-03-25 15:20:26 -04:00
|
|
|
|
return 0;
|
|
|
|
|
*u = udecoded;
|
|
|
|
|
utf8validate(u, len);
|
2015-07-10 08:30:37 -04:00
|
|
|
|
|
2014-03-25 15:20:26 -04:00
|
|
|
|
return len;
|
|
|
|
|
}
|
2012-10-06 03:58:45 -04:00
|
|
|
|
|
2015-05-05 16:13:21 -04:00
|
|
|
|
Rune
|
2015-07-09 17:59:50 -04:00
|
|
|
|
utf8decodebyte(char c, size_t *i)
|
|
|
|
|
{
|
2015-07-10 04:29:53 -04:00
|
|
|
|
for (*i = 0; *i < LEN(utfmask); ++(*i))
|
|
|
|
|
if (((uchar)c & utfmask[*i]) == utfbyte[*i])
|
2014-03-25 15:20:26 -04:00
|
|
|
|
return (uchar)c & ~utfmask[*i];
|
2015-07-10 08:30:37 -04:00
|
|
|
|
|
2014-03-25 15:20:26 -04:00
|
|
|
|
return 0;
|
2010-11-17 19:00:04 -05:00
|
|
|
|
}
|
|
|
|
|
|
2014-03-25 15:20:26 -04:00
|
|
|
|
size_t
|
2015-07-09 17:59:50 -04:00
|
|
|
|
utf8encode(Rune u, char *c)
|
|
|
|
|
{
|
2014-03-25 15:20:26 -04:00
|
|
|
|
size_t len, i;
|
2010-11-17 19:00:04 -05:00
|
|
|
|
|
2014-03-25 15:20:26 -04:00
|
|
|
|
len = utf8validate(&u, 0);
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (len > UTF_SIZ)
|
2010-11-17 19:00:04 -05:00
|
|
|
|
return 0;
|
2015-07-10 08:30:37 -04:00
|
|
|
|
|
2015-07-10 04:29:53 -04:00
|
|
|
|
for (i = len - 1; i != 0; --i) {
|
2014-03-25 15:20:26 -04:00
|
|
|
|
c[i] = utf8encodebyte(u, 0);
|
|
|
|
|
u >>= 6;
|
2012-10-06 03:58:45 -04:00
|
|
|
|
}
|
2014-03-25 15:20:26 -04:00
|
|
|
|
c[0] = utf8encodebyte(u, len);
|
2015-07-10 08:30:37 -04:00
|
|
|
|
|
2014-03-25 15:20:26 -04:00
|
|
|
|
return len;
|
2010-11-17 19:00:04 -05:00
|
|
|
|
}
|
|
|
|
|
|
2014-03-25 15:20:26 -04:00
|
|
|
|
char
|
2015-07-09 17:59:50 -04:00
|
|
|
|
utf8encodebyte(Rune u, size_t i)
|
|
|
|
|
{
|
2014-03-25 15:20:26 -04:00
|
|
|
|
return utfbyte[i] | (u & ~utfmask[i]);
|
|
|
|
|
}
|
2010-11-17 19:00:04 -05:00
|
|
|
|
|
2015-05-22 10:06:57 -04:00
|
|
|
|
char *
|
2015-07-09 17:59:50 -04:00
|
|
|
|
utf8strchr(char *s, Rune u)
|
|
|
|
|
{
|
2015-05-22 10:06:57 -04:00
|
|
|
|
Rune r;
|
|
|
|
|
size_t i, j, len;
|
|
|
|
|
|
|
|
|
|
len = strlen(s);
|
2015-07-10 04:29:53 -04:00
|
|
|
|
for (i = 0, j = 0; i < len; i += j) {
|
|
|
|
|
if (!(j = utf8decode(&s[i], &r, len - i)))
|
2015-05-22 10:06:57 -04:00
|
|
|
|
break;
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (r == u)
|
2015-05-22 10:06:57 -04:00
|
|
|
|
return &(s[i]);
|
|
|
|
|
}
|
2015-07-10 08:30:37 -04:00
|
|
|
|
|
2015-05-22 10:06:57 -04:00
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2014-03-25 15:20:26 -04:00
|
|
|
|
size_t
|
2015-07-09 17:59:50 -04:00
|
|
|
|
utf8validate(Rune *u, size_t i)
|
|
|
|
|
{
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (!BETWEEN(*u, utfmin[i], utfmax[i]) || BETWEEN(*u, 0xD800, 0xDFFF))
|
2014-03-25 15:20:26 -04:00
|
|
|
|
*u = UTF_INVALID;
|
2015-07-10 04:29:53 -04:00
|
|
|
|
for (i = 1; *u > utfmax[i]; ++i)
|
2014-03-25 15:20:26 -04:00
|
|
|
|
;
|
2015-07-10 08:30:37 -04:00
|
|
|
|
|
2014-03-25 15:20:26 -04:00
|
|
|
|
return i;
|
2010-11-17 19:00:04 -05:00
|
|
|
|
}
|
|
|
|
|
|
2015-04-08 19:17:33 -04:00
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
selinit(void)
|
|
|
|
|
{
|
2015-10-11 05:44:34 -04:00
|
|
|
|
clock_gettime(CLOCK_MONOTONIC, &sel.tclick1);
|
|
|
|
|
clock_gettime(CLOCK_MONOTONIC, &sel.tclick2);
|
2015-05-01 13:13:13 -04:00
|
|
|
|
sel.mode = SEL_IDLE;
|
2015-10-11 05:44:34 -04:00
|
|
|
|
sel.snap = 0;
|
2013-05-26 07:07:26 -04:00
|
|
|
|
sel.ob.x = -1;
|
2015-03-14 02:41:59 -04:00
|
|
|
|
sel.primary = NULL;
|
|
|
|
|
sel.clipboard = NULL;
|
2010-08-31 10:53:34 -04:00
|
|
|
|
}
|
|
|
|
|
|
2015-04-08 19:17:33 -04:00
|
|
|
|
int
|
2015-07-09 17:59:50 -04:00
|
|
|
|
x2col(int x)
|
|
|
|
|
{
|
2012-11-02 22:24:22 -04:00
|
|
|
|
x -= borderpx;
|
2017-01-20 03:06:39 -05:00
|
|
|
|
x /= win.cw;
|
2012-11-02 22:24:22 -04:00
|
|
|
|
|
|
|
|
|
return LIMIT(x, 0, term.col-1);
|
|
|
|
|
}
|
|
|
|
|
|
2015-04-08 19:17:33 -04:00
|
|
|
|
int
|
2015-07-09 17:59:50 -04:00
|
|
|
|
y2row(int y)
|
|
|
|
|
{
|
2012-11-02 22:24:22 -04:00
|
|
|
|
y -= borderpx;
|
2017-01-20 03:06:39 -05:00
|
|
|
|
y /= win.ch;
|
2012-11-02 22:24:22 -04:00
|
|
|
|
|
|
|
|
|
return LIMIT(y, 0, term.row-1);
|
|
|
|
|
}
|
|
|
|
|
|
2015-04-18 12:45:21 -04:00
|
|
|
|
int
|
2015-07-09 17:59:50 -04:00
|
|
|
|
tlinelen(int y)
|
|
|
|
|
{
|
2014-06-02 22:34:58 -04:00
|
|
|
|
int i = term.col;
|
|
|
|
|
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (term.line[y][i - 1].mode & ATTR_WRAP)
|
2014-08-22 12:25:04 -04:00
|
|
|
|
return i;
|
|
|
|
|
|
2015-07-10 04:29:53 -04:00
|
|
|
|
while (i > 0 && term.line[y][i - 1].u == ' ')
|
2014-06-02 22:34:58 -04:00
|
|
|
|
--i;
|
|
|
|
|
|
|
|
|
|
return i;
|
|
|
|
|
}
|
|
|
|
|
|
2015-04-08 19:17:33 -04:00
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
selnormalize(void)
|
|
|
|
|
{
|
2014-06-02 22:34:58 -04:00
|
|
|
|
int i;
|
|
|
|
|
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (sel.type == SEL_REGULAR && sel.ob.y != sel.oe.y) {
|
2013-05-26 10:10:22 -04:00
|
|
|
|
sel.nb.x = sel.ob.y < sel.oe.y ? sel.ob.x : sel.oe.x;
|
|
|
|
|
sel.ne.x = sel.ob.y < sel.oe.y ? sel.oe.x : sel.ob.x;
|
2015-04-30 15:59:24 -04:00
|
|
|
|
} else {
|
|
|
|
|
sel.nb.x = MIN(sel.ob.x, sel.oe.x);
|
|
|
|
|
sel.ne.x = MAX(sel.ob.x, sel.oe.x);
|
2013-05-26 10:10:22 -04:00
|
|
|
|
}
|
2013-05-26 07:07:26 -04:00
|
|
|
|
sel.nb.y = MIN(sel.ob.y, sel.oe.y);
|
|
|
|
|
sel.ne.y = MAX(sel.ob.y, sel.oe.y);
|
2014-06-02 22:34:58 -04:00
|
|
|
|
|
2015-04-30 16:51:35 -04:00
|
|
|
|
selsnap(&sel.nb.x, &sel.nb.y, -1);
|
|
|
|
|
selsnap(&sel.ne.x, &sel.ne.y, +1);
|
2014-08-20 15:14:08 -04:00
|
|
|
|
|
2014-06-02 22:34:58 -04:00
|
|
|
|
/* expand selection over line breaks */
|
|
|
|
|
if (sel.type == SEL_RECTANGULAR)
|
|
|
|
|
return;
|
|
|
|
|
i = tlinelen(sel.nb.y);
|
|
|
|
|
if (i < sel.nb.x)
|
|
|
|
|
sel.nb.x = i;
|
|
|
|
|
if (tlinelen(sel.ne.y) <= sel.ne.x)
|
|
|
|
|
sel.ne.x = term.col - 1;
|
2013-05-26 07:07:26 -04:00
|
|
|
|
}
|
|
|
|
|
|
2015-07-08 17:56:55 -04:00
|
|
|
|
int
|
2015-07-09 17:59:50 -04:00
|
|
|
|
selected(int x, int y)
|
|
|
|
|
{
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (sel.mode == SEL_EMPTY)
|
2015-07-08 17:56:55 -04:00
|
|
|
|
return 0;
|
2015-05-03 15:28:10 -04:00
|
|
|
|
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (sel.type == SEL_RECTANGULAR)
|
2014-04-27 07:16:41 -04:00
|
|
|
|
return BETWEEN(y, sel.nb.y, sel.ne.y)
|
|
|
|
|
&& BETWEEN(x, sel.nb.x, sel.ne.x);
|
2012-10-06 03:58:45 -04:00
|
|
|
|
|
2014-04-27 07:16:41 -04:00
|
|
|
|
return BETWEEN(y, sel.nb.y, sel.ne.y)
|
|
|
|
|
&& (y != sel.nb.y || x >= sel.nb.x)
|
|
|
|
|
&& (y != sel.ne.y || x <= sel.ne.x);
|
2010-08-30 17:41:37 -04:00
|
|
|
|
}
|
|
|
|
|
|
2013-04-15 02:28:31 -04:00
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
selsnap(int *x, int *y, int direction)
|
|
|
|
|
{
|
2014-06-05 00:32:01 -04:00
|
|
|
|
int newx, newy, xt, yt;
|
2015-07-08 17:56:55 -04:00
|
|
|
|
int delim, prevdelim;
|
2014-08-20 15:20:44 -04:00
|
|
|
|
Glyph *gp, *prevgp;
|
2014-06-05 00:32:01 -04:00
|
|
|
|
|
2015-07-10 04:29:53 -04:00
|
|
|
|
switch (sel.snap) {
|
2013-04-15 02:28:31 -04:00
|
|
|
|
case SNAP_WORD:
|
2013-05-04 02:01:17 -04:00
|
|
|
|
/*
|
|
|
|
|
* Snap around if the word wraps around at the end or
|
|
|
|
|
* beginning of a line.
|
|
|
|
|
*/
|
2014-08-20 15:20:44 -04:00
|
|
|
|
prevgp = &term.line[*y][*x];
|
2015-04-21 17:29:01 -04:00
|
|
|
|
prevdelim = ISDELIM(prevgp->u);
|
2015-07-10 04:29:53 -04:00
|
|
|
|
for (;;) {
|
2014-06-05 00:32:01 -04:00
|
|
|
|
newx = *x + direction;
|
|
|
|
|
newy = *y;
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (!BETWEEN(newx, 0, term.col - 1)) {
|
2014-06-05 00:32:01 -04:00
|
|
|
|
newy += direction;
|
|
|
|
|
newx = (newx + term.col) % term.col;
|
|
|
|
|
if (!BETWEEN(newy, 0, term.row - 1))
|
2013-04-28 12:14:15 -04:00
|
|
|
|
break;
|
2014-06-05 00:32:01 -04:00
|
|
|
|
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (direction > 0)
|
2014-06-05 00:32:01 -04:00
|
|
|
|
yt = *y, xt = *x;
|
|
|
|
|
else
|
|
|
|
|
yt = newy, xt = newx;
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (!(term.line[yt][xt].mode & ATTR_WRAP))
|
2013-04-28 12:14:15 -04:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
2014-06-05 00:32:01 -04:00
|
|
|
|
if (newx >= tlinelen(newy))
|
|
|
|
|
break;
|
2013-09-07 06:41:36 -04:00
|
|
|
|
|
2014-06-05 00:32:01 -04:00
|
|
|
|
gp = &term.line[newy][newx];
|
2015-04-21 17:29:01 -04:00
|
|
|
|
delim = ISDELIM(gp->u);
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (!(gp->mode & ATTR_WDUMMY) && (delim != prevdelim
|
2015-04-21 17:29:01 -04:00
|
|
|
|
|| (delim && gp->u != prevgp->u)))
|
2013-04-28 12:14:15 -04:00
|
|
|
|
break;
|
|
|
|
|
|
2014-06-05 00:32:01 -04:00
|
|
|
|
*x = newx;
|
|
|
|
|
*y = newy;
|
2014-08-20 15:20:44 -04:00
|
|
|
|
prevgp = gp;
|
|
|
|
|
prevdelim = delim;
|
2013-04-15 02:28:31 -04:00
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case SNAP_LINE:
|
2013-05-04 02:01:17 -04:00
|
|
|
|
/*
|
|
|
|
|
* Snap around if the the previous line or the current one
|
|
|
|
|
* has set ATTR_WRAP at its end. Then the whole next or
|
|
|
|
|
* previous line will be selected.
|
|
|
|
|
*/
|
2013-04-15 02:28:31 -04:00
|
|
|
|
*x = (direction < 0) ? 0 : term.col - 1;
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (direction < 0) {
|
|
|
|
|
for (; *y > 0; *y += direction) {
|
|
|
|
|
if (!(term.line[*y-1][term.col-1].mode
|
2013-04-28 12:14:15 -04:00
|
|
|
|
& ATTR_WRAP)) {
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
2015-07-10 04:29:53 -04:00
|
|
|
|
} else if (direction > 0) {
|
|
|
|
|
for (; *y < term.row-1; *y += direction) {
|
|
|
|
|
if (!(term.line[*y][term.col-1].mode
|
2013-04-28 12:14:15 -04:00
|
|
|
|
& ATTR_WRAP)) {
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2013-04-15 02:28:31 -04:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2014-02-01 07:41:58 -05:00
|
|
|
|
char *
|
2015-07-09 17:59:50 -04:00
|
|
|
|
getsel(void)
|
|
|
|
|
{
|
2013-04-15 09:13:19 -04:00
|
|
|
|
char *str, *ptr;
|
2015-04-21 17:29:01 -04:00
|
|
|
|
int y, bufsize, lastx, linelen;
|
2012-10-28 08:35:00 -04:00
|
|
|
|
Glyph *gp, *last;
|
2010-11-18 06:43:33 -05:00
|
|
|
|
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (sel.ob.x == -1)
|
2014-04-27 07:40:23 -04:00
|
|
|
|
return NULL;
|
2012-02-27 06:44:02 -05:00
|
|
|
|
|
2014-04-27 07:40:23 -04:00
|
|
|
|
bufsize = (term.col+1) * (sel.ne.y-sel.nb.y+1) * UTF_SIZ;
|
|
|
|
|
ptr = str = xmalloc(bufsize);
|
2012-09-17 16:13:09 -04:00
|
|
|
|
|
2014-04-27 07:40:23 -04:00
|
|
|
|
/* append every set & selected glyph to the selection */
|
2015-07-10 04:29:53 -04:00
|
|
|
|
for (y = sel.nb.y; y <= sel.ne.y; y++) {
|
2015-09-10 05:53:11 -04:00
|
|
|
|
if ((linelen = tlinelen(y)) == 0) {
|
|
|
|
|
*ptr++ = '\n';
|
|
|
|
|
continue;
|
|
|
|
|
}
|
2012-10-28 08:35:00 -04:00
|
|
|
|
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (sel.type == SEL_RECTANGULAR) {
|
2014-06-27 03:15:56 -04:00
|
|
|
|
gp = &term.line[y][sel.nb.x];
|
|
|
|
|
lastx = sel.ne.x;
|
|
|
|
|
} else {
|
|
|
|
|
gp = &term.line[y][sel.nb.y == y ? sel.nb.x : 0];
|
|
|
|
|
lastx = (sel.ne.y == y) ? sel.ne.x : term.col-1;
|
2014-04-27 07:40:23 -04:00
|
|
|
|
}
|
2014-06-27 03:15:56 -04:00
|
|
|
|
last = &term.line[y][MIN(lastx, linelen-1)];
|
2015-07-10 04:29:53 -04:00
|
|
|
|
while (last >= gp && last->u == ' ')
|
2014-11-16 03:02:57 -05:00
|
|
|
|
--last;
|
2012-10-28 08:35:00 -04:00
|
|
|
|
|
2015-07-10 04:29:53 -04:00
|
|
|
|
for ( ; gp <= last; ++gp) {
|
|
|
|
|
if (gp->mode & ATTR_WDUMMY)
|
2014-04-27 07:40:23 -04:00
|
|
|
|
continue;
|
2013-04-13 02:48:17 -04:00
|
|
|
|
|
2015-04-21 17:29:01 -04:00
|
|
|
|
ptr += utf8encode(gp->u, ptr);
|
2014-04-27 07:40:23 -04:00
|
|
|
|
}
|
2013-05-04 13:00:32 -04:00
|
|
|
|
|
2014-04-27 07:40:23 -04:00
|
|
|
|
/*
|
|
|
|
|
* Copy and pasting of line endings is inconsistent
|
|
|
|
|
* in the inconsistent terminal and GUI world.
|
|
|
|
|
* The best solution seems like to produce '\n' when
|
|
|
|
|
* something is copied from st and convert '\n' to
|
|
|
|
|
* '\r', when something to be pasted is received by
|
|
|
|
|
* st.
|
|
|
|
|
* FIXME: Fix the computer world.
|
|
|
|
|
*/
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if ((y < sel.ne.y || lastx >= linelen) && !(last->mode & ATTR_WRAP))
|
2014-04-27 07:40:23 -04:00
|
|
|
|
*ptr++ = '\n';
|
2010-08-30 17:41:37 -04:00
|
|
|
|
}
|
2014-04-27 07:40:23 -04:00
|
|
|
|
*ptr = 0;
|
2014-02-01 07:41:58 -05:00
|
|
|
|
return str;
|
|
|
|
|
}
|
|
|
|
|
|
2010-11-20 16:24:04 -05:00
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
selpaste(const Arg *dummy)
|
|
|
|
|
{
|
2017-01-20 03:06:39 -05:00
|
|
|
|
xselpaste();
|
2010-10-12 19:24:11 -04:00
|
|
|
|
}
|
|
|
|
|
|
2015-03-14 02:41:59 -04:00
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
clipcopy(const Arg *dummy)
|
|
|
|
|
{
|
2017-01-20 03:06:39 -05:00
|
|
|
|
xclipcopy();
|
2015-03-14 02:41:59 -04:00
|
|
|
|
}
|
|
|
|
|
|
2013-02-23 15:50:13 -05:00
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
clippaste(const Arg *dummy)
|
|
|
|
|
{
|
2017-01-20 03:06:39 -05:00
|
|
|
|
xclippaste();
|
2013-02-23 15:50:13 -05:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
2017-01-20 03:06:39 -05:00
|
|
|
|
selclear(void)
|
2015-07-09 17:59:50 -04:00
|
|
|
|
{
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (sel.ob.x == -1)
|
2012-09-05 15:55:45 -04:00
|
|
|
|
return;
|
2015-05-14 09:46:07 -04:00
|
|
|
|
sel.mode = SEL_IDLE;
|
2013-05-26 07:07:26 -04:00
|
|
|
|
sel.ob.x = -1;
|
|
|
|
|
tsetdirt(sel.nb.y, sel.ne.y);
|
2012-09-05 15:55:45 -04:00
|
|
|
|
}
|
|
|
|
|
|
2009-05-10 08:17:09 -04:00
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
die(const char *errstr, ...)
|
|
|
|
|
{
|
2009-05-10 08:17:09 -04:00
|
|
|
|
va_list ap;
|
|
|
|
|
|
|
|
|
|
va_start(ap, errstr);
|
|
|
|
|
vfprintf(stderr, errstr, ap);
|
|
|
|
|
va_end(ap);
|
2015-07-08 17:49:25 -04:00
|
|
|
|
exit(1);
|
2009-05-10 08:17:09 -04:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
execsh(void)
|
|
|
|
|
{
|
2014-10-15 13:42:20 -04:00
|
|
|
|
char **args, *sh, *prog;
|
2014-08-18 18:55:02 -04:00
|
|
|
|
const struct passwd *pw;
|
2010-11-28 07:17:20 -05:00
|
|
|
|
|
2014-08-18 18:55:02 -04:00
|
|
|
|
errno = 0;
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if ((pw = getpwuid(getuid())) == NULL) {
|
|
|
|
|
if (errno)
|
2014-08-18 18:55:02 -04:00
|
|
|
|
die("getpwuid:%s\n", strerror(errno));
|
|
|
|
|
else
|
|
|
|
|
die("who are you?\n");
|
|
|
|
|
}
|
2012-09-04 18:08:13 -04:00
|
|
|
|
|
2015-07-24 01:44:34 -04:00
|
|
|
|
if ((sh = getenv("SHELL")) == NULL)
|
2014-10-28 20:51:42 -04:00
|
|
|
|
sh = (pw->pw_shell[0]) ? pw->pw_shell : shell;
|
|
|
|
|
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (opt_cmd)
|
2014-10-15 13:42:20 -04:00
|
|
|
|
prog = opt_cmd[0];
|
2015-07-10 04:29:53 -04:00
|
|
|
|
else if (utmp)
|
2014-10-15 13:42:20 -04:00
|
|
|
|
prog = utmp;
|
2014-08-28 06:48:29 -04:00
|
|
|
|
else
|
2014-10-15 13:42:20 -04:00
|
|
|
|
prog = sh;
|
|
|
|
|
args = (opt_cmd) ? opt_cmd : (char *[]) {prog, NULL};
|
|
|
|
|
|
2014-08-28 06:48:29 -04:00
|
|
|
|
unsetenv("COLUMNS");
|
|
|
|
|
unsetenv("LINES");
|
|
|
|
|
unsetenv("TERMCAP");
|
2014-08-18 18:55:02 -04:00
|
|
|
|
setenv("LOGNAME", pw->pw_name, 1);
|
|
|
|
|
setenv("USER", pw->pw_name, 1);
|
2014-10-15 13:42:20 -04:00
|
|
|
|
setenv("SHELL", sh, 1);
|
2014-08-18 18:55:02 -04:00
|
|
|
|
setenv("HOME", pw->pw_dir, 1);
|
|
|
|
|
setenv("TERM", termname, 1);
|
2017-01-20 03:06:39 -05:00
|
|
|
|
xsetenv();
|
2012-10-28 01:54:08 -04:00
|
|
|
|
|
2012-09-13 17:19:57 -04:00
|
|
|
|
signal(SIGCHLD, SIG_DFL);
|
|
|
|
|
signal(SIGHUP, SIG_DFL);
|
|
|
|
|
signal(SIGINT, SIG_DFL);
|
|
|
|
|
signal(SIGQUIT, SIG_DFL);
|
|
|
|
|
signal(SIGTERM, SIG_DFL);
|
|
|
|
|
signal(SIGALRM, SIG_DFL);
|
|
|
|
|
|
2014-10-15 13:42:20 -04:00
|
|
|
|
execvp(prog, args);
|
2015-07-08 17:49:25 -04:00
|
|
|
|
_exit(1);
|
2009-05-10 08:17:09 -04:00
|
|
|
|
}
|
|
|
|
|
|
2011-04-26 14:29:28 -04:00
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
sigchld(int a)
|
|
|
|
|
{
|
2015-07-08 17:49:25 -04:00
|
|
|
|
int stat;
|
2015-04-22 11:22:34 -04:00
|
|
|
|
pid_t p;
|
2012-10-05 16:59:08 -04:00
|
|
|
|
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if ((p = waitpid(pid, &stat, WNOHANG)) < 0)
|
2014-04-20 07:15:40 -04:00
|
|
|
|
die("Waiting for pid %hd failed: %s\n", pid, strerror(errno));
|
2012-10-05 16:59:08 -04:00
|
|
|
|
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (pid != p)
|
2015-04-22 11:22:34 -04:00
|
|
|
|
return;
|
|
|
|
|
|
2015-07-08 17:49:25 -04:00
|
|
|
|
if (!WIFEXITED(stat) || WEXITSTATUS(stat))
|
2014-08-04 16:07:04 -04:00
|
|
|
|
die("child finished with error '%d'\n", stat);
|
2015-07-08 17:49:25 -04:00
|
|
|
|
exit(0);
|
2009-06-11 10:41:14 -04:00
|
|
|
|
}
|
|
|
|
|
|
2015-04-13 13:03:53 -04:00
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
stty(void)
|
|
|
|
|
{
|
|
|
|
|
char cmd[_POSIX_ARG_MAX], **p, *q, *s;
|
|
|
|
|
size_t n, siz;
|
|
|
|
|
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if ((n = strlen(stty_args)) > sizeof(cmd)-1)
|
2015-04-13 13:03:53 -04:00
|
|
|
|
die("incorrect stty parameters\n");
|
|
|
|
|
memcpy(cmd, stty_args, n);
|
|
|
|
|
q = cmd + n;
|
|
|
|
|
siz = sizeof(cmd) - n;
|
2015-07-10 04:29:53 -04:00
|
|
|
|
for (p = opt_cmd; p && (s = *p); ++p) {
|
|
|
|
|
if ((n = strlen(s)) > siz-1)
|
2015-04-13 13:03:53 -04:00
|
|
|
|
die("stty parameter length too long\n");
|
|
|
|
|
*q++ = ' ';
|
2016-04-15 01:58:26 -04:00
|
|
|
|
memcpy(q, s, n);
|
2015-04-13 13:03:53 -04:00
|
|
|
|
q += n;
|
2016-04-15 01:58:26 -04:00
|
|
|
|
siz -= n + 1;
|
2015-04-13 13:03:53 -04:00
|
|
|
|
}
|
|
|
|
|
*q = '\0';
|
2015-04-21 10:27:51 -04:00
|
|
|
|
if (system(cmd) != 0)
|
|
|
|
|
perror("Couldn't call stty");
|
2015-04-13 13:03:53 -04:00
|
|
|
|
}
|
|
|
|
|
|
2009-05-10 08:17:09 -04:00
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
ttynew(void)
|
|
|
|
|
{
|
2009-05-10 08:17:09 -04:00
|
|
|
|
int m, s;
|
2012-10-06 03:58:45 -04:00
|
|
|
|
struct winsize w = {term.row, term.col, 0, 0};
|
2012-09-02 13:43:29 -04:00
|
|
|
|
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (opt_io) {
|
2015-04-13 13:03:53 -04:00
|
|
|
|
term.mode |= MODE_PRINT;
|
|
|
|
|
iofd = (!strcmp(opt_io, "-")) ?
|
2015-07-08 17:49:25 -04:00
|
|
|
|
1 : open(opt_io, O_WRONLY | O_CREAT, 0666);
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (iofd < 0) {
|
2015-04-13 13:03:53 -04:00
|
|
|
|
fprintf(stderr, "Error opening %s:%s\n",
|
|
|
|
|
opt_io, strerror(errno));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (opt_line) {
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if ((cmdfd = open(opt_line, O_RDWR)) < 0)
|
2015-04-13 13:03:53 -04:00
|
|
|
|
die("open line failed: %s\n", strerror(errno));
|
2015-09-22 07:13:25 -04:00
|
|
|
|
dup2(cmdfd, 0);
|
2015-04-13 13:03:53 -04:00
|
|
|
|
stty();
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2010-08-27 21:18:22 -04:00
|
|
|
|
/* seems to work fine on linux, openbsd and freebsd */
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (openpty(&m, &s, NULL, NULL, &w) < 0)
|
2014-04-20 07:15:40 -04:00
|
|
|
|
die("openpty failed: %s\n", strerror(errno));
|
2010-08-27 21:18:22 -04:00
|
|
|
|
|
2015-07-10 04:29:53 -04:00
|
|
|
|
switch (pid = fork()) {
|
2009-05-10 08:17:09 -04:00
|
|
|
|
case -1:
|
2009-06-11 10:41:14 -04:00
|
|
|
|
die("fork failed\n");
|
2009-05-10 08:17:09 -04:00
|
|
|
|
break;
|
|
|
|
|
case 0:
|
2015-04-13 13:03:53 -04:00
|
|
|
|
close(iofd);
|
2009-05-10 08:17:09 -04:00
|
|
|
|
setsid(); /* create a new process group */
|
2015-07-08 17:49:25 -04:00
|
|
|
|
dup2(s, 0);
|
|
|
|
|
dup2(s, 1);
|
|
|
|
|
dup2(s, 2);
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (ioctl(s, TIOCSCTTY, NULL) < 0)
|
2014-04-20 07:15:40 -04:00
|
|
|
|
die("ioctl TIOCSCTTY failed: %s\n", strerror(errno));
|
2010-08-26 15:36:21 -04:00
|
|
|
|
close(s);
|
|
|
|
|
close(m);
|
2009-05-10 08:17:09 -04:00
|
|
|
|
execsh();
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
close(s);
|
|
|
|
|
cmdfd = m;
|
2009-06-11 10:41:14 -04:00
|
|
|
|
signal(SIGCHLD, sigchld);
|
2014-04-26 17:50:37 -04:00
|
|
|
|
break;
|
2009-05-10 08:17:09 -04:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2015-11-06 14:01:00 -05:00
|
|
|
|
size_t
|
2015-07-09 17:59:50 -04:00
|
|
|
|
ttyread(void)
|
|
|
|
|
{
|
2010-11-27 15:19:31 -05:00
|
|
|
|
static char buf[BUFSIZ];
|
2011-04-26 14:29:28 -04:00
|
|
|
|
static int buflen = 0;
|
2010-11-27 15:19:31 -05:00
|
|
|
|
char *ptr;
|
|
|
|
|
int charsize; /* size of utf8 char in bytes */
|
2015-05-05 16:13:21 -04:00
|
|
|
|
Rune unicodep;
|
2010-11-27 15:19:31 -05:00
|
|
|
|
int ret;
|
2009-05-10 08:17:09 -04:00
|
|
|
|
|
2010-11-27 15:19:31 -05:00
|
|
|
|
/* append read bytes to unprocessed bytes */
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if ((ret = read(cmdfd, buf+buflen, LEN(buf)-buflen)) < 0)
|
2014-04-20 07:15:40 -04:00
|
|
|
|
die("Couldn't read from shell: %s\n", strerror(errno));
|
2010-11-27 15:19:31 -05:00
|
|
|
|
|
|
|
|
|
buflen += ret;
|
|
|
|
|
ptr = buf;
|
|
|
|
|
|
2016-09-13 08:01:18 -04:00
|
|
|
|
for (;;) {
|
2016-09-14 02:27:32 -04:00
|
|
|
|
if (IS_SET(MODE_UTF8) && !IS_SET(MODE_SIXEL)) {
|
2016-09-13 08:01:18 -04:00
|
|
|
|
/* process a complete utf8 char */
|
|
|
|
|
charsize = utf8decode(ptr, &unicodep, buflen);
|
|
|
|
|
if (charsize == 0)
|
|
|
|
|
break;
|
|
|
|
|
tputc(unicodep);
|
|
|
|
|
ptr += charsize;
|
|
|
|
|
buflen -= charsize;
|
|
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
if (buflen <= 0)
|
|
|
|
|
break;
|
|
|
|
|
tputc(*ptr++ & 0xFF);
|
|
|
|
|
buflen--;
|
|
|
|
|
}
|
|
|
|
|
}
|
2010-11-27 15:19:31 -05:00
|
|
|
|
/* keep any uncomplete utf8 char for the next call */
|
2016-09-13 08:01:18 -04:00
|
|
|
|
if (buflen > 0)
|
|
|
|
|
memmove(buf, ptr, buflen);
|
2015-11-06 14:01:00 -05:00
|
|
|
|
|
|
|
|
|
return ret;
|
2009-05-10 08:17:09 -04:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
ttywrite(const char *s, size_t n)
|
|
|
|
|
{
|
2015-11-06 14:01:00 -05:00
|
|
|
|
fd_set wfd, rfd;
|
2015-07-10 08:15:39 -04:00
|
|
|
|
ssize_t r;
|
2015-11-06 14:01:00 -05:00
|
|
|
|
size_t lim = 256;
|
2015-07-10 08:15:39 -04:00
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Remember that we are using a pty, which might be a modem line.
|
|
|
|
|
* Writing too much will clog the line. That's why we are doing this
|
|
|
|
|
* dance.
|
|
|
|
|
* FIXME: Migrate the world to Plan 9.
|
|
|
|
|
*/
|
|
|
|
|
while (n > 0) {
|
|
|
|
|
FD_ZERO(&wfd);
|
2015-11-06 14:01:00 -05:00
|
|
|
|
FD_ZERO(&rfd);
|
2015-07-10 08:15:39 -04:00
|
|
|
|
FD_SET(cmdfd, &wfd);
|
2015-11-06 14:01:00 -05:00
|
|
|
|
FD_SET(cmdfd, &rfd);
|
2015-07-10 08:15:39 -04:00
|
|
|
|
|
|
|
|
|
/* Check if we can write. */
|
2015-11-06 14:01:00 -05:00
|
|
|
|
if (pselect(cmdfd+1, &rfd, &wfd, NULL, NULL, NULL) < 0) {
|
2015-07-10 08:15:39 -04:00
|
|
|
|
if (errno == EINTR)
|
|
|
|
|
continue;
|
|
|
|
|
die("select failed: %s\n", strerror(errno));
|
|
|
|
|
}
|
2015-11-06 14:01:00 -05:00
|
|
|
|
if (FD_ISSET(cmdfd, &wfd)) {
|
2015-07-10 08:15:39 -04:00
|
|
|
|
/*
|
2015-11-06 14:46:23 -05:00
|
|
|
|
* Only write the bytes written by ttywrite() or the
|
|
|
|
|
* default of 256. This seems to be a reasonable value
|
|
|
|
|
* for a serial line. Bigger values might clog the I/O.
|
2015-07-10 08:15:39 -04:00
|
|
|
|
*/
|
2015-11-06 14:46:23 -05:00
|
|
|
|
if ((r = write(cmdfd, s, (n < lim)? n : lim)) < 0)
|
2015-11-06 14:01:00 -05:00
|
|
|
|
goto write_error;
|
2015-07-10 08:15:39 -04:00
|
|
|
|
if (r < n) {
|
|
|
|
|
/*
|
|
|
|
|
* We weren't able to write out everything.
|
|
|
|
|
* This means the buffer is getting full
|
|
|
|
|
* again. Empty it.
|
|
|
|
|
*/
|
2015-11-06 14:01:00 -05:00
|
|
|
|
if (n < lim)
|
|
|
|
|
lim = ttyread();
|
2015-07-10 08:15:39 -04:00
|
|
|
|
n -= r;
|
|
|
|
|
s += r;
|
|
|
|
|
} else {
|
|
|
|
|
/* All bytes have been written. */
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
2015-11-21 12:21:03 -05:00
|
|
|
|
if (FD_ISSET(cmdfd, &rfd))
|
|
|
|
|
lim = ttyread();
|
2015-07-10 08:15:39 -04:00
|
|
|
|
}
|
2015-11-06 14:01:00 -05:00
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
write_error:
|
|
|
|
|
die("write error on tty: %s\n", strerror(errno));
|
2009-05-10 08:17:09 -04:00
|
|
|
|
}
|
|
|
|
|
|
2013-10-05 05:49:35 -04:00
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
ttysend(char *s, size_t n)
|
|
|
|
|
{
|
2015-04-21 17:29:15 -04:00
|
|
|
|
int len;
|
2016-09-13 08:01:18 -04:00
|
|
|
|
char *t, *lim;
|
2015-05-05 16:13:21 -04:00
|
|
|
|
Rune u;
|
2015-04-21 17:29:15 -04:00
|
|
|
|
|
2013-10-05 05:49:35 -04:00
|
|
|
|
ttywrite(s, n);
|
2016-09-13 08:01:18 -04:00
|
|
|
|
if (!IS_SET(MODE_ECHO))
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
lim = &s[n];
|
|
|
|
|
for (t = s; t < lim; t += len) {
|
2016-09-14 02:27:32 -04:00
|
|
|
|
if (IS_SET(MODE_UTF8) && !IS_SET(MODE_SIXEL)) {
|
2016-09-13 08:01:18 -04:00
|
|
|
|
len = utf8decode(t, &u, n);
|
|
|
|
|
} else {
|
|
|
|
|
u = *t & 0xFF;
|
|
|
|
|
len = 1;
|
2015-04-21 17:29:15 -04:00
|
|
|
|
}
|
2016-09-13 08:01:18 -04:00
|
|
|
|
if (len <= 0)
|
|
|
|
|
break;
|
|
|
|
|
techo(u);
|
|
|
|
|
n -= len;
|
|
|
|
|
}
|
2013-10-05 05:49:35 -04:00
|
|
|
|
}
|
|
|
|
|
|
2009-05-10 08:17:09 -04:00
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
ttyresize(void)
|
|
|
|
|
{
|
2009-05-10 08:17:09 -04:00
|
|
|
|
struct winsize w;
|
|
|
|
|
|
|
|
|
|
w.ws_row = term.row;
|
|
|
|
|
w.ws_col = term.col;
|
2017-01-20 03:06:39 -05:00
|
|
|
|
w.ws_xpixel = win.tw;
|
|
|
|
|
w.ws_ypixel = win.th;
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (ioctl(cmdfd, TIOCSWINSZ, &w) < 0)
|
2014-04-20 07:15:40 -04:00
|
|
|
|
fprintf(stderr, "Couldn't set window size: %s\n", strerror(errno));
|
2009-05-10 08:17:09 -04:00
|
|
|
|
}
|
2008-05-20 05:03:59 -04:00
|
|
|
|
|
2013-04-26 12:41:54 -04:00
|
|
|
|
int
|
2015-07-09 17:59:50 -04:00
|
|
|
|
tattrset(int attr)
|
|
|
|
|
{
|
2013-04-26 12:41:54 -04:00
|
|
|
|
int i, j;
|
|
|
|
|
|
2015-07-10 04:29:53 -04:00
|
|
|
|
for (i = 0; i < term.row-1; i++) {
|
|
|
|
|
for (j = 0; j < term.col-1; j++) {
|
|
|
|
|
if (term.line[i][j].mode & attr)
|
2013-04-26 12:41:54 -04:00
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2011-10-20 17:20:59 -04:00
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
tsetdirt(int top, int bot)
|
|
|
|
|
{
|
2011-10-20 17:20:59 -04:00
|
|
|
|
int i;
|
2012-02-27 06:44:02 -05:00
|
|
|
|
|
|
|
|
|
LIMIT(top, 0, term.row-1);
|
|
|
|
|
LIMIT(bot, 0, term.row-1);
|
|
|
|
|
|
2015-07-10 04:29:53 -04:00
|
|
|
|
for (i = top; i <= bot; i++)
|
2011-10-20 17:20:59 -04:00
|
|
|
|
term.dirty[i] = 1;
|
|
|
|
|
}
|
|
|
|
|
|
2013-04-26 12:41:54 -04:00
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
tsetdirtattr(int attr)
|
|
|
|
|
{
|
2013-04-26 12:41:54 -04:00
|
|
|
|
int i, j;
|
|
|
|
|
|
2015-07-10 04:29:53 -04:00
|
|
|
|
for (i = 0; i < term.row-1; i++) {
|
|
|
|
|
for (j = 0; j < term.col-1; j++) {
|
|
|
|
|
if (term.line[i][j].mode & attr) {
|
2013-04-26 12:41:54 -04:00
|
|
|
|
tsetdirt(i, i);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2012-02-27 06:44:02 -05:00
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
tfulldirt(void)
|
|
|
|
|
{
|
2012-02-27 06:44:02 -05:00
|
|
|
|
tsetdirt(0, term.row-1);
|
|
|
|
|
}
|
|
|
|
|
|
2009-05-10 08:17:09 -04:00
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
tcursor(int mode)
|
|
|
|
|
{
|
2013-10-01 14:02:24 -04:00
|
|
|
|
static TCursor c[2];
|
2015-07-08 17:56:55 -04:00
|
|
|
|
int alt = IS_SET(MODE_ALTSCREEN);
|
2010-02-08 17:16:55 -05:00
|
|
|
|
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (mode == CURSOR_SAVE) {
|
2013-10-01 14:02:24 -04:00
|
|
|
|
c[alt] = term.c;
|
2015-07-10 04:29:53 -04:00
|
|
|
|
} else if (mode == CURSOR_LOAD) {
|
2013-10-01 14:02:24 -04:00
|
|
|
|
term.c = c[alt];
|
|
|
|
|
tmoveto(c[alt].x, c[alt].y);
|
2012-10-06 03:58:45 -04:00
|
|
|
|
}
|
2009-05-10 08:17:09 -04:00
|
|
|
|
}
|
|
|
|
|
|
2010-03-11 17:50:50 -05:00
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
treset(void)
|
|
|
|
|
{
|
2012-09-19 10:03:16 -04:00
|
|
|
|
uint i;
|
2012-10-06 03:58:45 -04:00
|
|
|
|
|
2010-08-29 12:55:15 -04:00
|
|
|
|
term.c = (TCursor){{
|
2011-04-26 14:29:28 -04:00
|
|
|
|
.mode = ATTR_NULL,
|
2012-11-02 14:56:02 -04:00
|
|
|
|
.fg = defaultfg,
|
|
|
|
|
.bg = defaultbg
|
2010-08-29 19:35:37 -04:00
|
|
|
|
}, .x = 0, .y = 0, .state = CURSOR_DEFAULT};
|
2012-08-29 13:59:37 -04:00
|
|
|
|
|
|
|
|
|
memset(term.tabs, 0, term.col * sizeof(*term.tabs));
|
2015-07-10 04:29:53 -04:00
|
|
|
|
for (i = tabspaces; i < term.col; i += tabspaces)
|
2012-08-29 13:59:37 -04:00
|
|
|
|
term.tabs[i] = 1;
|
2012-10-06 07:43:01 -04:00
|
|
|
|
term.top = 0;
|
|
|
|
|
term.bot = term.row - 1;
|
2016-09-13 08:01:18 -04:00
|
|
|
|
term.mode = MODE_WRAP|MODE_UTF8;
|
2015-04-18 19:24:28 -04:00
|
|
|
|
memset(term.trantbl, CS_USA, sizeof(term.trantbl));
|
Add support for multiple charset definitions
vt100 has support for two defined charset, G0 and G1. Each charset
can be defined, but in each moment is selected only one of both
charset. This is usually used selecting a national charset in G0
and graphic charset in G1, so you can switch between graphic
charset and text charset without losing the national charset
already defined.
st hasn't support for national charsets, because it is an utf8
based terminal emulator, but it has support for graphic
charset because it is heavily used, but it only supports G0,
without understanding G1 selection sequences, which causes some
programs in some moments can print some garbage in the screen.
This patch adds a fake support for multiple charset definitions,
where we only support graphic charset and us-ascii charset, but
we allow more of one charset definition.
This patch allow define G0 until G3 charsets, but only accepts
select G0 or G1, and it accepts some national charset definitions
but all of them are mapped to us-ascii.
2013-10-01 15:23:11 -04:00
|
|
|
|
term.charset = 0;
|
2012-09-24 05:04:26 -04:00
|
|
|
|
|
2015-07-10 04:29:53 -04:00
|
|
|
|
for (i = 0; i < 2; i++) {
|
2014-08-18 13:20:41 -04:00
|
|
|
|
tmoveto(0, 0);
|
|
|
|
|
tcursor(CURSOR_SAVE);
|
|
|
|
|
tclearregion(0, 0, term.col-1, term.row-1);
|
|
|
|
|
tswapscreen();
|
|
|
|
|
}
|
2010-03-11 17:50:50 -05:00
|
|
|
|
}
|
|
|
|
|
|
2009-05-10 08:17:09 -04:00
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
tnew(int col, int row)
|
|
|
|
|
{
|
2013-08-25 18:10:47 -04:00
|
|
|
|
term = (Term){ .c = { .attr = { .fg = defaultfg, .bg = defaultbg } } };
|
2013-04-14 16:12:10 -04:00
|
|
|
|
tresize(col, row);
|
2012-11-25 03:23:02 -05:00
|
|
|
|
term.numlock = 1;
|
2013-04-18 00:41:54 -04:00
|
|
|
|
|
2010-08-29 12:55:15 -04:00
|
|
|
|
treset();
|
2009-05-10 08:17:09 -04:00
|
|
|
|
}
|
|
|
|
|
|
2010-08-30 10:48:18 -04:00
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
tswapscreen(void)
|
|
|
|
|
{
|
2012-10-06 03:58:45 -04:00
|
|
|
|
Line *tmp = term.line;
|
|
|
|
|
|
2010-08-30 10:48:18 -04:00
|
|
|
|
term.line = term.alt;
|
|
|
|
|
term.alt = tmp;
|
|
|
|
|
term.mode ^= MODE_ALTSCREEN;
|
2011-10-20 17:20:59 -04:00
|
|
|
|
tfulldirt();
|
2010-08-30 10:48:18 -04:00
|
|
|
|
}
|
|
|
|
|
|
2010-03-11 17:50:50 -05:00
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
tscrolldown(int orig, int n)
|
|
|
|
|
{
|
2010-03-11 17:50:50 -05:00
|
|
|
|
int i;
|
|
|
|
|
Line temp;
|
2012-09-02 13:43:29 -04:00
|
|
|
|
|
2010-09-01 17:20:54 -04:00
|
|
|
|
LIMIT(n, 0, term.bot-orig+1);
|
2010-03-11 17:50:50 -05:00
|
|
|
|
|
2014-04-20 09:26:13 -04:00
|
|
|
|
tsetdirt(orig, term.bot-n);
|
2014-04-20 09:26:50 -04:00
|
|
|
|
tclearregion(0, term.bot-n+1, term.col-1, term.bot);
|
2012-09-02 13:43:29 -04:00
|
|
|
|
|
2015-07-10 04:29:53 -04:00
|
|
|
|
for (i = term.bot; i >= orig+n; i--) {
|
2010-03-11 17:50:50 -05:00
|
|
|
|
temp = term.line[i];
|
|
|
|
|
term.line[i] = term.line[i-n];
|
|
|
|
|
term.line[i-n] = temp;
|
|
|
|
|
}
|
2011-09-16 12:48:16 -04:00
|
|
|
|
|
|
|
|
|
selscroll(orig, n);
|
2010-03-11 17:50:50 -05:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
tscrollup(int orig, int n)
|
|
|
|
|
{
|
2010-03-11 17:50:50 -05:00
|
|
|
|
int i;
|
|
|
|
|
Line temp;
|
2014-04-20 09:26:39 -04:00
|
|
|
|
|
2010-09-01 17:20:54 -04:00
|
|
|
|
LIMIT(n, 0, term.bot-orig+1);
|
2012-09-02 13:43:29 -04:00
|
|
|
|
|
2013-04-14 12:30:10 -04:00
|
|
|
|
tclearregion(0, orig, term.col-1, orig+n-1);
|
2014-04-20 09:26:13 -04:00
|
|
|
|
tsetdirt(orig+n, term.bot);
|
2012-09-02 13:43:29 -04:00
|
|
|
|
|
2015-07-10 04:29:53 -04:00
|
|
|
|
for (i = orig; i <= term.bot-n; i++) {
|
2014-04-20 09:26:39 -04:00
|
|
|
|
temp = term.line[i];
|
|
|
|
|
term.line[i] = term.line[i+n];
|
|
|
|
|
term.line[i+n] = temp;
|
2010-08-29 13:41:36 -04:00
|
|
|
|
}
|
2011-09-16 12:48:16 -04:00
|
|
|
|
|
|
|
|
|
selscroll(orig, -n);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
selscroll(int orig, int n)
|
|
|
|
|
{
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (sel.ob.x == -1)
|
2011-09-16 12:48:16 -04:00
|
|
|
|
return;
|
2012-09-02 13:43:29 -04:00
|
|
|
|
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (BETWEEN(sel.ob.y, orig, term.bot) || BETWEEN(sel.oe.y, orig, term.bot)) {
|
|
|
|
|
if ((sel.ob.y += n) > term.bot || (sel.oe.y += n) < term.top) {
|
2017-01-20 03:06:39 -05:00
|
|
|
|
selclear();
|
2011-09-16 12:48:16 -04:00
|
|
|
|
return;
|
|
|
|
|
}
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (sel.type == SEL_RECTANGULAR) {
|
|
|
|
|
if (sel.ob.y < term.top)
|
2013-05-26 07:07:26 -04:00
|
|
|
|
sel.ob.y = term.top;
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (sel.oe.y > term.bot)
|
2013-05-26 07:07:26 -04:00
|
|
|
|
sel.oe.y = term.bot;
|
2013-03-29 13:39:01 -04:00
|
|
|
|
} else {
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (sel.ob.y < term.top) {
|
2013-05-26 07:07:26 -04:00
|
|
|
|
sel.ob.y = term.top;
|
|
|
|
|
sel.ob.x = 0;
|
2013-02-19 13:08:41 -05:00
|
|
|
|
}
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (sel.oe.y > term.bot) {
|
2013-05-26 07:07:26 -04:00
|
|
|
|
sel.oe.y = term.bot;
|
|
|
|
|
sel.oe.x = term.col;
|
2013-02-19 13:08:41 -05:00
|
|
|
|
}
|
2013-03-29 13:39:01 -04:00
|
|
|
|
}
|
2014-06-02 22:34:58 -04:00
|
|
|
|
selnormalize();
|
2011-09-16 12:48:16 -04:00
|
|
|
|
}
|
2010-03-11 17:50:50 -05:00
|
|
|
|
}
|
|
|
|
|
|
2009-05-10 08:17:09 -04:00
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
tnewline(int first_col)
|
|
|
|
|
{
|
2010-09-01 17:20:54 -04:00
|
|
|
|
int y = term.c.y;
|
2012-10-06 03:58:45 -04:00
|
|
|
|
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (y == term.bot) {
|
2010-09-01 17:20:54 -04:00
|
|
|
|
tscrollup(term.top, 1);
|
2012-10-06 03:58:45 -04:00
|
|
|
|
} else {
|
2010-09-01 17:20:54 -04:00
|
|
|
|
y++;
|
2012-10-06 03:58:45 -04:00
|
|
|
|
}
|
2010-10-16 14:50:29 -04:00
|
|
|
|
tmoveto(first_col ? 0 : term.c.x, y);
|
2009-05-10 08:17:09 -04:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
csiparse(void)
|
|
|
|
|
{
|
2013-02-25 07:23:56 -05:00
|
|
|
|
char *p = csiescseq.buf, *np;
|
|
|
|
|
long int v;
|
2009-05-10 08:17:09 -04:00
|
|
|
|
|
2012-08-29 17:14:20 -04:00
|
|
|
|
csiescseq.narg = 0;
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (*p == '?') {
|
2013-02-25 07:36:40 -05:00
|
|
|
|
csiescseq.priv = 1;
|
|
|
|
|
p++;
|
|
|
|
|
}
|
2012-09-02 13:43:29 -04:00
|
|
|
|
|
2013-02-26 15:43:40 -05:00
|
|
|
|
csiescseq.buf[csiescseq.len] = '\0';
|
2015-07-10 04:29:53 -04:00
|
|
|
|
while (p < csiescseq.buf+csiescseq.len) {
|
2013-02-26 13:07:23 -05:00
|
|
|
|
np = NULL;
|
2013-02-25 07:23:56 -05:00
|
|
|
|
v = strtol(p, &np, 10);
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (np == p)
|
2013-02-26 13:07:23 -05:00
|
|
|
|
v = 0;
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (v == LONG_MAX || v == LONG_MIN)
|
2013-02-25 07:23:56 -05:00
|
|
|
|
v = -1;
|
2013-02-26 12:19:44 -05:00
|
|
|
|
csiescseq.arg[csiescseq.narg++] = v;
|
|
|
|
|
p = np;
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (*p != ';' || csiescseq.narg == ESC_ARG_SIZ)
|
2013-02-26 12:19:44 -05:00
|
|
|
|
break;
|
|
|
|
|
p++;
|
2009-05-10 08:17:09 -04:00
|
|
|
|
}
|
2015-03-18 16:12:47 -04:00
|
|
|
|
csiescseq.mode[0] = *p++;
|
|
|
|
|
csiescseq.mode[1] = (p < csiescseq.buf+csiescseq.len) ? *p : '\0';
|
2009-05-10 08:17:09 -04:00
|
|
|
|
}
|
|
|
|
|
|
2012-11-08 11:21:10 -05:00
|
|
|
|
/* for absolute user moves, when decom is set */
|
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
tmoveato(int x, int y)
|
|
|
|
|
{
|
2012-11-08 11:21:10 -05:00
|
|
|
|
tmoveto(x, y + ((term.c.state & CURSOR_ORIGIN) ? term.top: 0));
|
|
|
|
|
}
|
|
|
|
|
|
2009-05-10 08:17:09 -04:00
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
tmoveto(int x, int y)
|
|
|
|
|
{
|
2012-11-08 11:21:10 -05:00
|
|
|
|
int miny, maxy;
|
|
|
|
|
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (term.c.state & CURSOR_ORIGIN) {
|
2012-11-08 11:21:10 -05:00
|
|
|
|
miny = term.top;
|
|
|
|
|
maxy = term.bot;
|
|
|
|
|
} else {
|
|
|
|
|
miny = 0;
|
|
|
|
|
maxy = term.row - 1;
|
|
|
|
|
}
|
2010-08-29 19:35:37 -04:00
|
|
|
|
term.c.state &= ~CURSOR_WRAPNEXT;
|
2015-04-13 08:03:51 -04:00
|
|
|
|
term.c.x = LIMIT(x, 0, term.col-1);
|
|
|
|
|
term.c.y = LIMIT(y, miny, maxy);
|
2009-05-10 08:17:09 -04:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
tsetchar(Rune u, Glyph *attr, int x, int y)
|
|
|
|
|
{
|
2012-10-07 05:06:08 -04:00
|
|
|
|
static char *vt100_0[62] = { /* 0x41 - 0x7e */
|
2012-10-06 03:58:45 -04:00
|
|
|
|
"↑", "↓", "→", "←", "█", "▚", "☃", /* A - G */
|
|
|
|
|
0, 0, 0, 0, 0, 0, 0, 0, /* H - O */
|
|
|
|
|
0, 0, 0, 0, 0, 0, 0, 0, /* P - W */
|
|
|
|
|
0, 0, 0, 0, 0, 0, 0, " ", /* X - _ */
|
|
|
|
|
"◆", "▒", "␉", "␌", "␍", "␊", "°", "±", /* ` - g */
|
|
|
|
|
"", "␋", "┘", "┐", "┌", "└", "┼", "⎺", /* h - o */
|
|
|
|
|
"⎻", "─", "⎼", "⎽", "├", "┤", "┴", "┬", /* p - w */
|
|
|
|
|
"│", "≤", "≥", "π", "≠", "£", "·", /* x - ~ */
|
|
|
|
|
};
|
|
|
|
|
|
2012-09-26 14:21:08 -04:00
|
|
|
|
/*
|
|
|
|
|
* The table is proudly stolen from rxvt.
|
|
|
|
|
*/
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (term.trantbl[term.charset] == CS_GRAPHIC0 &&
|
2015-04-21 17:29:15 -04:00
|
|
|
|
BETWEEN(u, 0x41, 0x7e) && vt100_0[u - 0x41])
|
|
|
|
|
utf8decode(vt100_0[u - 0x41], &u, UTF_SIZ);
|
2012-09-26 14:21:08 -04:00
|
|
|
|
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (term.line[y][x].mode & ATTR_WIDE) {
|
|
|
|
|
if (x+1 < term.col) {
|
2015-04-21 17:29:01 -04:00
|
|
|
|
term.line[y][x+1].u = ' ';
|
2013-09-07 06:41:36 -04:00
|
|
|
|
term.line[y][x+1].mode &= ~ATTR_WDUMMY;
|
|
|
|
|
}
|
2015-07-10 04:29:53 -04:00
|
|
|
|
} else if (term.line[y][x].mode & ATTR_WDUMMY) {
|
2015-04-21 17:29:01 -04:00
|
|
|
|
term.line[y][x-1].u = ' ';
|
2013-09-07 06:41:36 -04:00
|
|
|
|
term.line[y][x-1].mode &= ~ATTR_WIDE;
|
|
|
|
|
}
|
|
|
|
|
|
2012-10-07 05:06:17 -04:00
|
|
|
|
term.dirty[y] = 1;
|
|
|
|
|
term.line[y][x] = *attr;
|
2015-04-21 17:29:15 -04:00
|
|
|
|
term.line[y][x].u = u;
|
2009-05-10 08:17:09 -04:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
tclearregion(int x1, int y1, int x2, int y2)
|
|
|
|
|
{
|
2013-04-24 15:30:59 -04:00
|
|
|
|
int x, y, temp;
|
2014-08-07 04:11:38 -04:00
|
|
|
|
Glyph *gp;
|
2010-03-11 17:50:50 -05:00
|
|
|
|
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (x1 > x2)
|
2010-03-11 17:50:50 -05:00
|
|
|
|
temp = x1, x1 = x2, x2 = temp;
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (y1 > y2)
|
2010-03-11 17:50:50 -05:00
|
|
|
|
temp = y1, y1 = y2, y2 = temp;
|
2009-05-10 08:17:09 -04:00
|
|
|
|
|
|
|
|
|
LIMIT(x1, 0, term.col-1);
|
|
|
|
|
LIMIT(x2, 0, term.col-1);
|
|
|
|
|
LIMIT(y1, 0, term.row-1);
|
|
|
|
|
LIMIT(y2, 0, term.row-1);
|
|
|
|
|
|
2015-07-10 04:29:53 -04:00
|
|
|
|
for (y = y1; y <= y2; y++) {
|
2011-10-20 17:20:59 -04:00
|
|
|
|
term.dirty[y] = 1;
|
2015-07-10 04:29:53 -04:00
|
|
|
|
for (x = x1; x <= x2; x++) {
|
2014-08-07 04:11:38 -04:00
|
|
|
|
gp = &term.line[y][x];
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (selected(x, y))
|
2017-01-20 03:06:39 -05:00
|
|
|
|
selclear();
|
2014-08-07 04:11:38 -04:00
|
|
|
|
gp->fg = term.c.attr.fg;
|
|
|
|
|
gp->bg = term.c.attr.bg;
|
|
|
|
|
gp->mode = 0;
|
2015-04-21 17:29:01 -04:00
|
|
|
|
gp->u = ' ';
|
2013-01-20 08:54:35 -05:00
|
|
|
|
}
|
2011-10-20 17:20:59 -04:00
|
|
|
|
}
|
2009-05-10 08:17:09 -04:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
tdeletechar(int n)
|
|
|
|
|
{
|
2014-04-22 18:08:13 -04:00
|
|
|
|
int dst, src, size;
|
2014-04-25 11:24:12 -04:00
|
|
|
|
Glyph *line;
|
2012-09-02 13:43:29 -04:00
|
|
|
|
|
2014-04-22 18:08:13 -04:00
|
|
|
|
LIMIT(n, 0, term.col - term.c.x);
|
2009-05-10 08:17:09 -04:00
|
|
|
|
|
2014-04-22 18:08:13 -04:00
|
|
|
|
dst = term.c.x;
|
|
|
|
|
src = term.c.x + n;
|
|
|
|
|
size = term.col - src;
|
2014-04-25 11:24:12 -04:00
|
|
|
|
line = term.line[term.c.y];
|
2012-10-06 03:58:45 -04:00
|
|
|
|
|
2014-04-25 11:24:12 -04:00
|
|
|
|
memmove(&line[dst], &line[src], size * sizeof(Glyph));
|
2013-04-14 12:30:10 -04:00
|
|
|
|
tclearregion(term.col-n, term.c.y, term.col-1, term.c.y);
|
2009-05-10 08:17:09 -04:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
tinsertblank(int n)
|
|
|
|
|
{
|
2014-04-22 18:08:13 -04:00
|
|
|
|
int dst, src, size;
|
2014-04-25 11:24:12 -04:00
|
|
|
|
Glyph *line;
|
2009-05-10 08:17:09 -04:00
|
|
|
|
|
2014-04-22 18:08:13 -04:00
|
|
|
|
LIMIT(n, 0, term.col - term.c.x);
|
2011-10-20 17:20:59 -04:00
|
|
|
|
|
2014-04-22 18:08:13 -04:00
|
|
|
|
dst = term.c.x + n;
|
|
|
|
|
src = term.c.x;
|
|
|
|
|
size = term.col - dst;
|
2014-04-25 11:24:12 -04:00
|
|
|
|
line = term.line[term.c.y];
|
2012-10-06 03:58:45 -04:00
|
|
|
|
|
2014-04-25 11:24:12 -04:00
|
|
|
|
memmove(&line[dst], &line[src], size * sizeof(Glyph));
|
2013-04-14 12:30:10 -04:00
|
|
|
|
tclearregion(src, term.c.y, dst - 1, term.c.y);
|
2009-05-10 08:17:09 -04:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
tinsertblankline(int n)
|
|
|
|
|
{
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (BETWEEN(term.c.y, term.top, term.bot))
|
2014-04-22 13:59:01 -04:00
|
|
|
|
tscrolldown(term.c.y, n);
|
2009-05-10 08:17:09 -04:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
tdeleteline(int n)
|
|
|
|
|
{
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (BETWEEN(term.c.y, term.top, term.bot))
|
2014-04-22 13:59:01 -04:00
|
|
|
|
tscrollup(term.c.y, n);
|
2009-05-10 08:17:09 -04:00
|
|
|
|
}
|
|
|
|
|
|
2013-11-25 08:09:53 -05:00
|
|
|
|
int32_t
|
2015-07-09 17:59:50 -04:00
|
|
|
|
tdefcolor(int *attr, int *npar, int l)
|
|
|
|
|
{
|
2013-11-24 04:20:45 -05:00
|
|
|
|
int32_t idx = -1;
|
2013-07-19 14:34:36 -04:00
|
|
|
|
uint r, g, b;
|
|
|
|
|
|
|
|
|
|
switch (attr[*npar + 1]) {
|
2014-06-01 11:08:16 -04:00
|
|
|
|
case 2: /* direct color in RGB space */
|
2013-07-19 14:34:36 -04:00
|
|
|
|
if (*npar + 4 >= l) {
|
|
|
|
|
fprintf(stderr,
|
|
|
|
|
"erresc(38): Incorrect number of parameters (%d)\n",
|
|
|
|
|
*npar);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
r = attr[*npar + 2];
|
|
|
|
|
g = attr[*npar + 3];
|
|
|
|
|
b = attr[*npar + 4];
|
|
|
|
|
*npar += 4;
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (!BETWEEN(r, 0, 255) || !BETWEEN(g, 0, 255) || !BETWEEN(b, 0, 255))
|
2015-04-22 09:07:59 -04:00
|
|
|
|
fprintf(stderr, "erresc: bad rgb color (%u,%u,%u)\n",
|
2013-07-19 14:34:36 -04:00
|
|
|
|
r, g, b);
|
|
|
|
|
else
|
|
|
|
|
idx = TRUECOLOR(r, g, b);
|
|
|
|
|
break;
|
2014-06-01 11:08:16 -04:00
|
|
|
|
case 5: /* indexed color */
|
2013-07-19 14:34:36 -04:00
|
|
|
|
if (*npar + 2 >= l) {
|
|
|
|
|
fprintf(stderr,
|
|
|
|
|
"erresc(38): Incorrect number of parameters (%d)\n",
|
|
|
|
|
*npar);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
*npar += 2;
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (!BETWEEN(attr[*npar], 0, 255))
|
2013-07-19 14:34:36 -04:00
|
|
|
|
fprintf(stderr, "erresc: bad fgcolor %d\n", attr[*npar]);
|
|
|
|
|
else
|
|
|
|
|
idx = attr[*npar];
|
|
|
|
|
break;
|
|
|
|
|
case 0: /* implemented defined (only foreground) */
|
|
|
|
|
case 1: /* transparent */
|
2014-06-01 11:08:16 -04:00
|
|
|
|
case 3: /* direct color in CMY space */
|
|
|
|
|
case 4: /* direct color in CMYK space */
|
2013-07-19 14:34:36 -04:00
|
|
|
|
default:
|
|
|
|
|
fprintf(stderr,
|
|
|
|
|
"erresc(38): gfx attr %d unknown\n", attr[*npar]);
|
2014-04-26 17:50:37 -04:00
|
|
|
|
break;
|
2013-07-19 14:34:36 -04:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return idx;
|
|
|
|
|
}
|
|
|
|
|
|
2009-05-10 08:17:09 -04:00
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
tsetattr(int *attr, int l)
|
|
|
|
|
{
|
2009-05-10 08:17:09 -04:00
|
|
|
|
int i;
|
2013-11-24 04:20:45 -05:00
|
|
|
|
int32_t idx;
|
2009-05-10 08:17:09 -04:00
|
|
|
|
|
2015-07-10 04:29:53 -04:00
|
|
|
|
for (i = 0; i < l; i++) {
|
|
|
|
|
switch (attr[i]) {
|
2009-06-16 20:58:40 -04:00
|
|
|
|
case 0:
|
2014-06-21 14:29:36 -04:00
|
|
|
|
term.c.attr.mode &= ~(
|
|
|
|
|
ATTR_BOLD |
|
|
|
|
|
ATTR_FAINT |
|
|
|
|
|
ATTR_ITALIC |
|
|
|
|
|
ATTR_UNDERLINE |
|
|
|
|
|
ATTR_BLINK |
|
|
|
|
|
ATTR_REVERSE |
|
|
|
|
|
ATTR_INVISIBLE |
|
|
|
|
|
ATTR_STRUCK );
|
2012-11-02 14:56:02 -04:00
|
|
|
|
term.c.attr.fg = defaultfg;
|
|
|
|
|
term.c.attr.bg = defaultbg;
|
2009-06-16 20:58:40 -04:00
|
|
|
|
break;
|
|
|
|
|
case 1:
|
2011-04-26 14:29:28 -04:00
|
|
|
|
term.c.attr.mode |= ATTR_BOLD;
|
2009-06-16 20:58:40 -04:00
|
|
|
|
break;
|
2014-06-21 14:29:36 -04:00
|
|
|
|
case 2:
|
|
|
|
|
term.c.attr.mode |= ATTR_FAINT;
|
|
|
|
|
break;
|
2013-01-08 14:36:49 -05:00
|
|
|
|
case 3:
|
2012-09-05 15:48:26 -04:00
|
|
|
|
term.c.attr.mode |= ATTR_ITALIC;
|
2012-09-02 13:53:50 -04:00
|
|
|
|
break;
|
2011-04-26 14:29:28 -04:00
|
|
|
|
case 4:
|
2010-02-08 17:16:55 -05:00
|
|
|
|
term.c.attr.mode |= ATTR_UNDERLINE;
|
2009-06-16 20:58:40 -04:00
|
|
|
|
break;
|
2013-01-27 07:26:06 -05:00
|
|
|
|
case 5: /* slow blink */
|
2014-07-31 13:37:59 -04:00
|
|
|
|
/* FALLTHROUGH */
|
2014-06-21 14:29:36 -04:00
|
|
|
|
case 6: /* rapid blink */
|
2014-07-31 13:37:59 -04:00
|
|
|
|
term.c.attr.mode |= ATTR_BLINK;
|
2014-06-21 14:29:36 -04:00
|
|
|
|
break;
|
2011-04-26 14:29:28 -04:00
|
|
|
|
case 7:
|
|
|
|
|
term.c.attr.mode |= ATTR_REVERSE;
|
2009-06-16 20:58:40 -04:00
|
|
|
|
break;
|
2014-06-21 14:29:36 -04:00
|
|
|
|
case 8:
|
|
|
|
|
term.c.attr.mode |= ATTR_INVISIBLE;
|
|
|
|
|
break;
|
|
|
|
|
case 9:
|
|
|
|
|
term.c.attr.mode |= ATTR_STRUCK;
|
|
|
|
|
break;
|
|
|
|
|
case 22:
|
2014-07-26 03:48:15 -04:00
|
|
|
|
term.c.attr.mode &= ~(ATTR_BOLD | ATTR_FAINT);
|
2014-06-21 14:29:36 -04:00
|
|
|
|
break;
|
2013-01-08 14:36:49 -05:00
|
|
|
|
case 23:
|
2012-09-05 15:48:26 -04:00
|
|
|
|
term.c.attr.mode &= ~ATTR_ITALIC;
|
2012-09-02 13:53:50 -04:00
|
|
|
|
break;
|
2011-04-26 14:29:28 -04:00
|
|
|
|
case 24:
|
2010-02-08 17:16:55 -05:00
|
|
|
|
term.c.attr.mode &= ~ATTR_UNDERLINE;
|
2009-06-16 20:58:40 -04:00
|
|
|
|
break;
|
2012-09-12 07:08:26 -04:00
|
|
|
|
case 25:
|
2014-07-31 13:37:59 -04:00
|
|
|
|
term.c.attr.mode &= ~ATTR_BLINK;
|
2014-06-21 14:29:36 -04:00
|
|
|
|
break;
|
2011-04-26 14:29:28 -04:00
|
|
|
|
case 27:
|
|
|
|
|
term.c.attr.mode &= ~ATTR_REVERSE;
|
2009-06-16 20:58:40 -04:00
|
|
|
|
break;
|
2014-06-21 14:29:36 -04:00
|
|
|
|
case 28:
|
|
|
|
|
term.c.attr.mode &= ~ATTR_INVISIBLE;
|
|
|
|
|
break;
|
|
|
|
|
case 29:
|
|
|
|
|
term.c.attr.mode &= ~ATTR_STRUCK;
|
|
|
|
|
break;
|
2010-07-24 07:09:14 -04:00
|
|
|
|
case 38:
|
2013-07-19 14:34:36 -04:00
|
|
|
|
if ((idx = tdefcolor(attr, &i, l)) >= 0)
|
|
|
|
|
term.c.attr.fg = idx;
|
2010-07-24 07:09:14 -04:00
|
|
|
|
break;
|
2009-06-16 20:58:40 -04:00
|
|
|
|
case 39:
|
2012-11-02 14:56:02 -04:00
|
|
|
|
term.c.attr.fg = defaultfg;
|
2009-06-16 20:58:40 -04:00
|
|
|
|
break;
|
2010-07-24 07:09:14 -04:00
|
|
|
|
case 48:
|
2013-07-19 14:34:36 -04:00
|
|
|
|
if ((idx = tdefcolor(attr, &i, l)) >= 0)
|
|
|
|
|
term.c.attr.bg = idx;
|
2010-07-24 07:09:14 -04:00
|
|
|
|
break;
|
2009-06-16 20:58:40 -04:00
|
|
|
|
case 49:
|
2012-11-02 14:56:02 -04:00
|
|
|
|
term.c.attr.bg = defaultbg;
|
2009-06-16 20:58:40 -04:00
|
|
|
|
break;
|
|
|
|
|
default:
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (BETWEEN(attr[i], 30, 37)) {
|
2009-06-16 20:58:40 -04:00
|
|
|
|
term.c.attr.fg = attr[i] - 30;
|
2015-07-10 04:29:53 -04:00
|
|
|
|
} else if (BETWEEN(attr[i], 40, 47)) {
|
2009-06-16 20:58:40 -04:00
|
|
|
|
term.c.attr.bg = attr[i] - 40;
|
2015-07-10 04:29:53 -04:00
|
|
|
|
} else if (BETWEEN(attr[i], 90, 97)) {
|
2010-07-24 07:09:14 -04:00
|
|
|
|
term.c.attr.fg = attr[i] - 90 + 8;
|
2015-07-10 04:29:53 -04:00
|
|
|
|
} else if (BETWEEN(attr[i], 100, 107)) {
|
2012-09-12 07:20:10 -04:00
|
|
|
|
term.c.attr.bg = attr[i] - 100 + 8;
|
2012-10-06 03:58:45 -04:00
|
|
|
|
} else {
|
|
|
|
|
fprintf(stderr,
|
|
|
|
|
"erresc(default): gfx attr %d unknown\n",
|
|
|
|
|
attr[i]), csidump();
|
|
|
|
|
}
|
2009-06-16 20:58:40 -04:00
|
|
|
|
break;
|
2009-05-10 08:17:09 -04:00
|
|
|
|
}
|
2009-06-16 20:58:40 -04:00
|
|
|
|
}
|
2009-05-10 08:17:09 -04:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
tsetscroll(int t, int b)
|
|
|
|
|
{
|
2009-05-10 08:17:09 -04:00
|
|
|
|
int temp;
|
|
|
|
|
|
|
|
|
|
LIMIT(t, 0, term.row-1);
|
|
|
|
|
LIMIT(b, 0, term.row-1);
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (t > b) {
|
2009-05-10 08:17:09 -04:00
|
|
|
|
temp = t;
|
|
|
|
|
t = b;
|
|
|
|
|
b = temp;
|
|
|
|
|
}
|
|
|
|
|
term.top = t;
|
2011-04-26 14:29:28 -04:00
|
|
|
|
term.bot = b;
|
2009-05-10 08:17:09 -04:00
|
|
|
|
}
|
|
|
|
|
|
2012-09-02 13:09:35 -04:00
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
tsetmode(int priv, int set, int *args, int narg)
|
|
|
|
|
{
|
2012-09-02 13:09:35 -04:00
|
|
|
|
int *lim, mode;
|
2015-07-08 17:56:55 -04:00
|
|
|
|
int alt;
|
2012-09-02 13:09:35 -04:00
|
|
|
|
|
2015-07-10 04:29:53 -04:00
|
|
|
|
for (lim = args + narg; args < lim; ++args) {
|
|
|
|
|
if (priv) {
|
|
|
|
|
switch (*args) {
|
2012-09-24 04:29:37 -04:00
|
|
|
|
case 1: /* DECCKM -- Cursor key */
|
2012-11-13 14:04:34 -05:00
|
|
|
|
MODBIT(term.mode, set, MODE_APPCURSOR);
|
2012-09-02 13:09:35 -04:00
|
|
|
|
break;
|
2012-10-04 16:59:45 -04:00
|
|
|
|
case 5: /* DECSCNM -- Reverse video */
|
2012-09-02 13:09:35 -04:00
|
|
|
|
mode = term.mode;
|
2012-09-29 05:17:16 -04:00
|
|
|
|
MODBIT(term.mode, set, MODE_REVERSE);
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (mode != term.mode)
|
2015-02-14 18:34:03 -05:00
|
|
|
|
redraw();
|
2012-09-02 13:09:35 -04:00
|
|
|
|
break;
|
2012-11-08 11:21:10 -05:00
|
|
|
|
case 6: /* DECOM -- Origin */
|
|
|
|
|
MODBIT(term.c.state, set, CURSOR_ORIGIN);
|
|
|
|
|
tmoveato(0, 0);
|
2012-09-24 04:29:37 -04:00
|
|
|
|
break;
|
|
|
|
|
case 7: /* DECAWM -- Auto wrap */
|
2012-09-02 13:09:35 -04:00
|
|
|
|
MODBIT(term.mode, set, MODE_WRAP);
|
|
|
|
|
break;
|
2012-09-24 04:29:37 -04:00
|
|
|
|
case 0: /* Error (IGNORED) */
|
2012-11-08 11:22:04 -05:00
|
|
|
|
case 2: /* DECANM -- ANSI/VT52 (IGNORED) */
|
|
|
|
|
case 3: /* DECCOLM -- Column (IGNORED) */
|
|
|
|
|
case 4: /* DECSCLM -- Scroll (IGNORED) */
|
|
|
|
|
case 8: /* DECARM -- Auto repeat (IGNORED) */
|
|
|
|
|
case 18: /* DECPFF -- Printer feed (IGNORED) */
|
|
|
|
|
case 19: /* DECPEX -- Printer extent (IGNORED) */
|
|
|
|
|
case 42: /* DECNRCM -- National characters (IGNORED) */
|
2012-09-02 13:09:35 -04:00
|
|
|
|
case 12: /* att610 -- Start blinking cursor (IGNORED) */
|
|
|
|
|
break;
|
2012-11-08 11:15:26 -05:00
|
|
|
|
case 25: /* DECTCEM -- Text Cursor Enable Mode */
|
|
|
|
|
MODBIT(term.mode, !set, MODE_HIDE);
|
2012-09-02 13:09:35 -04:00
|
|
|
|
break;
|
2013-06-01 08:37:30 -04:00
|
|
|
|
case 9: /* X10 mouse compatibility mode */
|
|
|
|
|
xsetpointermotion(0);
|
|
|
|
|
MODBIT(term.mode, 0, MODE_MOUSE);
|
|
|
|
|
MODBIT(term.mode, set, MODE_MOUSEX10);
|
|
|
|
|
break;
|
|
|
|
|
case 1000: /* 1000: report button press */
|
|
|
|
|
xsetpointermotion(0);
|
|
|
|
|
MODBIT(term.mode, 0, MODE_MOUSE);
|
2012-09-02 13:09:35 -04:00
|
|
|
|
MODBIT(term.mode, set, MODE_MOUSEBTN);
|
|
|
|
|
break;
|
2013-06-01 08:37:30 -04:00
|
|
|
|
case 1002: /* 1002: report motion on button press */
|
|
|
|
|
xsetpointermotion(0);
|
|
|
|
|
MODBIT(term.mode, 0, MODE_MOUSE);
|
2012-09-02 13:09:35 -04:00
|
|
|
|
MODBIT(term.mode, set, MODE_MOUSEMOTION);
|
|
|
|
|
break;
|
2013-06-01 08:37:30 -04:00
|
|
|
|
case 1003: /* 1003: enable all mouse motions */
|
|
|
|
|
xsetpointermotion(set);
|
|
|
|
|
MODBIT(term.mode, 0, MODE_MOUSE);
|
|
|
|
|
MODBIT(term.mode, set, MODE_MOUSEMANY);
|
2013-06-01 07:06:53 -04:00
|
|
|
|
break;
|
2013-06-01 08:37:30 -04:00
|
|
|
|
case 1004: /* 1004: send focus events to tty */
|
2013-06-01 07:06:53 -04:00
|
|
|
|
MODBIT(term.mode, set, MODE_FOCUS);
|
|
|
|
|
break;
|
2013-06-01 08:37:30 -04:00
|
|
|
|
case 1006: /* 1006: extended reporting mode */
|
2013-01-26 09:13:56 -05:00
|
|
|
|
MODBIT(term.mode, set, MODE_MOUSESGR);
|
|
|
|
|
break;
|
2013-04-23 09:22:14 -04:00
|
|
|
|
case 1034:
|
|
|
|
|
MODBIT(term.mode, set, MODE_8BIT);
|
|
|
|
|
break;
|
2013-10-01 14:02:24 -04:00
|
|
|
|
case 1049: /* swap screen & set/restore cursor as xterm */
|
2014-04-09 14:37:23 -04:00
|
|
|
|
if (!allowaltscreen)
|
|
|
|
|
break;
|
2013-10-01 14:02:24 -04:00
|
|
|
|
tcursor((set) ? CURSOR_SAVE : CURSOR_LOAD);
|
2014-04-25 10:26:54 -04:00
|
|
|
|
/* FALLTHROUGH */
|
2013-10-01 14:02:24 -04:00
|
|
|
|
case 47: /* swap screen */
|
2013-04-03 14:42:27 -04:00
|
|
|
|
case 1047:
|
|
|
|
|
if (!allowaltscreen)
|
|
|
|
|
break;
|
2012-12-10 14:45:46 -05:00
|
|
|
|
alt = IS_SET(MODE_ALTSCREEN);
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (alt) {
|
2013-01-20 08:54:35 -05:00
|
|
|
|
tclearregion(0, 0, term.col-1,
|
2013-04-14 12:30:10 -04:00
|
|
|
|
term.row-1);
|
2013-01-20 08:54:35 -05:00
|
|
|
|
}
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (set ^ alt) /* set is always 1 or 0 */
|
2012-10-06 07:43:01 -04:00
|
|
|
|
tswapscreen();
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (*args != 1049)
|
2012-09-02 13:09:35 -04:00
|
|
|
|
break;
|
2014-04-25 10:26:54 -04:00
|
|
|
|
/* FALLTHROUGH */
|
2012-09-02 13:09:35 -04:00
|
|
|
|
case 1048:
|
|
|
|
|
tcursor((set) ? CURSOR_SAVE : CURSOR_LOAD);
|
|
|
|
|
break;
|
2013-09-23 03:22:47 -04:00
|
|
|
|
case 2004: /* 2004: bracketed paste mode */
|
|
|
|
|
MODBIT(term.mode, set, MODE_BRCKTPASTE);
|
|
|
|
|
break;
|
2013-06-01 07:13:01 -04:00
|
|
|
|
/* Not implemented mouse modes. See comments there. */
|
2013-06-01 07:06:53 -04:00
|
|
|
|
case 1001: /* mouse highlight mode; can hang the
|
2013-06-01 07:13:01 -04:00
|
|
|
|
terminal by design when implemented. */
|
|
|
|
|
case 1005: /* UTF-8 mouse mode; will confuse
|
|
|
|
|
applications not supporting UTF-8
|
|
|
|
|
and luit. */
|
|
|
|
|
case 1015: /* urxvt mangled mouse mode; incompatible
|
|
|
|
|
and can be mistaken for other control
|
|
|
|
|
codes. */
|
2012-09-02 13:09:35 -04:00
|
|
|
|
default:
|
|
|
|
|
fprintf(stderr,
|
|
|
|
|
"erresc: unknown private set/reset mode %d\n",
|
|
|
|
|
*args);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
} else {
|
2015-07-10 04:29:53 -04:00
|
|
|
|
switch (*args) {
|
2012-09-24 04:29:37 -04:00
|
|
|
|
case 0: /* Error (IGNORED) */
|
|
|
|
|
break;
|
|
|
|
|
case 2: /* KAM -- keyboard action */
|
2012-09-24 04:28:05 -04:00
|
|
|
|
MODBIT(term.mode, set, MODE_KBDLOCK);
|
|
|
|
|
break;
|
2012-09-24 04:29:37 -04:00
|
|
|
|
case 4: /* IRM -- Insertion-replacement */
|
2012-09-02 13:09:35 -04:00
|
|
|
|
MODBIT(term.mode, set, MODE_INSERT);
|
|
|
|
|
break;
|
2012-11-13 14:04:26 -05:00
|
|
|
|
case 12: /* SRM -- Send/Receive */
|
|
|
|
|
MODBIT(term.mode, !set, MODE_ECHO);
|
2012-09-24 04:29:37 -04:00
|
|
|
|
break;
|
|
|
|
|
case 20: /* LNM -- Linefeed/new line */
|
2012-09-24 04:28:35 -04:00
|
|
|
|
MODBIT(term.mode, set, MODE_CRLF);
|
|
|
|
|
break;
|
2012-09-02 13:09:35 -04:00
|
|
|
|
default:
|
|
|
|
|
fprintf(stderr,
|
|
|
|
|
"erresc: unknown set/reset mode %d\n",
|
|
|
|
|
*args);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2009-05-10 08:17:09 -04:00
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
csihandle(void)
|
|
|
|
|
{
|
2013-10-02 15:06:50 -04:00
|
|
|
|
char buf[40];
|
|
|
|
|
int len;
|
|
|
|
|
|
2015-07-10 04:29:53 -04:00
|
|
|
|
switch (csiescseq.mode[0]) {
|
2009-06-16 06:34:10 -04:00
|
|
|
|
default:
|
2010-02-08 17:16:55 -05:00
|
|
|
|
unknown:
|
2011-04-01 03:32:41 -04:00
|
|
|
|
fprintf(stderr, "erresc: unknown csi ");
|
2010-02-02 21:25:35 -05:00
|
|
|
|
csidump();
|
|
|
|
|
/* die(""); */
|
|
|
|
|
break;
|
2010-02-08 17:16:55 -05:00
|
|
|
|
case '@': /* ICH -- Insert <n> blank char */
|
2012-08-29 17:14:20 -04:00
|
|
|
|
DEFAULT(csiescseq.arg[0], 1);
|
|
|
|
|
tinsertblank(csiescseq.arg[0]);
|
2010-02-02 21:25:35 -05:00
|
|
|
|
break;
|
2010-02-08 17:16:55 -05:00
|
|
|
|
case 'A': /* CUU -- Cursor <n> Up */
|
2012-08-29 17:14:20 -04:00
|
|
|
|
DEFAULT(csiescseq.arg[0], 1);
|
|
|
|
|
tmoveto(term.c.x, term.c.y-csiescseq.arg[0]);
|
2010-02-02 21:25:35 -05:00
|
|
|
|
break;
|
2010-02-08 17:16:55 -05:00
|
|
|
|
case 'B': /* CUD -- Cursor <n> Down */
|
2012-11-08 11:21:24 -05:00
|
|
|
|
case 'e': /* VPR --Cursor <n> Down */
|
2012-08-29 17:14:20 -04:00
|
|
|
|
DEFAULT(csiescseq.arg[0], 1);
|
|
|
|
|
tmoveto(term.c.x, term.c.y+csiescseq.arg[0]);
|
2010-02-02 21:25:35 -05:00
|
|
|
|
break;
|
2014-01-31 14:57:09 -05:00
|
|
|
|
case 'i': /* MC -- Media Copy */
|
2015-07-10 04:29:53 -04:00
|
|
|
|
switch (csiescseq.arg[0]) {
|
2014-01-31 14:57:09 -05:00
|
|
|
|
case 0:
|
2014-01-31 16:25:51 -05:00
|
|
|
|
tdump();
|
|
|
|
|
break;
|
2014-01-31 14:57:09 -05:00
|
|
|
|
case 1:
|
2014-01-31 15:53:53 -05:00
|
|
|
|
tdumpline(term.c.y);
|
|
|
|
|
break;
|
2014-02-01 07:41:58 -05:00
|
|
|
|
case 2:
|
|
|
|
|
tdumpsel();
|
|
|
|
|
break;
|
2014-01-31 14:57:09 -05:00
|
|
|
|
case 4:
|
|
|
|
|
term.mode &= ~MODE_PRINT;
|
|
|
|
|
break;
|
|
|
|
|
case 5:
|
|
|
|
|
term.mode |= MODE_PRINT;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
break;
|
2012-10-06 15:19:56 -04:00
|
|
|
|
case 'c': /* DA -- Device Attributes */
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (csiescseq.arg[0] == 0)
|
2014-08-15 09:00:48 -04:00
|
|
|
|
ttywrite(vtiden, sizeof(vtiden) - 1);
|
2012-10-06 15:19:56 -04:00
|
|
|
|
break;
|
2010-02-08 17:16:55 -05:00
|
|
|
|
case 'C': /* CUF -- Cursor <n> Forward */
|
2012-11-08 11:21:24 -05:00
|
|
|
|
case 'a': /* HPR -- Cursor <n> Forward */
|
2012-08-29 17:14:20 -04:00
|
|
|
|
DEFAULT(csiescseq.arg[0], 1);
|
|
|
|
|
tmoveto(term.c.x+csiescseq.arg[0], term.c.y);
|
2010-02-02 21:25:35 -05:00
|
|
|
|
break;
|
2010-02-08 17:16:55 -05:00
|
|
|
|
case 'D': /* CUB -- Cursor <n> Backward */
|
2012-08-29 17:14:20 -04:00
|
|
|
|
DEFAULT(csiescseq.arg[0], 1);
|
|
|
|
|
tmoveto(term.c.x-csiescseq.arg[0], term.c.y);
|
2010-02-02 21:25:35 -05:00
|
|
|
|
break;
|
2010-02-08 17:16:55 -05:00
|
|
|
|
case 'E': /* CNL -- Cursor <n> Down and first col */
|
2012-08-29 17:14:20 -04:00
|
|
|
|
DEFAULT(csiescseq.arg[0], 1);
|
|
|
|
|
tmoveto(0, term.c.y+csiescseq.arg[0]);
|
2010-02-02 21:25:35 -05:00
|
|
|
|
break;
|
2010-02-08 17:16:55 -05:00
|
|
|
|
case 'F': /* CPL -- Cursor <n> Up and first col */
|
2012-08-29 17:14:20 -04:00
|
|
|
|
DEFAULT(csiescseq.arg[0], 1);
|
|
|
|
|
tmoveto(0, term.c.y-csiescseq.arg[0]);
|
2010-02-02 21:25:35 -05:00
|
|
|
|
break;
|
2012-08-29 13:59:47 -04:00
|
|
|
|
case 'g': /* TBC -- Tabulation clear */
|
2015-07-10 04:29:53 -04:00
|
|
|
|
switch (csiescseq.arg[0]) {
|
2012-08-29 13:59:47 -04:00
|
|
|
|
case 0: /* clear current tab stop */
|
|
|
|
|
term.tabs[term.c.x] = 0;
|
|
|
|
|
break;
|
|
|
|
|
case 3: /* clear all the tabs */
|
|
|
|
|
memset(term.tabs, 0, term.col * sizeof(*term.tabs));
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
goto unknown;
|
|
|
|
|
}
|
|
|
|
|
break;
|
2010-02-08 17:16:55 -05:00
|
|
|
|
case 'G': /* CHA -- Move to <col> */
|
2012-09-04 15:56:55 -04:00
|
|
|
|
case '`': /* HPA */
|
2012-08-29 17:14:20 -04:00
|
|
|
|
DEFAULT(csiescseq.arg[0], 1);
|
|
|
|
|
tmoveto(csiescseq.arg[0]-1, term.c.y);
|
2010-02-02 21:25:35 -05:00
|
|
|
|
break;
|
2010-02-08 17:16:55 -05:00
|
|
|
|
case 'H': /* CUP -- Move to <row> <col> */
|
2012-09-04 15:56:55 -04:00
|
|
|
|
case 'f': /* HVP */
|
2012-08-29 17:14:20 -04:00
|
|
|
|
DEFAULT(csiescseq.arg[0], 1);
|
|
|
|
|
DEFAULT(csiescseq.arg[1], 1);
|
2012-11-08 11:21:10 -05:00
|
|
|
|
tmoveato(csiescseq.arg[1]-1, csiescseq.arg[0]-1);
|
2010-02-02 21:25:35 -05:00
|
|
|
|
break;
|
2012-08-29 14:05:25 -04:00
|
|
|
|
case 'I': /* CHT -- Cursor Forward Tabulation <n> tab stops */
|
2012-08-29 17:14:20 -04:00
|
|
|
|
DEFAULT(csiescseq.arg[0], 1);
|
2014-04-23 15:12:45 -04:00
|
|
|
|
tputtab(csiescseq.arg[0]);
|
2012-08-29 14:05:25 -04:00
|
|
|
|
break;
|
2010-02-08 17:16:55 -05:00
|
|
|
|
case 'J': /* ED -- Clear screen */
|
2017-01-20 03:06:39 -05:00
|
|
|
|
selclear();
|
2015-07-10 04:29:53 -04:00
|
|
|
|
switch (csiescseq.arg[0]) {
|
2010-02-02 21:25:35 -05:00
|
|
|
|
case 0: /* below */
|
2013-04-14 12:30:10 -04:00
|
|
|
|
tclearregion(term.c.x, term.c.y, term.col-1, term.c.y);
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (term.c.y < term.row-1) {
|
2013-01-20 08:54:35 -05:00
|
|
|
|
tclearregion(0, term.c.y+1, term.col-1,
|
2013-04-14 12:30:10 -04:00
|
|
|
|
term.row-1);
|
2013-01-20 08:54:35 -05:00
|
|
|
|
}
|
2009-05-10 08:17:09 -04:00
|
|
|
|
break;
|
2010-02-02 21:25:35 -05:00
|
|
|
|
case 1: /* above */
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (term.c.y > 1)
|
2013-04-14 12:30:10 -04:00
|
|
|
|
tclearregion(0, 0, term.col-1, term.c.y-1);
|
|
|
|
|
tclearregion(0, term.c.y, term.c.x, term.c.y);
|
2009-05-10 08:17:09 -04:00
|
|
|
|
break;
|
2010-02-02 21:25:35 -05:00
|
|
|
|
case 2: /* all */
|
2013-04-14 12:30:10 -04:00
|
|
|
|
tclearregion(0, 0, term.col-1, term.row-1);
|
2010-02-08 17:16:55 -05:00
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
goto unknown;
|
2010-02-02 21:25:35 -05:00
|
|
|
|
}
|
|
|
|
|
break;
|
2010-02-08 17:16:55 -05:00
|
|
|
|
case 'K': /* EL -- Clear line */
|
2015-07-10 04:29:53 -04:00
|
|
|
|
switch (csiescseq.arg[0]) {
|
2010-02-02 21:25:35 -05:00
|
|
|
|
case 0: /* right */
|
2013-01-20 08:54:35 -05:00
|
|
|
|
tclearregion(term.c.x, term.c.y, term.col-1,
|
2013-04-14 12:30:10 -04:00
|
|
|
|
term.c.y);
|
2009-05-10 08:17:09 -04:00
|
|
|
|
break;
|
2010-02-02 21:25:35 -05:00
|
|
|
|
case 1: /* left */
|
2013-04-14 12:30:10 -04:00
|
|
|
|
tclearregion(0, term.c.y, term.c.x, term.c.y);
|
2009-05-10 08:17:09 -04:00
|
|
|
|
break;
|
2010-02-02 21:25:35 -05:00
|
|
|
|
case 2: /* all */
|
2013-04-14 12:30:10 -04:00
|
|
|
|
tclearregion(0, term.c.y, term.col-1, term.c.y);
|
2009-05-10 08:17:09 -04:00
|
|
|
|
break;
|
2010-02-02 21:25:35 -05:00
|
|
|
|
}
|
|
|
|
|
break;
|
2010-03-11 17:50:50 -05:00
|
|
|
|
case 'S': /* SU -- Scroll <n> line up */
|
2012-08-29 17:14:20 -04:00
|
|
|
|
DEFAULT(csiescseq.arg[0], 1);
|
|
|
|
|
tscrollup(term.top, csiescseq.arg[0]);
|
2010-03-11 17:50:50 -05:00
|
|
|
|
break;
|
|
|
|
|
case 'T': /* SD -- Scroll <n> line down */
|
2012-08-29 17:14:20 -04:00
|
|
|
|
DEFAULT(csiescseq.arg[0], 1);
|
|
|
|
|
tscrolldown(term.top, csiescseq.arg[0]);
|
2010-03-11 17:50:50 -05:00
|
|
|
|
break;
|
2010-02-08 17:16:55 -05:00
|
|
|
|
case 'L': /* IL -- Insert <n> blank lines */
|
2012-08-29 17:14:20 -04:00
|
|
|
|
DEFAULT(csiescseq.arg[0], 1);
|
|
|
|
|
tinsertblankline(csiescseq.arg[0]);
|
2010-02-02 21:25:35 -05:00
|
|
|
|
break;
|
2010-02-08 17:16:55 -05:00
|
|
|
|
case 'l': /* RM -- Reset Mode */
|
2012-09-02 13:09:35 -04:00
|
|
|
|
tsetmode(csiescseq.priv, 0, csiescseq.arg, csiescseq.narg);
|
2010-02-02 21:25:35 -05:00
|
|
|
|
break;
|
2010-02-08 17:16:55 -05:00
|
|
|
|
case 'M': /* DL -- Delete <n> lines */
|
2012-08-29 17:14:20 -04:00
|
|
|
|
DEFAULT(csiescseq.arg[0], 1);
|
|
|
|
|
tdeleteline(csiescseq.arg[0]);
|
2010-02-02 21:25:35 -05:00
|
|
|
|
break;
|
2010-02-21 08:14:58 -05:00
|
|
|
|
case 'X': /* ECH -- Erase <n> char */
|
2012-08-29 17:14:20 -04:00
|
|
|
|
DEFAULT(csiescseq.arg[0], 1);
|
2013-01-27 11:48:01 -05:00
|
|
|
|
tclearregion(term.c.x, term.c.y,
|
2013-04-14 12:30:10 -04:00
|
|
|
|
term.c.x + csiescseq.arg[0] - 1, term.c.y);
|
2010-02-21 08:14:58 -05:00
|
|
|
|
break;
|
2010-02-08 17:16:55 -05:00
|
|
|
|
case 'P': /* DCH -- Delete <n> char */
|
2012-08-29 17:14:20 -04:00
|
|
|
|
DEFAULT(csiescseq.arg[0], 1);
|
|
|
|
|
tdeletechar(csiescseq.arg[0]);
|
2010-02-02 21:25:35 -05:00
|
|
|
|
break;
|
2012-08-30 15:17:54 -04:00
|
|
|
|
case 'Z': /* CBT -- Cursor Backward Tabulation <n> tab stops */
|
|
|
|
|
DEFAULT(csiescseq.arg[0], 1);
|
2014-04-23 15:12:45 -04:00
|
|
|
|
tputtab(-csiescseq.arg[0]);
|
2012-08-30 15:17:54 -04:00
|
|
|
|
break;
|
2010-02-08 17:16:55 -05:00
|
|
|
|
case 'd': /* VPA -- Move to <row> */
|
2012-08-29 17:14:20 -04:00
|
|
|
|
DEFAULT(csiescseq.arg[0], 1);
|
2012-11-08 11:21:10 -05:00
|
|
|
|
tmoveato(term.c.x, csiescseq.arg[0]-1);
|
2010-02-02 21:25:35 -05:00
|
|
|
|
break;
|
2010-02-08 17:16:55 -05:00
|
|
|
|
case 'h': /* SM -- Set terminal mode */
|
2012-09-02 13:09:35 -04:00
|
|
|
|
tsetmode(csiescseq.priv, 1, csiescseq.arg, csiescseq.narg);
|
2010-02-02 21:25:35 -05:00
|
|
|
|
break;
|
2010-02-08 17:16:55 -05:00
|
|
|
|
case 'm': /* SGR -- Terminal attribute (color) */
|
2012-08-29 17:14:20 -04:00
|
|
|
|
tsetattr(csiescseq.arg, csiescseq.narg);
|
2010-02-02 21:25:35 -05:00
|
|
|
|
break;
|
2013-10-01 14:01:15 -04:00
|
|
|
|
case 'n': /* DSR – Device Status Report (cursor position) */
|
|
|
|
|
if (csiescseq.arg[0] == 6) {
|
2013-10-02 15:06:50 -04:00
|
|
|
|
len = snprintf(buf, sizeof(buf),"\033[%i;%iR",
|
|
|
|
|
term.c.y+1, term.c.x+1);
|
2013-10-01 14:01:15 -04:00
|
|
|
|
ttywrite(buf, len);
|
|
|
|
|
}
|
2014-04-26 03:30:53 -04:00
|
|
|
|
break;
|
2010-02-08 17:16:55 -05:00
|
|
|
|
case 'r': /* DECSTBM -- Set Scrolling Region */
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (csiescseq.priv) {
|
2010-02-03 10:18:04 -05:00
|
|
|
|
goto unknown;
|
2012-10-06 03:58:45 -04:00
|
|
|
|
} else {
|
2012-08-29 17:14:20 -04:00
|
|
|
|
DEFAULT(csiescseq.arg[0], 1);
|
|
|
|
|
DEFAULT(csiescseq.arg[1], term.row);
|
|
|
|
|
tsetscroll(csiescseq.arg[0]-1, csiescseq.arg[1]-1);
|
2012-11-08 11:21:10 -05:00
|
|
|
|
tmoveato(0, 0);
|
2009-05-10 08:17:09 -04:00
|
|
|
|
}
|
|
|
|
|
break;
|
2010-02-08 17:16:55 -05:00
|
|
|
|
case 's': /* DECSC -- Save cursor position (ANSI.SYS) */
|
|
|
|
|
tcursor(CURSOR_SAVE);
|
2010-02-02 21:25:35 -05:00
|
|
|
|
break;
|
2010-02-08 17:16:55 -05:00
|
|
|
|
case 'u': /* DECRC -- Restore cursor position (ANSI.SYS) */
|
|
|
|
|
tcursor(CURSOR_LOAD);
|
2010-02-02 21:25:35 -05:00
|
|
|
|
break;
|
2015-03-18 16:12:47 -04:00
|
|
|
|
case ' ':
|
|
|
|
|
switch (csiescseq.mode[1]) {
|
2015-10-05 14:48:24 -04:00
|
|
|
|
case 'q': /* DECSCUSR -- Set Cursor Style */
|
|
|
|
|
DEFAULT(csiescseq.arg[0], 1);
|
|
|
|
|
if (!BETWEEN(csiescseq.arg[0], 0, 6)) {
|
2015-03-18 16:12:47 -04:00
|
|
|
|
goto unknown;
|
2015-10-05 14:48:24 -04:00
|
|
|
|
}
|
2017-01-20 03:06:39 -05:00
|
|
|
|
win.cursor = csiescseq.arg[0];
|
2015-10-05 14:48:24 -04:00
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
goto unknown;
|
2015-03-18 16:12:47 -04:00
|
|
|
|
}
|
|
|
|
|
break;
|
2009-05-10 08:17:09 -04:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
csidump(void)
|
|
|
|
|
{
|
2012-02-15 18:58:16 -05:00
|
|
|
|
int i;
|
2012-10-06 03:58:45 -04:00
|
|
|
|
uint c;
|
|
|
|
|
|
2016-11-11 11:45:52 -05:00
|
|
|
|
fprintf(stderr, "ESC[");
|
2015-07-10 04:29:53 -04:00
|
|
|
|
for (i = 0; i < csiescseq.len; i++) {
|
2012-10-06 03:58:45 -04:00
|
|
|
|
c = csiescseq.buf[i] & 0xff;
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (isprint(c)) {
|
2016-11-11 11:45:52 -05:00
|
|
|
|
putc(c, stderr);
|
2015-07-10 04:29:53 -04:00
|
|
|
|
} else if (c == '\n') {
|
2016-11-11 11:45:52 -05:00
|
|
|
|
fprintf(stderr, "(\\n)");
|
2015-07-10 04:29:53 -04:00
|
|
|
|
} else if (c == '\r') {
|
2016-11-11 11:45:52 -05:00
|
|
|
|
fprintf(stderr, "(\\r)");
|
2015-07-10 04:29:53 -04:00
|
|
|
|
} else if (c == 0x1b) {
|
2016-11-11 11:45:52 -05:00
|
|
|
|
fprintf(stderr, "(\\e)");
|
2012-10-06 03:58:45 -04:00
|
|
|
|
} else {
|
2016-11-11 11:45:52 -05:00
|
|
|
|
fprintf(stderr, "(%02x)", c);
|
2012-10-06 03:58:45 -04:00
|
|
|
|
}
|
2012-02-15 18:58:16 -05:00
|
|
|
|
}
|
2016-11-11 11:45:52 -05:00
|
|
|
|
putc('\n', stderr);
|
2009-05-10 08:17:09 -04:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
csireset(void)
|
|
|
|
|
{
|
2012-08-29 17:14:20 -04:00
|
|
|
|
memset(&csiescseq, 0, sizeof(csiescseq));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
strhandle(void)
|
|
|
|
|
{
|
2013-02-19 12:39:13 -05:00
|
|
|
|
char *p = NULL;
|
2014-01-31 11:04:18 -05:00
|
|
|
|
int j, narg, par;
|
2012-08-29 17:14:20 -04:00
|
|
|
|
|
Cancel DCS with SUB, CAN, ESC or any CC1 code
From http://www.vt100.net/docs/vt510-rm/chapter4:
*The VT510 ignores all following characters until it receives a
SUB, ST, or any other C1 control character.
So OSC, PM and APC sequence ends with a SUB (it cancels the sequence
and show a question mark as error), ST or any another C1 (8 bits)
code, or their C0 (7 bits) equivalent sequences (at this moment we
do not handle C1 codes, but we should). But it is also said that:
Cancel CAN
1/8 Immediately cancels an escape sequence, control sequence,
or device control string in progress. In this case, the
VT510 does not display any error character.
Escape ESC
1/11 Introduces an escape sequence. ESC also cancels any escape
sequence, control sequence, or device control string in
progress.
2014-04-25 19:34:46 -04:00
|
|
|
|
term.esc &= ~(ESC_STR_END|ESC_STR);
|
2012-08-30 15:19:53 -04:00
|
|
|
|
strparse();
|
2015-04-23 11:55:41 -04:00
|
|
|
|
par = (narg = strescseq.narg) ? atoi(strescseq.args[0]) : 0;
|
2012-08-29 17:14:20 -04:00
|
|
|
|
|
2015-07-10 04:29:53 -04:00
|
|
|
|
switch (strescseq.type) {
|
2012-08-29 17:14:20 -04:00
|
|
|
|
case ']': /* OSC -- Operating System Command */
|
2015-07-10 04:29:53 -04:00
|
|
|
|
switch (par) {
|
2013-02-19 12:39:13 -05:00
|
|
|
|
case 0:
|
|
|
|
|
case 1:
|
|
|
|
|
case 2:
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (narg > 1)
|
2013-02-23 15:44:06 -05:00
|
|
|
|
xsettitle(strescseq.args[1]);
|
2014-01-31 11:04:18 -05:00
|
|
|
|
return;
|
2013-02-19 12:39:13 -05:00
|
|
|
|
case 4: /* color set */
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (narg < 3)
|
2013-02-19 12:39:13 -05:00
|
|
|
|
break;
|
|
|
|
|
p = strescseq.args[2];
|
2014-04-25 10:26:54 -04:00
|
|
|
|
/* FALLTHROUGH */
|
2013-02-19 12:39:13 -05:00
|
|
|
|
case 104: /* color reset, here p = NULL */
|
2013-02-23 15:17:25 -05:00
|
|
|
|
j = (narg > 1) ? atoi(strescseq.args[1]) : -1;
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (xsetcolorname(j, p)) {
|
2013-02-19 12:39:13 -05:00
|
|
|
|
fprintf(stderr, "erresc: invalid color %s\n", p);
|
2013-02-23 15:17:25 -05:00
|
|
|
|
} else {
|
2013-02-23 15:44:06 -05:00
|
|
|
|
/*
|
|
|
|
|
* TODO if defaultbg color is changed, borders
|
|
|
|
|
* are dirty
|
|
|
|
|
*/
|
2015-02-14 18:34:03 -05:00
|
|
|
|
redraw();
|
2013-02-19 12:39:13 -05:00
|
|
|
|
}
|
2014-01-31 11:04:18 -05:00
|
|
|
|
return;
|
2012-08-29 17:14:20 -04:00
|
|
|
|
}
|
|
|
|
|
break;
|
2012-09-12 07:00:39 -04:00
|
|
|
|
case 'k': /* old title set compatibility */
|
2013-02-23 15:44:06 -05:00
|
|
|
|
xsettitle(strescseq.args[0]);
|
2014-01-31 11:04:18 -05:00
|
|
|
|
return;
|
2014-04-25 10:27:48 -04:00
|
|
|
|
case 'P': /* DCS -- Device Control String */
|
2016-09-14 02:27:32 -04:00
|
|
|
|
term.mode |= ESC_DCS;
|
2012-08-29 17:14:20 -04:00
|
|
|
|
case '_': /* APC -- Application Program Command */
|
|
|
|
|
case '^': /* PM -- Privacy Message */
|
2014-01-31 11:04:18 -05:00
|
|
|
|
return;
|
2012-08-29 17:14:20 -04:00
|
|
|
|
}
|
2014-01-31 11:04:18 -05:00
|
|
|
|
|
|
|
|
|
fprintf(stderr, "erresc: unknown str ");
|
|
|
|
|
strdump();
|
2012-08-29 17:14:20 -04:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
strparse(void)
|
|
|
|
|
{
|
2015-03-20 02:46:59 -04:00
|
|
|
|
int c;
|
2013-02-26 15:43:40 -05:00
|
|
|
|
char *p = strescseq.buf;
|
2013-02-25 07:36:40 -05:00
|
|
|
|
|
2013-02-26 15:43:40 -05:00
|
|
|
|
strescseq.narg = 0;
|
2013-02-26 12:19:44 -05:00
|
|
|
|
strescseq.buf[strescseq.len] = '\0';
|
2015-03-20 02:46:59 -04:00
|
|
|
|
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (*p == '\0')
|
2015-03-20 02:46:59 -04:00
|
|
|
|
return;
|
|
|
|
|
|
2015-07-10 04:29:53 -04:00
|
|
|
|
while (strescseq.narg < STR_ARG_SIZ) {
|
2015-03-20 02:46:59 -04:00
|
|
|
|
strescseq.args[strescseq.narg++] = p;
|
2015-07-10 04:29:53 -04:00
|
|
|
|
while ((c = *p) != ';' && c != '\0')
|
2015-03-20 02:46:59 -04:00
|
|
|
|
++p;
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (c == '\0')
|
2015-03-20 02:46:59 -04:00
|
|
|
|
return;
|
|
|
|
|
*p++ = '\0';
|
|
|
|
|
}
|
2012-08-29 17:14:20 -04:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
strdump(void)
|
|
|
|
|
{
|
2012-08-29 17:14:20 -04:00
|
|
|
|
int i;
|
2012-10-06 03:58:45 -04:00
|
|
|
|
uint c;
|
|
|
|
|
|
2016-11-11 11:45:52 -05:00
|
|
|
|
fprintf(stderr, "ESC%c", strescseq.type);
|
2015-07-10 04:29:53 -04:00
|
|
|
|
for (i = 0; i < strescseq.len; i++) {
|
2012-10-06 03:58:45 -04:00
|
|
|
|
c = strescseq.buf[i] & 0xff;
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (c == '\0') {
|
2016-11-11 11:45:52 -05:00
|
|
|
|
putc('\n', stderr);
|
2013-02-26 12:19:44 -05:00
|
|
|
|
return;
|
2015-07-10 04:29:53 -04:00
|
|
|
|
} else if (isprint(c)) {
|
2016-11-11 11:45:52 -05:00
|
|
|
|
putc(c, stderr);
|
2015-07-10 04:29:53 -04:00
|
|
|
|
} else if (c == '\n') {
|
2016-11-11 11:45:52 -05:00
|
|
|
|
fprintf(stderr, "(\\n)");
|
2015-07-10 04:29:53 -04:00
|
|
|
|
} else if (c == '\r') {
|
2016-11-11 11:45:52 -05:00
|
|
|
|
fprintf(stderr, "(\\r)");
|
2015-07-10 04:29:53 -04:00
|
|
|
|
} else if (c == 0x1b) {
|
2016-11-11 11:45:52 -05:00
|
|
|
|
fprintf(stderr, "(\\e)");
|
2012-10-06 03:58:45 -04:00
|
|
|
|
} else {
|
2016-11-11 11:45:52 -05:00
|
|
|
|
fprintf(stderr, "(%02x)", c);
|
2012-10-06 03:58:45 -04:00
|
|
|
|
}
|
2012-08-29 17:14:20 -04:00
|
|
|
|
}
|
2016-11-11 11:45:52 -05:00
|
|
|
|
fprintf(stderr, "ESC\\\n");
|
2012-08-29 17:14:20 -04:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
strreset(void)
|
|
|
|
|
{
|
2012-08-29 17:14:20 -04:00
|
|
|
|
memset(&strescseq, 0, sizeof(strescseq));
|
2009-05-10 08:17:09 -04:00
|
|
|
|
}
|
|
|
|
|
|
2015-09-08 06:10:11 -04:00
|
|
|
|
void
|
|
|
|
|
sendbreak(const Arg *arg)
|
|
|
|
|
{
|
|
|
|
|
if (tcsendbreak(cmdfd, 0))
|
|
|
|
|
perror("Error sending break");
|
|
|
|
|
}
|
|
|
|
|
|
2014-01-31 15:53:53 -05:00
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
tprinter(char *s, size_t len)
|
|
|
|
|
{
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (iofd != -1 && xwrite(iofd, s, len) < 0) {
|
2014-01-31 15:53:53 -05:00
|
|
|
|
fprintf(stderr, "Error writing in %s:%s\n",
|
|
|
|
|
opt_io, strerror(errno));
|
|
|
|
|
close(iofd);
|
|
|
|
|
iofd = -1;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2016-10-08 10:22:18 -04:00
|
|
|
|
void
|
|
|
|
|
iso14755(const Arg *arg)
|
|
|
|
|
{
|
2017-01-20 03:06:39 -05:00
|
|
|
|
unsigned long id = xwinid();
|
|
|
|
|
char cmd[sizeof(ISO14755CMD) + NUMMAXLEN(id)];
|
2016-10-08 10:22:18 -04:00
|
|
|
|
FILE *p;
|
|
|
|
|
char *us, *e, codepoint[9], uc[UTF_SIZ];
|
|
|
|
|
unsigned long utf32;
|
|
|
|
|
|
2017-01-20 03:06:39 -05:00
|
|
|
|
snprintf(cmd, sizeof(cmd), ISO14755CMD, id);
|
2016-10-08 10:22:18 -04:00
|
|
|
|
if (!(p = popen(cmd, "r")))
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
us = fgets(codepoint, sizeof(codepoint), p);
|
|
|
|
|
pclose(p);
|
|
|
|
|
|
|
|
|
|
if (!us || *us == '\0' || *us == '-' || strlen(us) > 7)
|
|
|
|
|
return;
|
|
|
|
|
if ((utf32 = strtoul(us, &e, 16)) == ULONG_MAX ||
|
|
|
|
|
(*e != '\n' && *e != '\0'))
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
ttysend(uc, utf8encode(utf32, uc));
|
|
|
|
|
}
|
|
|
|
|
|
2014-01-31 17:05:42 -05:00
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
toggleprinter(const Arg *arg)
|
|
|
|
|
{
|
2014-01-31 17:05:42 -05:00
|
|
|
|
term.mode ^= MODE_PRINT;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
printscreen(const Arg *arg)
|
|
|
|
|
{
|
2014-01-31 17:05:42 -05:00
|
|
|
|
tdump();
|
|
|
|
|
}
|
|
|
|
|
|
2014-02-01 07:41:58 -05:00
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
printsel(const Arg *arg)
|
|
|
|
|
{
|
2014-02-01 07:41:58 -05:00
|
|
|
|
tdumpsel();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
tdumpsel(void)
|
|
|
|
|
{
|
2014-02-01 07:41:58 -05:00
|
|
|
|
char *ptr;
|
|
|
|
|
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if ((ptr = getsel())) {
|
2014-03-26 18:58:27 -04:00
|
|
|
|
tprinter(ptr, strlen(ptr));
|
|
|
|
|
free(ptr);
|
|
|
|
|
}
|
2014-02-01 07:41:58 -05:00
|
|
|
|
}
|
|
|
|
|
|
2014-01-31 15:53:53 -05:00
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
tdumpline(int n)
|
|
|
|
|
{
|
2015-04-21 17:29:01 -04:00
|
|
|
|
char buf[UTF_SIZ];
|
2014-01-31 15:53:53 -05:00
|
|
|
|
Glyph *bp, *end;
|
|
|
|
|
|
|
|
|
|
bp = &term.line[n][0];
|
2014-06-27 03:15:56 -04:00
|
|
|
|
end = &bp[MIN(tlinelen(n), term.col) - 1];
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (bp != end || bp->u != ' ') {
|
|
|
|
|
for ( ;bp <= end; ++bp)
|
2015-04-21 17:29:01 -04:00
|
|
|
|
tprinter(buf, utf8encode(bp->u, buf));
|
2014-01-31 15:53:53 -05:00
|
|
|
|
}
|
|
|
|
|
tprinter("\n", 1);
|
|
|
|
|
}
|
|
|
|
|
|
2014-01-31 16:25:51 -05:00
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
tdump(void)
|
|
|
|
|
{
|
2014-01-31 16:25:51 -05:00
|
|
|
|
int i;
|
|
|
|
|
|
2015-07-10 04:29:53 -04:00
|
|
|
|
for (i = 0; i < term.row; ++i)
|
2014-01-31 16:25:51 -05:00
|
|
|
|
tdumpline(i);
|
|
|
|
|
}
|
|
|
|
|
|
2009-05-13 19:03:17 -04:00
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
tputtab(int n)
|
|
|
|
|
{
|
2012-09-19 10:03:16 -04:00
|
|
|
|
uint x = term.c.x;
|
2012-08-29 13:59:43 -04:00
|
|
|
|
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (n > 0) {
|
|
|
|
|
while (x < term.col && n--)
|
|
|
|
|
for (++x; x < term.col && !term.tabs[x]; ++x)
|
2014-04-23 15:12:45 -04:00
|
|
|
|
/* nothing */ ;
|
2015-07-10 04:29:53 -04:00
|
|
|
|
} else if (n < 0) {
|
|
|
|
|
while (x > 0 && n++)
|
|
|
|
|
for (--x; x > 0 && !term.tabs[x]; --x)
|
2014-04-23 15:12:45 -04:00
|
|
|
|
/* nothing */ ;
|
2012-08-30 15:17:54 -04:00
|
|
|
|
}
|
2015-04-13 08:03:35 -04:00
|
|
|
|
term.c.x = LIMIT(x, 0, term.col-1);
|
2009-05-13 19:03:17 -04:00
|
|
|
|
}
|
|
|
|
|
|
2012-11-13 14:04:26 -05:00
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
techo(Rune u)
|
|
|
|
|
{
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (ISCONTROL(u)) { /* control code */
|
|
|
|
|
if (u & 0x80) {
|
2015-04-21 17:29:15 -04:00
|
|
|
|
u &= 0x7f;
|
|
|
|
|
tputc('^');
|
|
|
|
|
tputc('[');
|
2015-07-10 04:29:53 -04:00
|
|
|
|
} else if (u != '\n' && u != '\r' && u != '\t') {
|
2015-04-21 17:29:15 -04:00
|
|
|
|
u ^= 0x40;
|
|
|
|
|
tputc('^');
|
2012-11-13 14:04:26 -05:00
|
|
|
|
}
|
|
|
|
|
}
|
2015-04-21 17:29:15 -04:00
|
|
|
|
tputc(u);
|
2012-11-13 14:04:26 -05:00
|
|
|
|
}
|
|
|
|
|
|
2016-09-13 08:01:18 -04:00
|
|
|
|
void
|
|
|
|
|
tdefutf8(char ascii)
|
|
|
|
|
{
|
|
|
|
|
if (ascii == 'G')
|
|
|
|
|
term.mode |= MODE_UTF8;
|
|
|
|
|
else if (ascii == '@')
|
|
|
|
|
term.mode &= ~MODE_UTF8;
|
|
|
|
|
}
|
|
|
|
|
|
Add support for multiple charset definitions
vt100 has support for two defined charset, G0 and G1. Each charset
can be defined, but in each moment is selected only one of both
charset. This is usually used selecting a national charset in G0
and graphic charset in G1, so you can switch between graphic
charset and text charset without losing the national charset
already defined.
st hasn't support for national charsets, because it is an utf8
based terminal emulator, but it has support for graphic
charset because it is heavily used, but it only supports G0,
without understanding G1 selection sequences, which causes some
programs in some moments can print some garbage in the screen.
This patch adds a fake support for multiple charset definitions,
where we only support graphic charset and us-ascii charset, but
we allow more of one charset definition.
This patch allow define G0 until G3 charsets, but only accepts
select G0 or G1, and it accepts some national charset definitions
but all of them are mapped to us-ascii.
2013-10-01 15:23:11 -04:00
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
tdeftran(char ascii)
|
|
|
|
|
{
|
2014-06-07 07:23:45 -04:00
|
|
|
|
static char cs[] = "0B";
|
|
|
|
|
static int vcs[] = {CS_GRAPHIC0, CS_USA};
|
|
|
|
|
char *p;
|
Add support for multiple charset definitions
vt100 has support for two defined charset, G0 and G1. Each charset
can be defined, but in each moment is selected only one of both
charset. This is usually used selecting a national charset in G0
and graphic charset in G1, so you can switch between graphic
charset and text charset without losing the national charset
already defined.
st hasn't support for national charsets, because it is an utf8
based terminal emulator, but it has support for graphic
charset because it is heavily used, but it only supports G0,
without understanding G1 selection sequences, which causes some
programs in some moments can print some garbage in the screen.
This patch adds a fake support for multiple charset definitions,
where we only support graphic charset and us-ascii charset, but
we allow more of one charset definition.
This patch allow define G0 until G3 charsets, but only accepts
select G0 or G1, and it accepts some national charset definitions
but all of them are mapped to us-ascii.
2013-10-01 15:23:11 -04:00
|
|
|
|
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if ((p = strchr(cs, ascii)) == NULL) {
|
Add support for multiple charset definitions
vt100 has support for two defined charset, G0 and G1. Each charset
can be defined, but in each moment is selected only one of both
charset. This is usually used selecting a national charset in G0
and graphic charset in G1, so you can switch between graphic
charset and text charset without losing the national charset
already defined.
st hasn't support for national charsets, because it is an utf8
based terminal emulator, but it has support for graphic
charset because it is heavily used, but it only supports G0,
without understanding G1 selection sequences, which causes some
programs in some moments can print some garbage in the screen.
This patch adds a fake support for multiple charset definitions,
where we only support graphic charset and us-ascii charset, but
we allow more of one charset definition.
This patch allow define G0 until G3 charsets, but only accepts
select G0 or G1, and it accepts some national charset definitions
but all of them are mapped to us-ascii.
2013-10-01 15:23:11 -04:00
|
|
|
|
fprintf(stderr, "esc unhandled charset: ESC ( %c\n", ascii);
|
2014-06-07 07:49:04 -04:00
|
|
|
|
} else {
|
2014-06-07 07:23:45 -04:00
|
|
|
|
term.trantbl[term.icharset] = vcs[p - cs];
|
2014-06-07 07:49:04 -04:00
|
|
|
|
}
|
Add support for multiple charset definitions
vt100 has support for two defined charset, G0 and G1. Each charset
can be defined, but in each moment is selected only one of both
charset. This is usually used selecting a national charset in G0
and graphic charset in G1, so you can switch between graphic
charset and text charset without losing the national charset
already defined.
st hasn't support for national charsets, because it is an utf8
based terminal emulator, but it has support for graphic
charset because it is heavily used, but it only supports G0,
without understanding G1 selection sequences, which causes some
programs in some moments can print some garbage in the screen.
This patch adds a fake support for multiple charset definitions,
where we only support graphic charset and us-ascii charset, but
we allow more of one charset definition.
This patch allow define G0 until G3 charsets, but only accepts
select G0 or G1, and it accepts some national charset definitions
but all of them are mapped to us-ascii.
2013-10-01 15:23:11 -04:00
|
|
|
|
}
|
|
|
|
|
|
2014-08-20 03:56:24 -04:00
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
tdectest(char c)
|
|
|
|
|
{
|
2014-08-20 03:56:24 -04:00
|
|
|
|
int x, y;
|
|
|
|
|
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (c == '8') { /* DEC screen alignment test. */
|
|
|
|
|
for (x = 0; x < term.col; ++x) {
|
|
|
|
|
for (y = 0; y < term.row; ++y)
|
2015-04-21 17:29:15 -04:00
|
|
|
|
tsetchar('E', &term.c.attr, x, y);
|
2014-08-20 03:56:24 -04:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2014-06-20 03:51:18 -04:00
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
tstrsequence(uchar c)
|
|
|
|
|
{
|
2016-09-14 02:27:32 -04:00
|
|
|
|
strreset();
|
|
|
|
|
|
2015-04-13 08:34:23 -04:00
|
|
|
|
switch (c) {
|
|
|
|
|
case 0x90: /* DCS -- Device Control String */
|
|
|
|
|
c = 'P';
|
2016-09-14 02:27:32 -04:00
|
|
|
|
term.esc |= ESC_DCS;
|
2015-04-13 08:34:23 -04:00
|
|
|
|
break;
|
|
|
|
|
case 0x9f: /* APC -- Application Program Command */
|
|
|
|
|
c = '_';
|
|
|
|
|
break;
|
|
|
|
|
case 0x9e: /* PM -- Privacy Message */
|
|
|
|
|
c = '^';
|
|
|
|
|
break;
|
|
|
|
|
case 0x9d: /* OSC -- Operating System Command */
|
|
|
|
|
c = ']';
|
|
|
|
|
break;
|
2014-06-20 03:51:18 -04:00
|
|
|
|
}
|
|
|
|
|
strescseq.type = c;
|
|
|
|
|
term.esc |= ESC_STR;
|
|
|
|
|
}
|
|
|
|
|
|
2014-04-29 03:58:55 -04:00
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
tcontrolcode(uchar ascii)
|
|
|
|
|
{
|
2015-07-10 04:29:53 -04:00
|
|
|
|
switch (ascii) {
|
Cancel DCS with SUB, CAN, ESC or any CC1 code
From http://www.vt100.net/docs/vt510-rm/chapter4:
*The VT510 ignores all following characters until it receives a
SUB, ST, or any other C1 control character.
So OSC, PM and APC sequence ends with a SUB (it cancels the sequence
and show a question mark as error), ST or any another C1 (8 bits)
code, or their C0 (7 bits) equivalent sequences (at this moment we
do not handle C1 codes, but we should). But it is also said that:
Cancel CAN
1/8 Immediately cancels an escape sequence, control sequence,
or device control string in progress. In this case, the
VT510 does not display any error character.
Escape ESC
1/11 Introduces an escape sequence. ESC also cancels any escape
sequence, control sequence, or device control string in
progress.
2014-04-25 19:34:46 -04:00
|
|
|
|
case '\t': /* HT */
|
|
|
|
|
tputtab(1);
|
2014-05-09 04:23:53 -04:00
|
|
|
|
return;
|
Cancel DCS with SUB, CAN, ESC or any CC1 code
From http://www.vt100.net/docs/vt510-rm/chapter4:
*The VT510 ignores all following characters until it receives a
SUB, ST, or any other C1 control character.
So OSC, PM and APC sequence ends with a SUB (it cancels the sequence
and show a question mark as error), ST or any another C1 (8 bits)
code, or their C0 (7 bits) equivalent sequences (at this moment we
do not handle C1 codes, but we should). But it is also said that:
Cancel CAN
1/8 Immediately cancels an escape sequence, control sequence,
or device control string in progress. In this case, the
VT510 does not display any error character.
Escape ESC
1/11 Introduces an escape sequence. ESC also cancels any escape
sequence, control sequence, or device control string in
progress.
2014-04-25 19:34:46 -04:00
|
|
|
|
case '\b': /* BS */
|
|
|
|
|
tmoveto(term.c.x-1, term.c.y);
|
2014-05-09 04:23:53 -04:00
|
|
|
|
return;
|
Cancel DCS with SUB, CAN, ESC or any CC1 code
From http://www.vt100.net/docs/vt510-rm/chapter4:
*The VT510 ignores all following characters until it receives a
SUB, ST, or any other C1 control character.
So OSC, PM and APC sequence ends with a SUB (it cancels the sequence
and show a question mark as error), ST or any another C1 (8 bits)
code, or their C0 (7 bits) equivalent sequences (at this moment we
do not handle C1 codes, but we should). But it is also said that:
Cancel CAN
1/8 Immediately cancels an escape sequence, control sequence,
or device control string in progress. In this case, the
VT510 does not display any error character.
Escape ESC
1/11 Introduces an escape sequence. ESC also cancels any escape
sequence, control sequence, or device control string in
progress.
2014-04-25 19:34:46 -04:00
|
|
|
|
case '\r': /* CR */
|
|
|
|
|
tmoveto(0, term.c.y);
|
2014-05-09 04:23:53 -04:00
|
|
|
|
return;
|
Cancel DCS with SUB, CAN, ESC or any CC1 code
From http://www.vt100.net/docs/vt510-rm/chapter4:
*The VT510 ignores all following characters until it receives a
SUB, ST, or any other C1 control character.
So OSC, PM and APC sequence ends with a SUB (it cancels the sequence
and show a question mark as error), ST or any another C1 (8 bits)
code, or their C0 (7 bits) equivalent sequences (at this moment we
do not handle C1 codes, but we should). But it is also said that:
Cancel CAN
1/8 Immediately cancels an escape sequence, control sequence,
or device control string in progress. In this case, the
VT510 does not display any error character.
Escape ESC
1/11 Introduces an escape sequence. ESC also cancels any escape
sequence, control sequence, or device control string in
progress.
2014-04-25 19:34:46 -04:00
|
|
|
|
case '\f': /* LF */
|
|
|
|
|
case '\v': /* VT */
|
|
|
|
|
case '\n': /* LF */
|
|
|
|
|
/* go to first col if the mode is set */
|
|
|
|
|
tnewline(IS_SET(MODE_CRLF));
|
2014-05-09 04:23:53 -04:00
|
|
|
|
return;
|
Cancel DCS with SUB, CAN, ESC or any CC1 code
From http://www.vt100.net/docs/vt510-rm/chapter4:
*The VT510 ignores all following characters until it receives a
SUB, ST, or any other C1 control character.
So OSC, PM and APC sequence ends with a SUB (it cancels the sequence
and show a question mark as error), ST or any another C1 (8 bits)
code, or their C0 (7 bits) equivalent sequences (at this moment we
do not handle C1 codes, but we should). But it is also said that:
Cancel CAN
1/8 Immediately cancels an escape sequence, control sequence,
or device control string in progress. In this case, the
VT510 does not display any error character.
Escape ESC
1/11 Introduces an escape sequence. ESC also cancels any escape
sequence, control sequence, or device control string in
progress.
2014-04-25 19:34:46 -04:00
|
|
|
|
case '\a': /* BEL */
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (term.esc & ESC_STR_END) {
|
Cancel DCS with SUB, CAN, ESC or any CC1 code
From http://www.vt100.net/docs/vt510-rm/chapter4:
*The VT510 ignores all following characters until it receives a
SUB, ST, or any other C1 control character.
So OSC, PM and APC sequence ends with a SUB (it cancels the sequence
and show a question mark as error), ST or any another C1 (8 bits)
code, or their C0 (7 bits) equivalent sequences (at this moment we
do not handle C1 codes, but we should). But it is also said that:
Cancel CAN
1/8 Immediately cancels an escape sequence, control sequence,
or device control string in progress. In this case, the
VT510 does not display any error character.
Escape ESC
1/11 Introduces an escape sequence. ESC also cancels any escape
sequence, control sequence, or device control string in
progress.
2014-04-25 19:34:46 -04:00
|
|
|
|
/* backwards compatibility to xterm */
|
|
|
|
|
strhandle();
|
|
|
|
|
} else {
|
2017-01-20 03:06:39 -05:00
|
|
|
|
if (!(win.state & WIN_FOCUSED))
|
Cancel DCS with SUB, CAN, ESC or any CC1 code
From http://www.vt100.net/docs/vt510-rm/chapter4:
*The VT510 ignores all following characters until it receives a
SUB, ST, or any other C1 control character.
So OSC, PM and APC sequence ends with a SUB (it cancels the sequence
and show a question mark as error), ST or any another C1 (8 bits)
code, or their C0 (7 bits) equivalent sequences (at this moment we
do not handle C1 codes, but we should). But it is also said that:
Cancel CAN
1/8 Immediately cancels an escape sequence, control sequence,
or device control string in progress. In this case, the
VT510 does not display any error character.
Escape ESC
1/11 Introduces an escape sequence. ESC also cancels any escape
sequence, control sequence, or device control string in
progress.
2014-04-25 19:34:46 -04:00
|
|
|
|
xseturgency(1);
|
|
|
|
|
if (bellvolume)
|
2017-01-20 03:06:39 -05:00
|
|
|
|
xbell(bellvolume);
|
Cancel DCS with SUB, CAN, ESC or any CC1 code
From http://www.vt100.net/docs/vt510-rm/chapter4:
*The VT510 ignores all following characters until it receives a
SUB, ST, or any other C1 control character.
So OSC, PM and APC sequence ends with a SUB (it cancels the sequence
and show a question mark as error), ST or any another C1 (8 bits)
code, or their C0 (7 bits) equivalent sequences (at this moment we
do not handle C1 codes, but we should). But it is also said that:
Cancel CAN
1/8 Immediately cancels an escape sequence, control sequence,
or device control string in progress. In this case, the
VT510 does not display any error character.
Escape ESC
1/11 Introduces an escape sequence. ESC also cancels any escape
sequence, control sequence, or device control string in
progress.
2014-04-25 19:34:46 -04:00
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case '\033': /* ESC */
|
|
|
|
|
csireset();
|
|
|
|
|
term.esc &= ~(ESC_CSI|ESC_ALTCHARSET|ESC_TEST);
|
|
|
|
|
term.esc |= ESC_START;
|
2014-04-29 03:58:55 -04:00
|
|
|
|
return;
|
2014-10-08 04:30:20 -04:00
|
|
|
|
case '\016': /* SO (LS1 -- Locking shift 1) */
|
|
|
|
|
case '\017': /* SI (LS0 -- Locking shift 0) */
|
|
|
|
|
term.charset = 1 - (ascii - '\016');
|
2014-05-09 04:23:53 -04:00
|
|
|
|
return;
|
Cancel DCS with SUB, CAN, ESC or any CC1 code
From http://www.vt100.net/docs/vt510-rm/chapter4:
*The VT510 ignores all following characters until it receives a
SUB, ST, or any other C1 control character.
So OSC, PM and APC sequence ends with a SUB (it cancels the sequence
and show a question mark as error), ST or any another C1 (8 bits)
code, or their C0 (7 bits) equivalent sequences (at this moment we
do not handle C1 codes, but we should). But it is also said that:
Cancel CAN
1/8 Immediately cancels an escape sequence, control sequence,
or device control string in progress. In this case, the
VT510 does not display any error character.
Escape ESC
1/11 Introduces an escape sequence. ESC also cancels any escape
sequence, control sequence, or device control string in
progress.
2014-04-25 19:34:46 -04:00
|
|
|
|
case '\032': /* SUB */
|
2015-04-21 17:29:15 -04:00
|
|
|
|
tsetchar('?', &term.c.attr, term.c.x, term.c.y);
|
Cancel DCS with SUB, CAN, ESC or any CC1 code
From http://www.vt100.net/docs/vt510-rm/chapter4:
*The VT510 ignores all following characters until it receives a
SUB, ST, or any other C1 control character.
So OSC, PM and APC sequence ends with a SUB (it cancels the sequence
and show a question mark as error), ST or any another C1 (8 bits)
code, or their C0 (7 bits) equivalent sequences (at this moment we
do not handle C1 codes, but we should). But it is also said that:
Cancel CAN
1/8 Immediately cancels an escape sequence, control sequence,
or device control string in progress. In this case, the
VT510 does not display any error character.
Escape ESC
1/11 Introduces an escape sequence. ESC also cancels any escape
sequence, control sequence, or device control string in
progress.
2014-04-25 19:34:46 -04:00
|
|
|
|
case '\030': /* CAN */
|
|
|
|
|
csireset();
|
|
|
|
|
break;
|
|
|
|
|
case '\005': /* ENQ (IGNORED) */
|
|
|
|
|
case '\000': /* NUL (IGNORED) */
|
|
|
|
|
case '\021': /* XON (IGNORED) */
|
|
|
|
|
case '\023': /* XOFF (IGNORED) */
|
|
|
|
|
case 0177: /* DEL (IGNORED) */
|
2014-05-09 04:23:53 -04:00
|
|
|
|
return;
|
2015-08-31 09:26:21 -04:00
|
|
|
|
case 0x80: /* TODO: PAD */
|
|
|
|
|
case 0x81: /* TODO: HOP */
|
|
|
|
|
case 0x82: /* TODO: BPH */
|
|
|
|
|
case 0x83: /* TODO: NBH */
|
Cancel DCS with SUB, CAN, ESC or any CC1 code
From http://www.vt100.net/docs/vt510-rm/chapter4:
*The VT510 ignores all following characters until it receives a
SUB, ST, or any other C1 control character.
So OSC, PM and APC sequence ends with a SUB (it cancels the sequence
and show a question mark as error), ST or any another C1 (8 bits)
code, or their C0 (7 bits) equivalent sequences (at this moment we
do not handle C1 codes, but we should). But it is also said that:
Cancel CAN
1/8 Immediately cancels an escape sequence, control sequence,
or device control string in progress. In this case, the
VT510 does not display any error character.
Escape ESC
1/11 Introduces an escape sequence. ESC also cancels any escape
sequence, control sequence, or device control string in
progress.
2014-04-25 19:34:46 -04:00
|
|
|
|
case 0x84: /* TODO: IND */
|
2014-06-20 03:51:18 -04:00
|
|
|
|
break;
|
|
|
|
|
case 0x85: /* NEL -- Next line */
|
|
|
|
|
tnewline(1); /* always go to first col */
|
|
|
|
|
break;
|
2015-08-31 09:26:21 -04:00
|
|
|
|
case 0x86: /* TODO: SSA */
|
|
|
|
|
case 0x87: /* TODO: ESA */
|
|
|
|
|
break;
|
2014-06-20 03:51:18 -04:00
|
|
|
|
case 0x88: /* HTS -- Horizontal tab stop */
|
|
|
|
|
term.tabs[term.c.x] = 1;
|
|
|
|
|
break;
|
2015-08-31 09:26:21 -04:00
|
|
|
|
case 0x89: /* TODO: HTJ */
|
|
|
|
|
case 0x8a: /* TODO: VTS */
|
|
|
|
|
case 0x8b: /* TODO: PLD */
|
|
|
|
|
case 0x8c: /* TODO: PLU */
|
Cancel DCS with SUB, CAN, ESC or any CC1 code
From http://www.vt100.net/docs/vt510-rm/chapter4:
*The VT510 ignores all following characters until it receives a
SUB, ST, or any other C1 control character.
So OSC, PM and APC sequence ends with a SUB (it cancels the sequence
and show a question mark as error), ST or any another C1 (8 bits)
code, or their C0 (7 bits) equivalent sequences (at this moment we
do not handle C1 codes, but we should). But it is also said that:
Cancel CAN
1/8 Immediately cancels an escape sequence, control sequence,
or device control string in progress. In this case, the
VT510 does not display any error character.
Escape ESC
1/11 Introduces an escape sequence. ESC also cancels any escape
sequence, control sequence, or device control string in
progress.
2014-04-25 19:34:46 -04:00
|
|
|
|
case 0x8d: /* TODO: RI */
|
|
|
|
|
case 0x8e: /* TODO: SS2 */
|
|
|
|
|
case 0x8f: /* TODO: SS3 */
|
2015-08-31 09:26:21 -04:00
|
|
|
|
case 0x91: /* TODO: PU1 */
|
|
|
|
|
case 0x92: /* TODO: PU2 */
|
|
|
|
|
case 0x93: /* TODO: STS */
|
|
|
|
|
case 0x94: /* TODO: CCH */
|
|
|
|
|
case 0x95: /* TODO: MW */
|
|
|
|
|
case 0x96: /* TODO: SPA */
|
|
|
|
|
case 0x97: /* TODO: EPA */
|
Cancel DCS with SUB, CAN, ESC or any CC1 code
From http://www.vt100.net/docs/vt510-rm/chapter4:
*The VT510 ignores all following characters until it receives a
SUB, ST, or any other C1 control character.
So OSC, PM and APC sequence ends with a SUB (it cancels the sequence
and show a question mark as error), ST or any another C1 (8 bits)
code, or their C0 (7 bits) equivalent sequences (at this moment we
do not handle C1 codes, but we should). But it is also said that:
Cancel CAN
1/8 Immediately cancels an escape sequence, control sequence,
or device control string in progress. In this case, the
VT510 does not display any error character.
Escape ESC
1/11 Introduces an escape sequence. ESC also cancels any escape
sequence, control sequence, or device control string in
progress.
2014-04-25 19:34:46 -04:00
|
|
|
|
case 0x98: /* TODO: SOS */
|
2015-08-31 09:26:21 -04:00
|
|
|
|
case 0x99: /* TODO: SGCI */
|
2014-06-20 03:51:18 -04:00
|
|
|
|
break;
|
|
|
|
|
case 0x9a: /* DECID -- Identify Terminal */
|
2014-08-15 09:00:48 -04:00
|
|
|
|
ttywrite(vtiden, sizeof(vtiden) - 1);
|
2014-06-20 03:51:18 -04:00
|
|
|
|
break;
|
Cancel DCS with SUB, CAN, ESC or any CC1 code
From http://www.vt100.net/docs/vt510-rm/chapter4:
*The VT510 ignores all following characters until it receives a
SUB, ST, or any other C1 control character.
So OSC, PM and APC sequence ends with a SUB (it cancels the sequence
and show a question mark as error), ST or any another C1 (8 bits)
code, or their C0 (7 bits) equivalent sequences (at this moment we
do not handle C1 codes, but we should). But it is also said that:
Cancel CAN
1/8 Immediately cancels an escape sequence, control sequence,
or device control string in progress. In this case, the
VT510 does not display any error character.
Escape ESC
1/11 Introduces an escape sequence. ESC also cancels any escape
sequence, control sequence, or device control string in
progress.
2014-04-25 19:34:46 -04:00
|
|
|
|
case 0x9b: /* TODO: CSI */
|
|
|
|
|
case 0x9c: /* TODO: ST */
|
|
|
|
|
break;
|
2014-06-20 03:51:18 -04:00
|
|
|
|
case 0x90: /* DCS -- Device Control String */
|
|
|
|
|
case 0x9d: /* OSC -- Operating System Command */
|
2015-08-31 09:26:21 -04:00
|
|
|
|
case 0x9e: /* PM -- Privacy Message */
|
|
|
|
|
case 0x9f: /* APC -- Application Program Command */
|
2014-06-20 03:51:18 -04:00
|
|
|
|
tstrsequence(ascii);
|
|
|
|
|
return;
|
Cancel DCS with SUB, CAN, ESC or any CC1 code
From http://www.vt100.net/docs/vt510-rm/chapter4:
*The VT510 ignores all following characters until it receives a
SUB, ST, or any other C1 control character.
So OSC, PM and APC sequence ends with a SUB (it cancels the sequence
and show a question mark as error), ST or any another C1 (8 bits)
code, or their C0 (7 bits) equivalent sequences (at this moment we
do not handle C1 codes, but we should). But it is also said that:
Cancel CAN
1/8 Immediately cancels an escape sequence, control sequence,
or device control string in progress. In this case, the
VT510 does not display any error character.
Escape ESC
1/11 Introduces an escape sequence. ESC also cancels any escape
sequence, control sequence, or device control string in
progress.
2014-04-25 19:34:46 -04:00
|
|
|
|
}
|
2014-05-09 04:23:53 -04:00
|
|
|
|
/* only CAN, SUB, \a and C1 chars interrupt a sequence */
|
Cancel DCS with SUB, CAN, ESC or any CC1 code
From http://www.vt100.net/docs/vt510-rm/chapter4:
*The VT510 ignores all following characters until it receives a
SUB, ST, or any other C1 control character.
So OSC, PM and APC sequence ends with a SUB (it cancels the sequence
and show a question mark as error), ST or any another C1 (8 bits)
code, or their C0 (7 bits) equivalent sequences (at this moment we
do not handle C1 codes, but we should). But it is also said that:
Cancel CAN
1/8 Immediately cancels an escape sequence, control sequence,
or device control string in progress. In this case, the
VT510 does not display any error character.
Escape ESC
1/11 Introduces an escape sequence. ESC also cancels any escape
sequence, control sequence, or device control string in
progress.
2014-04-25 19:34:46 -04:00
|
|
|
|
term.esc &= ~(ESC_STR_END|ESC_STR);
|
|
|
|
|
}
|
|
|
|
|
|
2014-08-20 03:56:24 -04:00
|
|
|
|
/*
|
|
|
|
|
* returns 1 when the sequence is finished and it hasn't to read
|
|
|
|
|
* more characters for this sequence, otherwise 0
|
|
|
|
|
*/
|
|
|
|
|
int
|
2015-07-09 17:59:50 -04:00
|
|
|
|
eschandle(uchar ascii)
|
|
|
|
|
{
|
2015-07-10 04:29:53 -04:00
|
|
|
|
switch (ascii) {
|
2014-08-20 03:56:24 -04:00
|
|
|
|
case '[':
|
|
|
|
|
term.esc |= ESC_CSI;
|
|
|
|
|
return 0;
|
|
|
|
|
case '#':
|
|
|
|
|
term.esc |= ESC_TEST;
|
|
|
|
|
return 0;
|
2016-09-13 08:01:18 -04:00
|
|
|
|
case '%':
|
|
|
|
|
term.esc |= ESC_UTF8;
|
|
|
|
|
return 0;
|
2014-08-20 03:56:24 -04:00
|
|
|
|
case 'P': /* DCS -- Device Control String */
|
|
|
|
|
case '_': /* APC -- Application Program Command */
|
|
|
|
|
case '^': /* PM -- Privacy Message */
|
|
|
|
|
case ']': /* OSC -- Operating System Command */
|
|
|
|
|
case 'k': /* old title set compatibility */
|
|
|
|
|
tstrsequence(ascii);
|
|
|
|
|
return 0;
|
2014-10-08 05:33:36 -04:00
|
|
|
|
case 'n': /* LS2 -- Locking shift 2 */
|
|
|
|
|
case 'o': /* LS3 -- Locking shift 3 */
|
|
|
|
|
term.charset = 2 + (ascii - 'n');
|
|
|
|
|
break;
|
2014-08-20 04:41:41 -04:00
|
|
|
|
case '(': /* GZD4 -- set primary charset G0 */
|
|
|
|
|
case ')': /* G1D4 -- set secondary charset G1 */
|
|
|
|
|
case '*': /* G2D4 -- set tertiary charset G2 */
|
|
|
|
|
case '+': /* G3D4 -- set quaternary charset G3 */
|
2014-08-20 03:56:24 -04:00
|
|
|
|
term.icharset = ascii - '(';
|
|
|
|
|
term.esc |= ESC_ALTCHARSET;
|
|
|
|
|
return 0;
|
|
|
|
|
case 'D': /* IND -- Linefeed */
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (term.c.y == term.bot) {
|
2014-08-20 03:56:24 -04:00
|
|
|
|
tscrollup(term.top, 1);
|
|
|
|
|
} else {
|
|
|
|
|
tmoveto(term.c.x, term.c.y+1);
|
2014-04-26 03:24:04 -04:00
|
|
|
|
}
|
2014-08-20 03:56:24 -04:00
|
|
|
|
break;
|
|
|
|
|
case 'E': /* NEL -- Next line */
|
|
|
|
|
tnewline(1); /* always go to first col */
|
|
|
|
|
break;
|
|
|
|
|
case 'H': /* HTS -- Horizontal tab stop */
|
|
|
|
|
term.tabs[term.c.x] = 1;
|
|
|
|
|
break;
|
|
|
|
|
case 'M': /* RI -- Reverse index */
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (term.c.y == term.top) {
|
2014-08-20 03:56:24 -04:00
|
|
|
|
tscrolldown(term.top, 1);
|
|
|
|
|
} else {
|
|
|
|
|
tmoveto(term.c.x, term.c.y-1);
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case 'Z': /* DECID -- Identify Terminal */
|
|
|
|
|
ttywrite(vtiden, sizeof(vtiden) - 1);
|
|
|
|
|
break;
|
|
|
|
|
case 'c': /* RIS -- Reset to inital state */
|
|
|
|
|
treset();
|
2017-01-20 03:06:39 -05:00
|
|
|
|
resettitle();
|
2014-08-20 03:56:24 -04:00
|
|
|
|
xloadcols();
|
|
|
|
|
break;
|
|
|
|
|
case '=': /* DECPAM -- Application keypad */
|
|
|
|
|
term.mode |= MODE_APPKEYPAD;
|
|
|
|
|
break;
|
|
|
|
|
case '>': /* DECPNM -- Normal keypad */
|
|
|
|
|
term.mode &= ~MODE_APPKEYPAD;
|
|
|
|
|
break;
|
|
|
|
|
case '7': /* DECSC -- Save Cursor */
|
|
|
|
|
tcursor(CURSOR_SAVE);
|
|
|
|
|
break;
|
|
|
|
|
case '8': /* DECRC -- Restore Cursor */
|
|
|
|
|
tcursor(CURSOR_LOAD);
|
|
|
|
|
break;
|
|
|
|
|
case '\\': /* ST -- String Terminator */
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (term.esc & ESC_STR_END)
|
2014-08-20 03:56:24 -04:00
|
|
|
|
strhandle();
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
fprintf(stderr, "erresc: unknown sequence ESC 0x%02X '%c'\n",
|
|
|
|
|
(uchar) ascii, isprint(ascii)? ascii:'.');
|
|
|
|
|
break;
|
2014-04-26 03:24:04 -04:00
|
|
|
|
}
|
2014-08-20 03:56:24 -04:00
|
|
|
|
return 1;
|
2014-04-26 03:24:04 -04:00
|
|
|
|
}
|
|
|
|
|
|
2009-05-10 08:17:09 -04:00
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
tputc(Rune u)
|
|
|
|
|
{
|
2015-04-21 17:29:15 -04:00
|
|
|
|
char c[UTF_SIZ];
|
2015-07-08 17:56:55 -04:00
|
|
|
|
int control;
|
2015-04-21 17:29:15 -04:00
|
|
|
|
int width, len;
|
2014-04-27 04:25:15 -04:00
|
|
|
|
Glyph *gp;
|
2013-09-07 06:41:36 -04:00
|
|
|
|
|
2015-08-17 05:25:38 -04:00
|
|
|
|
control = ISCONTROL(u);
|
2016-09-14 02:27:32 -04:00
|
|
|
|
if (!IS_SET(MODE_UTF8) && !IS_SET(MODE_SIXEL)) {
|
2016-09-13 08:01:18 -04:00
|
|
|
|
c[0] = u;
|
|
|
|
|
width = len = 1;
|
|
|
|
|
} else {
|
|
|
|
|
len = utf8encode(u, c);
|
|
|
|
|
if (!control && (width = wcwidth(u)) == -1) {
|
|
|
|
|
memcpy(c, "\357\277\275", 4); /* UTF_INVALID */
|
|
|
|
|
width = 1;
|
|
|
|
|
}
|
2013-09-07 06:41:36 -04:00
|
|
|
|
}
|
2012-09-03 15:52:21 -04:00
|
|
|
|
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (IS_SET(MODE_PRINT))
|
2014-01-31 15:53:53 -05:00
|
|
|
|
tprinter(c, len);
|
2013-01-18 13:11:25 -05:00
|
|
|
|
|
2012-10-06 13:15:30 -04:00
|
|
|
|
/*
|
Cancel DCS with SUB, CAN, ESC or any CC1 code
From http://www.vt100.net/docs/vt510-rm/chapter4:
*The VT510 ignores all following characters until it receives a
SUB, ST, or any other C1 control character.
So OSC, PM and APC sequence ends with a SUB (it cancels the sequence
and show a question mark as error), ST or any another C1 (8 bits)
code, or their C0 (7 bits) equivalent sequences (at this moment we
do not handle C1 codes, but we should). But it is also said that:
Cancel CAN
1/8 Immediately cancels an escape sequence, control sequence,
or device control string in progress. In this case, the
VT510 does not display any error character.
Escape ESC
1/11 Introduces an escape sequence. ESC also cancels any escape
sequence, control sequence, or device control string in
progress.
2014-04-25 19:34:46 -04:00
|
|
|
|
* STR sequence must be checked before anything else
|
|
|
|
|
* because it uses all following characters until it
|
|
|
|
|
* receives a ESC, a SUB, a ST or any other C1 control
|
|
|
|
|
* character.
|
2012-10-06 13:15:30 -04:00
|
|
|
|
*/
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (term.esc & ESC_STR) {
|
|
|
|
|
if (u == '\a' || u == 030 || u == 032 || u == 033 ||
|
2015-04-21 17:29:15 -04:00
|
|
|
|
ISCONTROLC1(u)) {
|
2016-09-14 02:27:32 -04:00
|
|
|
|
term.esc &= ~(ESC_START|ESC_STR|ESC_DCS);
|
|
|
|
|
if (IS_SET(MODE_SIXEL)) {
|
|
|
|
|
/* TODO: render sixel */;
|
|
|
|
|
term.mode &= ~MODE_SIXEL;
|
|
|
|
|
return;
|
|
|
|
|
}
|
Cancel DCS with SUB, CAN, ESC or any CC1 code
From http://www.vt100.net/docs/vt510-rm/chapter4:
*The VT510 ignores all following characters until it receives a
SUB, ST, or any other C1 control character.
So OSC, PM and APC sequence ends with a SUB (it cancels the sequence
and show a question mark as error), ST or any another C1 (8 bits)
code, or their C0 (7 bits) equivalent sequences (at this moment we
do not handle C1 codes, but we should). But it is also said that:
Cancel CAN
1/8 Immediately cancels an escape sequence, control sequence,
or device control string in progress. In this case, the
VT510 does not display any error character.
Escape ESC
1/11 Introduces an escape sequence. ESC also cancels any escape
sequence, control sequence, or device control string in
progress.
2014-04-25 19:34:46 -04:00
|
|
|
|
term.esc |= ESC_STR_END;
|
2016-09-14 02:27:32 -04:00
|
|
|
|
goto check_control_code;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if (IS_SET(MODE_SIXEL)) {
|
|
|
|
|
/* TODO: implement sixel mode */
|
Cancel DCS with SUB, CAN, ESC or any CC1 code
From http://www.vt100.net/docs/vt510-rm/chapter4:
*The VT510 ignores all following characters until it receives a
SUB, ST, or any other C1 control character.
So OSC, PM and APC sequence ends with a SUB (it cancels the sequence
and show a question mark as error), ST or any another C1 (8 bits)
code, or their C0 (7 bits) equivalent sequences (at this moment we
do not handle C1 codes, but we should). But it is also said that:
Cancel CAN
1/8 Immediately cancels an escape sequence, control sequence,
or device control string in progress. In this case, the
VT510 does not display any error character.
Escape ESC
1/11 Introduces an escape sequence. ESC also cancels any escape
sequence, control sequence, or device control string in
progress.
2014-04-25 19:34:46 -04:00
|
|
|
|
return;
|
2016-09-14 02:27:32 -04:00
|
|
|
|
}
|
|
|
|
|
if (term.esc&ESC_DCS && strescseq.len == 0 && u == 'q')
|
|
|
|
|
term.mode |= MODE_SIXEL;
|
|
|
|
|
|
|
|
|
|
if (strescseq.len+len >= sizeof(strescseq.buf)-1) {
|
|
|
|
|
/*
|
|
|
|
|
* Here is a bug in terminals. If the user never sends
|
|
|
|
|
* some code to stop the str or esc command, then st
|
|
|
|
|
* will stop responding. But this is better than
|
|
|
|
|
* silently failing with unknown characters. At least
|
|
|
|
|
* then users will report back.
|
|
|
|
|
*
|
|
|
|
|
* In the case users ever get fixed, here is the code:
|
|
|
|
|
*/
|
|
|
|
|
/*
|
|
|
|
|
* term.esc = 0;
|
|
|
|
|
* strhandle();
|
|
|
|
|
*/
|
Cancel DCS with SUB, CAN, ESC or any CC1 code
From http://www.vt100.net/docs/vt510-rm/chapter4:
*The VT510 ignores all following characters until it receives a
SUB, ST, or any other C1 control character.
So OSC, PM and APC sequence ends with a SUB (it cancels the sequence
and show a question mark as error), ST or any another C1 (8 bits)
code, or their C0 (7 bits) equivalent sequences (at this moment we
do not handle C1 codes, but we should). But it is also said that:
Cancel CAN
1/8 Immediately cancels an escape sequence, control sequence,
or device control string in progress. In this case, the
VT510 does not display any error character.
Escape ESC
1/11 Introduces an escape sequence. ESC also cancels any escape
sequence, control sequence, or device control string in
progress.
2014-04-25 19:34:46 -04:00
|
|
|
|
return;
|
2012-10-06 13:15:30 -04:00
|
|
|
|
}
|
2016-09-14 02:27:32 -04:00
|
|
|
|
|
|
|
|
|
memmove(&strescseq.buf[strescseq.len], c, len);
|
|
|
|
|
strescseq.len += len;
|
|
|
|
|
return;
|
2012-09-26 14:55:18 -04:00
|
|
|
|
}
|
2012-11-06 17:44:37 -05:00
|
|
|
|
|
2016-09-14 02:27:32 -04:00
|
|
|
|
check_control_code:
|
2012-10-06 13:15:30 -04:00
|
|
|
|
/*
|
|
|
|
|
* Actions of control codes must be performed as soon they arrive
|
|
|
|
|
* because they can be embedded inside a control sequence, and
|
|
|
|
|
* they must not cause conflicts with sequences.
|
|
|
|
|
*/
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (control) {
|
2015-04-21 17:29:15 -04:00
|
|
|
|
tcontrolcode(u);
|
2014-04-29 03:58:55 -04:00
|
|
|
|
/*
|
|
|
|
|
* control codes are not shown ever
|
|
|
|
|
*/
|
|
|
|
|
return;
|
2015-07-10 04:29:53 -04:00
|
|
|
|
} else if (term.esc & ESC_START) {
|
|
|
|
|
if (term.esc & ESC_CSI) {
|
2015-04-21 17:29:15 -04:00
|
|
|
|
csiescseq.buf[csiescseq.len++] = u;
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (BETWEEN(u, 0x40, 0x7E)
|
2013-02-26 15:43:40 -05:00
|
|
|
|
|| csiescseq.len >= \
|
|
|
|
|
sizeof(csiescseq.buf)-1) {
|
2010-02-02 21:25:35 -05:00
|
|
|
|
term.esc = 0;
|
2013-02-25 07:23:56 -05:00
|
|
|
|
csiparse();
|
|
|
|
|
csihandle();
|
2010-02-02 21:25:35 -05:00
|
|
|
|
}
|
2014-04-25 19:45:10 -04:00
|
|
|
|
return;
|
2016-09-13 08:01:18 -04:00
|
|
|
|
} else if (term.esc & ESC_UTF8) {
|
|
|
|
|
tdefutf8(u);
|
2015-07-10 04:29:53 -04:00
|
|
|
|
} else if (term.esc & ESC_ALTCHARSET) {
|
2015-04-21 17:29:15 -04:00
|
|
|
|
tdeftran(u);
|
2015-07-10 04:29:53 -04:00
|
|
|
|
} else if (term.esc & ESC_TEST) {
|
2015-04-21 17:29:15 -04:00
|
|
|
|
tdectest(u);
|
2010-06-03 17:14:37 -04:00
|
|
|
|
} else {
|
2015-04-21 17:29:15 -04:00
|
|
|
|
if (!eschandle(u))
|
2014-04-25 19:45:10 -04:00
|
|
|
|
return;
|
2014-08-20 03:56:24 -04:00
|
|
|
|
/* sequence already finished */
|
2010-02-02 21:25:35 -05:00
|
|
|
|
}
|
2014-04-25 19:45:10 -04:00
|
|
|
|
term.esc = 0;
|
2012-10-06 13:15:30 -04:00
|
|
|
|
/*
|
2012-11-15 14:57:37 -05:00
|
|
|
|
* All characters which form part of a sequence are not
|
2012-10-06 13:15:30 -04:00
|
|
|
|
* printed
|
|
|
|
|
*/
|
|
|
|
|
return;
|
2009-05-10 08:17:09 -04:00
|
|
|
|
}
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (sel.ob.x != -1 && BETWEEN(term.c.y, sel.ob.y, sel.oe.y))
|
2017-01-20 03:06:39 -05:00
|
|
|
|
selclear();
|
2014-04-27 04:25:15 -04:00
|
|
|
|
|
|
|
|
|
gp = &term.line[term.c.y][term.c.x];
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (IS_SET(MODE_WRAP) && (term.c.state & CURSOR_WRAPNEXT)) {
|
2014-04-27 04:25:15 -04:00
|
|
|
|
gp->mode |= ATTR_WRAP;
|
2013-04-21 07:01:16 -04:00
|
|
|
|
tnewline(1);
|
2015-01-29 18:06:43 -05:00
|
|
|
|
gp = &term.line[term.c.y][term.c.x];
|
2013-04-21 07:01:16 -04:00
|
|
|
|
}
|
2012-11-15 10:26:50 -05:00
|
|
|
|
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (IS_SET(MODE_INSERT) && term.c.x+width < term.col)
|
2015-01-29 18:00:39 -05:00
|
|
|
|
memmove(gp+width, gp, (term.col - term.c.x - width) * sizeof(Glyph));
|
2012-11-15 10:26:50 -05:00
|
|
|
|
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (term.c.x+width > term.col) {
|
2013-09-07 06:41:36 -04:00
|
|
|
|
tnewline(1);
|
2015-01-29 18:06:43 -05:00
|
|
|
|
gp = &term.line[term.c.y][term.c.x];
|
|
|
|
|
}
|
2013-09-07 06:41:36 -04:00
|
|
|
|
|
2015-04-21 17:29:15 -04:00
|
|
|
|
tsetchar(u, &term.c.attr, term.c.x, term.c.y);
|
2013-09-07 06:41:36 -04:00
|
|
|
|
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (width == 2) {
|
2014-04-27 04:25:15 -04:00
|
|
|
|
gp->mode |= ATTR_WIDE;
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (term.c.x+1 < term.col) {
|
2015-04-21 17:29:01 -04:00
|
|
|
|
gp[1].u = '\0';
|
2014-04-27 04:25:15 -04:00
|
|
|
|
gp[1].mode = ATTR_WDUMMY;
|
2013-09-07 06:41:36 -04:00
|
|
|
|
}
|
|
|
|
|
}
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (term.c.x+width < term.col) {
|
2013-09-07 06:41:36 -04:00
|
|
|
|
tmoveto(term.c.x+width, term.c.y);
|
2012-11-15 10:26:50 -05:00
|
|
|
|
} else {
|
2012-10-06 13:15:30 -04:00
|
|
|
|
term.c.state |= CURSOR_WRAPNEXT;
|
2012-11-15 10:26:50 -05:00
|
|
|
|
}
|
2009-05-10 08:17:09 -04:00
|
|
|
|
}
|
|
|
|
|
|
2014-04-27 18:03:04 -04:00
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
tresize(int col, int row)
|
|
|
|
|
{
|
2013-04-15 09:13:19 -04:00
|
|
|
|
int i;
|
2009-05-10 08:17:09 -04:00
|
|
|
|
int minrow = MIN(row, term.row);
|
|
|
|
|
int mincol = MIN(col, term.col);
|
2015-07-08 17:56:55 -04:00
|
|
|
|
int *bp;
|
2014-04-28 18:35:22 -04:00
|
|
|
|
TCursor c;
|
2009-05-10 08:17:09 -04:00
|
|
|
|
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (col < 1 || row < 1) {
|
2014-04-27 18:03:04 -04:00
|
|
|
|
fprintf(stderr,
|
|
|
|
|
"tresize: error resizing to %dx%d\n", col, row);
|
|
|
|
|
return;
|
|
|
|
|
}
|
2010-08-26 15:37:12 -04:00
|
|
|
|
|
2015-04-11 13:30:12 -04:00
|
|
|
|
/*
|
|
|
|
|
* slide screen to keep cursor where we expect it -
|
|
|
|
|
* tscrollup would work here, but we can optimize to
|
|
|
|
|
* memmove because we're freeing the earlier lines
|
|
|
|
|
*/
|
2015-07-10 04:29:53 -04:00
|
|
|
|
for (i = 0; i <= term.c.y - row; i++) {
|
2015-04-11 13:29:52 -04:00
|
|
|
|
free(term.line[i]);
|
|
|
|
|
free(term.alt[i]);
|
|
|
|
|
}
|
2015-04-15 04:43:06 -04:00
|
|
|
|
/* ensure that both src and dst are not NULL */
|
|
|
|
|
if (i > 0) {
|
|
|
|
|
memmove(term.line, term.line + i, row * sizeof(Line));
|
|
|
|
|
memmove(term.alt, term.alt + i, row * sizeof(Line));
|
|
|
|
|
}
|
2015-07-10 04:29:53 -04:00
|
|
|
|
for (i += row; i < term.row; i++) {
|
2009-05-27 19:33:01 -04:00
|
|
|
|
free(term.line[i]);
|
2010-08-30 10:48:18 -04:00
|
|
|
|
free(term.alt[i]);
|
|
|
|
|
}
|
2010-08-26 18:28:27 -04:00
|
|
|
|
|
Clean up xdraws and optimize glyph drawing with non-unit kerning values
I have another patch here for review that optimizes the performance of
glyph drawing, primarily when using non-unit kerning values, and fixes a
few other minor issues. It's dependent on the earlier patch from me that
stores unicode codepoints in a Rune type, typedef'd to uint_least32_t.
This patch is a pretty big change to xdraws so your scrutiny is
appreciated.
First, some performance numbers. I used Yu-Jie Lin termfps.sh shell
script to benchmark before and after, and you can find it in the
attachments. On my Kaveri A10 7850k machine, I get the following
results:
Before Patch
============
1) Font: "Liberation Mono:pixelsize=12:antialias=false:autohint=false"
cwscale: 1.0, chscale: 1.0
For 273x83 100 frames.
Elapsed time : 1.553
Frames/second: 64.352
Chars /second: 1,458,159
2) Font: "Inconsolata:pixelsize=14:antialias=true:autohint=true"
cwscale: 1.001, chscale: 1.001
For 239x73 100 frames.
Elapsed time : 159.286
Frames/second: 0.627
Chars /second: 10,953
After Patch
===========
3) Font: "Liberation Mono:pixelsize=12:antialias=false:autohint=false"
cwscale: 1.0, chscale: 1.0
For 273x83 100 frames.
Elapsed time : 1.544
Frames/second: 64.728
Chars /second: 1,466,690
4) Font: "Inconsolata:pixelsize=14:antialias=true:autohint=true"
cwscale: 1.001, chscale: 1.001
For 239x73 100 frames.
Elapsed time : 1.955
Frames/second: 51.146
Chars /second: 892,361
As you can see, while the improvements for fonts with unit-kerning is
marginal, there's a huge ~81x performance increase with the patch when
using kerning values other than 1.0.
So what does the patch do?
The `xdraws' function would render each glyph one at a time if non-unit
kerning values were configured, and this was the primary cause of the
slow down. Xft provides a handful of functions which allow you to render
multiple characters or glyphs at time, each with a unique <x,y> position,
so it was simply a matter of massaging the data into a format that would
allow us to use one of these functions.
I've split `xdraws' up into two functions. In the first pass with
`xmakeglyphfontspecs' it will iterate over all of the glyphs in a given
row and it will build up an array of corresponding XftGlyphFontSpec
records. Much of the old logic for resolving fonts for glyphs using Xft
and fontconfig went into this function.
The second pass is done with `xrenderglyphfontspecs' which contains the
old logic for determining colors, clearing the background, and finally
rendering the array of XftGlyphFontSpec records.
There's a couple of other things that have been improved by this patch.
For instance, the UTF-32 codepoints in the Line's were being re-encoded
back into UTF-8 strings to be passed to `xdraws' which in turn would then
decode back to UTF-32 to verify that the Font contained a matching glyph
for the code point. Next, the UTF-8 string was being passed to
`XftDrawStringUtf8' which internally mallocs a scratch buffer and decodes
back to UTF-32 and does the lookup of the glyphs all over again.
This patch gets rid of all of this redundant round-trip encoding and
decoding of characters to be rendered and only looks up the glyph index
once (per font) during the font resolution phase. So this is probably
what's responsible for the marginal improvements seen when kerning values
are kept to 1.0.
I imagine there are other performance improvements here too, not seen in
the above benchmarks, if the user has lots of non-ASCII code plane characters
on the screen, or several different fonts are being utilized during
screen redraw.
Anyway, if you see any problems, please let me know and I can fix them.
2015-05-05 23:24:00 -04:00
|
|
|
|
/* resize to new width */
|
2017-01-20 03:06:39 -05:00
|
|
|
|
term.specbuf = xrealloc(term.specbuf, col * sizeof(GlyphFontSpec));
|
Clean up xdraws and optimize glyph drawing with non-unit kerning values
I have another patch here for review that optimizes the performance of
glyph drawing, primarily when using non-unit kerning values, and fixes a
few other minor issues. It's dependent on the earlier patch from me that
stores unicode codepoints in a Rune type, typedef'd to uint_least32_t.
This patch is a pretty big change to xdraws so your scrutiny is
appreciated.
First, some performance numbers. I used Yu-Jie Lin termfps.sh shell
script to benchmark before and after, and you can find it in the
attachments. On my Kaveri A10 7850k machine, I get the following
results:
Before Patch
============
1) Font: "Liberation Mono:pixelsize=12:antialias=false:autohint=false"
cwscale: 1.0, chscale: 1.0
For 273x83 100 frames.
Elapsed time : 1.553
Frames/second: 64.352
Chars /second: 1,458,159
2) Font: "Inconsolata:pixelsize=14:antialias=true:autohint=true"
cwscale: 1.001, chscale: 1.001
For 239x73 100 frames.
Elapsed time : 159.286
Frames/second: 0.627
Chars /second: 10,953
After Patch
===========
3) Font: "Liberation Mono:pixelsize=12:antialias=false:autohint=false"
cwscale: 1.0, chscale: 1.0
For 273x83 100 frames.
Elapsed time : 1.544
Frames/second: 64.728
Chars /second: 1,466,690
4) Font: "Inconsolata:pixelsize=14:antialias=true:autohint=true"
cwscale: 1.001, chscale: 1.001
For 239x73 100 frames.
Elapsed time : 1.955
Frames/second: 51.146
Chars /second: 892,361
As you can see, while the improvements for fonts with unit-kerning is
marginal, there's a huge ~81x performance increase with the patch when
using kerning values other than 1.0.
So what does the patch do?
The `xdraws' function would render each glyph one at a time if non-unit
kerning values were configured, and this was the primary cause of the
slow down. Xft provides a handful of functions which allow you to render
multiple characters or glyphs at time, each with a unique <x,y> position,
so it was simply a matter of massaging the data into a format that would
allow us to use one of these functions.
I've split `xdraws' up into two functions. In the first pass with
`xmakeglyphfontspecs' it will iterate over all of the glyphs in a given
row and it will build up an array of corresponding XftGlyphFontSpec
records. Much of the old logic for resolving fonts for glyphs using Xft
and fontconfig went into this function.
The second pass is done with `xrenderglyphfontspecs' which contains the
old logic for determining colors, clearing the background, and finally
rendering the array of XftGlyphFontSpec records.
There's a couple of other things that have been improved by this patch.
For instance, the UTF-32 codepoints in the Line's were being re-encoded
back into UTF-8 strings to be passed to `xdraws' which in turn would then
decode back to UTF-32 to verify that the Font contained a matching glyph
for the code point. Next, the UTF-8 string was being passed to
`XftDrawStringUtf8' which internally mallocs a scratch buffer and decodes
back to UTF-32 and does the lookup of the glyphs all over again.
This patch gets rid of all of this redundant round-trip encoding and
decoding of characters to be rendered and only looks up the glyph index
once (per font) during the font resolution phase. So this is probably
what's responsible for the marginal improvements seen when kerning values
are kept to 1.0.
I imagine there are other performance improvements here too, not seen in
the above benchmarks, if the user has lots of non-ASCII code plane characters
on the screen, or several different fonts are being utilized during
screen redraw.
Anyway, if you see any problems, please let me know and I can fix them.
2015-05-05 23:24:00 -04:00
|
|
|
|
|
2010-08-26 18:28:27 -04:00
|
|
|
|
/* resize to new height */
|
2012-09-12 15:25:35 -04:00
|
|
|
|
term.line = xrealloc(term.line, row * sizeof(Line));
|
|
|
|
|
term.alt = xrealloc(term.alt, row * sizeof(Line));
|
|
|
|
|
term.dirty = xrealloc(term.dirty, row * sizeof(*term.dirty));
|
|
|
|
|
term.tabs = xrealloc(term.tabs, col * sizeof(*term.tabs));
|
2010-08-26 18:28:27 -04:00
|
|
|
|
|
|
|
|
|
/* resize each row to new width, zero-pad if needed */
|
2015-07-10 04:29:53 -04:00
|
|
|
|
for (i = 0; i < minrow; i++) {
|
2012-09-12 15:25:35 -04:00
|
|
|
|
term.line[i] = xrealloc(term.line[i], col * sizeof(Glyph));
|
|
|
|
|
term.alt[i] = xrealloc(term.alt[i], col * sizeof(Glyph));
|
2010-08-26 15:37:12 -04:00
|
|
|
|
}
|
2010-08-26 18:28:27 -04:00
|
|
|
|
|
|
|
|
|
/* allocate any new rows */
|
2015-07-10 04:29:53 -04:00
|
|
|
|
for (/* i == minrow */; i < row; i++) {
|
2013-08-25 18:10:47 -04:00
|
|
|
|
term.line[i] = xmalloc(col * sizeof(Glyph));
|
|
|
|
|
term.alt[i] = xmalloc(col * sizeof(Glyph));
|
2010-08-30 10:48:18 -04:00
|
|
|
|
}
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (col > term.col) {
|
2012-10-06 03:58:45 -04:00
|
|
|
|
bp = term.tabs + term.col;
|
2012-08-29 13:59:37 -04:00
|
|
|
|
|
|
|
|
|
memset(bp, 0, sizeof(*term.tabs) * (col - term.col));
|
2015-07-10 04:29:53 -04:00
|
|
|
|
while (--bp > term.tabs && !*bp)
|
2012-08-29 13:59:37 -04:00
|
|
|
|
/* nothing */ ;
|
2015-07-10 04:29:53 -04:00
|
|
|
|
for (bp += tabspaces; bp < term.tabs + col; bp += tabspaces)
|
2012-08-29 13:59:37 -04:00
|
|
|
|
*bp = 1;
|
|
|
|
|
}
|
2010-08-29 19:35:37 -04:00
|
|
|
|
/* update terminal size */
|
2012-10-28 08:25:53 -04:00
|
|
|
|
term.col = col;
|
|
|
|
|
term.row = row;
|
2010-08-29 19:35:37 -04:00
|
|
|
|
/* reset scrolling region */
|
|
|
|
|
tsetscroll(0, row-1);
|
2012-11-08 11:21:10 -05:00
|
|
|
|
/* make use of the LIMIT in tmoveto */
|
|
|
|
|
tmoveto(term.c.x, term.c.y);
|
2014-04-27 18:16:21 -04:00
|
|
|
|
/* Clearing both screens (it makes dirty all lines) */
|
2014-04-28 18:35:22 -04:00
|
|
|
|
c = term.c;
|
2015-07-10 04:29:53 -04:00
|
|
|
|
for (i = 0; i < 2; i++) {
|
|
|
|
|
if (mincol < col && 0 < minrow) {
|
2013-04-15 09:13:19 -04:00
|
|
|
|
tclearregion(mincol, 0, col - 1, minrow - 1);
|
|
|
|
|
}
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (0 < col && minrow < row) {
|
2013-04-15 09:13:19 -04:00
|
|
|
|
tclearregion(0, minrow, col - 1, row - 1);
|
|
|
|
|
}
|
|
|
|
|
tswapscreen();
|
2014-04-24 14:35:41 -04:00
|
|
|
|
tcursor(CURSOR_LOAD);
|
2014-08-18 13:19:42 -04:00
|
|
|
|
}
|
2014-04-28 18:35:22 -04:00
|
|
|
|
term.c = c;
|
2009-05-10 08:17:09 -04:00
|
|
|
|
}
|
|
|
|
|
|
2010-10-25 15:10:41 -04:00
|
|
|
|
void
|
2017-01-20 03:06:39 -05:00
|
|
|
|
zoom(const Arg *arg)
|
2015-07-09 17:59:50 -04:00
|
|
|
|
{
|
2017-01-20 03:06:39 -05:00
|
|
|
|
Arg larg;
|
2010-10-25 15:10:41 -04:00
|
|
|
|
|
2017-01-20 03:06:39 -05:00
|
|
|
|
larg.f = usedfontsize + arg->f;
|
|
|
|
|
zoomabs(&larg);
|
2013-02-19 12:39:13 -05:00
|
|
|
|
}
|
|
|
|
|
|
2017-01-20 03:06:39 -05:00
|
|
|
|
void
|
|
|
|
|
zoomabs(const Arg *arg)
|
2015-07-09 17:59:50 -04:00
|
|
|
|
{
|
2017-01-20 03:06:39 -05:00
|
|
|
|
xunloadfonts();
|
|
|
|
|
xloadfonts(usedfont, arg->f);
|
|
|
|
|
cresize(0, 0);
|
|
|
|
|
ttyresize();
|
|
|
|
|
redraw();
|
|
|
|
|
xhints();
|
2015-04-21 03:48:33 -04:00
|
|
|
|
}
|
|
|
|
|
|
2010-07-24 07:09:14 -04:00
|
|
|
|
void
|
2017-01-20 03:06:39 -05:00
|
|
|
|
zoomreset(const Arg *arg)
|
2015-07-09 17:59:50 -04:00
|
|
|
|
{
|
2017-01-20 03:06:39 -05:00
|
|
|
|
Arg larg;
|
2013-07-20 15:52:40 -04:00
|
|
|
|
|
2017-01-20 03:06:39 -05:00
|
|
|
|
if (defaultfontsize > 0) {
|
|
|
|
|
larg.f = defaultfontsize;
|
|
|
|
|
zoomabs(&larg);
|
2013-07-20 15:52:40 -04:00
|
|
|
|
}
|
2013-02-19 12:39:13 -05:00
|
|
|
|
}
|
|
|
|
|
|
2009-05-10 08:17:09 -04:00
|
|
|
|
void
|
2017-01-20 03:06:39 -05:00
|
|
|
|
resettitle(void)
|
2015-07-09 17:59:50 -04:00
|
|
|
|
{
|
2017-01-20 03:06:39 -05:00
|
|
|
|
xsettitle(opt_title ? opt_title : "st");
|
2012-09-29 05:17:16 -04:00
|
|
|
|
}
|
|
|
|
|
|
2010-06-02 10:01:30 -04:00
|
|
|
|
void
|
2017-01-20 03:06:39 -05:00
|
|
|
|
redraw(void)
|
2015-07-09 17:59:50 -04:00
|
|
|
|
{
|
2017-01-20 03:06:39 -05:00
|
|
|
|
tfulldirt();
|
|
|
|
|
draw();
|
2010-06-02 10:01:30 -04:00
|
|
|
|
}
|
|
|
|
|
|
2014-04-25 16:34:24 -04:00
|
|
|
|
int
|
2017-01-20 03:06:39 -05:00
|
|
|
|
match(uint mask, uint state)
|
2015-07-09 17:59:50 -04:00
|
|
|
|
{
|
2017-01-20 03:06:39 -05:00
|
|
|
|
return mask == XK_ANY_MOD || mask == (state & ~ignoremod);
|
2014-04-25 16:34:24 -04:00
|
|
|
|
}
|
|
|
|
|
|
2017-01-20 03:06:39 -05:00
|
|
|
|
void
|
|
|
|
|
numlock(const Arg *dummy)
|
2015-07-09 17:59:50 -04:00
|
|
|
|
{
|
2017-01-20 03:06:39 -05:00
|
|
|
|
term.numlock ^= 1;
|
|
|
|
|
}
|
2012-10-04 16:59:45 -04:00
|
|
|
|
|
2017-01-20 03:06:39 -05:00
|
|
|
|
char*
|
|
|
|
|
kmap(KeySym k, uint state)
|
|
|
|
|
{
|
|
|
|
|
Key *kp;
|
|
|
|
|
int i;
|
2012-11-15 14:19:35 -05:00
|
|
|
|
|
|
|
|
|
/* Check for mapped keys out of X11 function keys. */
|
2015-07-10 04:29:53 -04:00
|
|
|
|
for (i = 0; i < LEN(mappedkeys); i++) {
|
|
|
|
|
if (mappedkeys[i] == k)
|
2012-11-15 14:19:35 -05:00
|
|
|
|
break;
|
|
|
|
|
}
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (i == LEN(mappedkeys)) {
|
|
|
|
|
if ((k & 0xFFFF) < 0xFD00)
|
2012-11-15 14:19:35 -05:00
|
|
|
|
return NULL;
|
|
|
|
|
}
|
2012-10-06 03:58:45 -04:00
|
|
|
|
|
2015-07-10 04:29:53 -04:00
|
|
|
|
for (kp = key; kp < key + LEN(key); kp++) {
|
|
|
|
|
if (kp->k != k)
|
2012-11-13 14:04:45 -05:00
|
|
|
|
continue;
|
2012-11-14 00:37:24 -05:00
|
|
|
|
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (!match(kp->mask, state))
|
2012-11-13 14:04:45 -05:00
|
|
|
|
continue;
|
2012-11-14 00:37:24 -05:00
|
|
|
|
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (IS_SET(MODE_APPKEYPAD) ? kp->appkey < 0 : kp->appkey > 0)
|
2013-10-19 09:13:13 -04:00
|
|
|
|
continue;
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (term.numlock && kp->appkey == 2)
|
2012-11-13 14:04:45 -05:00
|
|
|
|
continue;
|
2012-11-14 00:37:24 -05:00
|
|
|
|
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (IS_SET(MODE_APPCURSOR) ? kp->appcursor < 0 : kp->appcursor > 0)
|
2012-11-13 14:04:45 -05:00
|
|
|
|
continue;
|
2012-11-14 00:37:24 -05:00
|
|
|
|
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (IS_SET(MODE_CRLF) ? kp->crlf < 0 : kp->crlf > 0)
|
2012-11-13 14:04:45 -05:00
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
return kp->s;
|
2011-08-14 11:13:59 -04:00
|
|
|
|
}
|
2012-11-14 00:37:24 -05:00
|
|
|
|
|
2009-09-07 15:19:29 -04:00
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2009-05-10 08:17:09 -04:00
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
cresize(int width, int height)
|
|
|
|
|
{
|
2009-05-10 08:17:09 -04:00
|
|
|
|
int col, row;
|
2012-09-02 13:43:29 -04:00
|
|
|
|
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (width != 0)
|
2017-01-20 03:06:39 -05:00
|
|
|
|
win.w = width;
|
2015-07-10 04:29:53 -04:00
|
|
|
|
if (height != 0)
|
2017-01-20 03:06:39 -05:00
|
|
|
|
win.h = height;
|
2012-09-02 13:43:29 -04:00
|
|
|
|
|
2017-01-20 03:06:39 -05:00
|
|
|
|
col = (win.w - 2 * borderpx) / win.cw;
|
|
|
|
|
row = (win.h - 2 * borderpx) / win.ch;
|
2012-09-17 16:44:27 -04:00
|
|
|
|
|
2012-09-16 08:02:35 -04:00
|
|
|
|
tresize(col, row);
|
2010-10-25 15:10:41 -04:00
|
|
|
|
xresize(col, row);
|
2009-05-10 08:17:09 -04:00
|
|
|
|
}
|
|
|
|
|
|
2013-04-03 15:00:38 -04:00
|
|
|
|
void
|
2015-07-09 17:59:50 -04:00
|
|
|
|
usage(void)
|
|
|
|
|
{
|
2016-02-01 06:20:33 -05:00
|
|
|
|
die("usage: %s [-aiv] [-c class] [-f font] [-g geometry]"
|
|
|
|
|
" [-n name] [-o file]\n"
|
|
|
|
|
" [-T title] [-t title] [-w windowid]"
|
|
|
|
|
" [[-e] command [args ...]]\n"
|
|
|
|
|
" %s [-aiv] [-c class] [-f font] [-g geometry]"
|
|
|
|
|
" [-n name] [-o file]\n"
|
|
|
|
|
" [-T title] [-t title] [-w windowid] -l line"
|
|
|
|
|
" [stty_args ...]\n", argv0, argv0);
|
2016-01-29 16:02:40 -05:00
|
|
|
|
}
|