X-Git-Url: https://git.danieliu.xyz/?a=blobdiff_plain;f=st.c;h=3abf1b021258ce2b7f16f24bd1e14aa3247ed595;hb=ddb08dfe82ca196bb4f6e554e7db0fd32da58ba2;hp=f0c2cd20a66ab7c434fe5b0b6b0208f38f4df91b;hpb=8503f954a1cb2d08124fe2c1f0227bd23dffff46;p=st.git diff --git a/st.c b/st.c index f0c2cd2..3abf1b0 100644 --- a/st.c +++ b/st.c @@ -1,10 +1,10 @@ -/* See LICENSE for licence details. */ -#define _XOPEN_SOURCE 600 +/* See LICENSE for license details. */ +#include #include #include #include #include -#include +#include #include #include #include @@ -12,18 +12,14 @@ #include #include #include -#include #include #include +#include #include -#include -#include -#include -#include -#include +#include -#include -#include +#include "st.h" +#include "win.h" #if defined(__linux) #include @@ -32,984 +28,1480 @@ #elif defined(__FreeBSD__) || defined(__DragonFly__) #include #endif - -#define USAGE \ - "st-" VERSION ", (c) 2010-2011 st engineers\n" \ - "usage: st [-t title] [-c class] [-w windowid] [-v] [-e command...]\n" +#if defined(__OpenBSD__) + #include +#endif /* Arbitrary sizes */ -#define ESC_TITLE_SIZ 256 -#define ESC_BUF_SIZ 256 -#define ESC_ARG_SIZ 16 -#define DRAW_BUF_SIZ 1024 +#define UTF_INVALID 0xFFFD #define UTF_SIZ 4 +#define ESC_BUF_SIZ (128*UTF_SIZ) +#define ESC_ARG_SIZ 16 +#define STR_BUF_SIZ ESC_BUF_SIZ +#define STR_ARG_SIZ ESC_ARG_SIZ + +/* macros */ +#define IS_SET(flag) ((term.mode & (flag)) != 0) +#define ISCONTROLC0(c) (BETWEEN(c, 0, 0x1f) || (c) == 0x7f) +#define ISCONTROLC1(c) (BETWEEN(c, 0x80, 0x9f)) +#define ISCONTROL(c) (ISCONTROLC0(c) || ISCONTROLC1(c)) +#define ISDELIM(u) (u && wcschr(worddelimiters, u)) +static inline int max(int a, int b) { return a > b ? a : b; } +static inline int min(int a, int b) { return a < b ? a : b; } + +enum term_mode { + MODE_WRAP = 1 << 0, + MODE_INSERT = 1 << 1, + MODE_ALTSCREEN = 1 << 2, + MODE_CRLF = 1 << 3, + MODE_ECHO = 1 << 4, + MODE_PRINT = 1 << 5, + MODE_UTF8 = 1 << 6, +}; -#define SERRNO strerror(errno) -#define MIN(a, b) ((a) < (b) ? (a) : (b)) -#define MAX(a, b) ((a) < (b) ? (b) : (a)) -#define LEN(a) (sizeof(a) / sizeof(a[0])) -#define DEFAULT(a, b) (a) = (a) ? (a) : (b) -#define BETWEEN(x, a, b) ((a) <= (x) && (x) <= (b)) -#define LIMIT(x, a, b) (x) = (x) < (a) ? (a) : (x) > (b) ? (b) : (x) -#define ATTRCMP(a, b) ((a).mode != (b).mode || (a).fg != (b).fg || (a).bg != (b).bg) -#define IS_SET(flag) (term.mode & (flag)) -#define TIMEDIFF(t1, t2) ((t1.tv_sec-t2.tv_sec)*1000 + (t1.tv_usec-t2.tv_usec)/1000) -#define X2COL(x) (((x) - BORDER)/xw.cw) -#define Y2ROW(y) (((y) - BORDER)/xw.ch) - -/* Attribute, Cursor, Character state, Terminal mode, Screen draw mode */ -enum { ATTR_NULL=0 , ATTR_REVERSE=1 , ATTR_UNDERLINE=2, ATTR_BOLD=4, ATTR_GFX=8 }; -enum { CURSOR_UP, CURSOR_DOWN, CURSOR_LEFT, CURSOR_RIGHT, - CURSOR_SAVE, CURSOR_LOAD }; -enum { CURSOR_DEFAULT = 0, CURSOR_HIDE = 1, CURSOR_WRAPNEXT = 2 }; -enum { GLYPH_SET=1, GLYPH_DIRTY=2 }; -enum { MODE_WRAP=1, MODE_INSERT=2, MODE_APPKEYPAD=4, MODE_ALTSCREEN=8, - MODE_CRLF=16, MODE_MOUSEBTN=32, MODE_MOUSEMOTION=64, MODE_MOUSE=32|64, MODE_REVERSE=128 }; -enum { ESC_START=1, ESC_CSI=2, ESC_OSC=4, ESC_TITLE=8, ESC_ALTCHARSET=16 }; -enum { WIN_VISIBLE=1, WIN_REDRAW=2, WIN_FOCUSED=4 }; - -#undef B0 -enum { B0=1, B1=2, B2=4, B3=8, B4=16, B5=32, B6=64, B7=128 }; +enum cursor_movement { + CURSOR_SAVE, + CURSOR_LOAD +}; -typedef struct { - char c[UTF_SIZ]; /* character code */ - char mode; /* attribute flags */ - int fg; /* foreground */ - int bg; /* background */ - char state; /* state flags */ -} Glyph; +enum cursor_state { + CURSOR_DEFAULT = 0, + CURSOR_WRAPNEXT = 1, + CURSOR_ORIGIN = 2 +}; -typedef Glyph* Line; +enum charset { + CS_GRAPHIC0, + CS_GRAPHIC1, + CS_UK, + CS_USA, + CS_MULTI, + CS_GER, + CS_FIN +}; + +enum escape_state { + ESC_START = 1, + ESC_CSI = 2, + ESC_STR = 4, /* DCS, OSC, PM, APC */ + ESC_ALTCHARSET = 8, + ESC_STR_END = 16, /* a final string was encountered */ + ESC_TEST = 32, /* Enter in test mode */ + ESC_UTF8 = 64, +}; typedef struct { - Glyph attr; /* current char attributes */ + Glyph attr; /* current char attributes */ int x; int y; char state; } TCursor; -/* CSI Escape sequence structs */ -/* ESC '[' [[ [] [;]] ] */ typedef struct { - char buf[ESC_BUF_SIZ]; /* raw string */ - int len; /* raw string length */ - char priv; - int arg[ESC_ARG_SIZ]; - int narg; /* nb of args */ - char mode; -} CSIEscape; + int mode; + int type; + int snap; + int swap; + /* + * Selection variables: + * nb – normalized coordinates of the beginning of the selection + * ne – normalized coordinates of the end of the selection + * ob – original coordinates of the beginning of the selection + * oe – original coordinates of the end of the selection + */ + struct { + int x, y; + } nb, ne, ob, oe; + + int alt; +} Selection; /* Internal representation of the screen */ typedef struct { - int row; /* nb row */ - int col; /* nb col */ - Line* line; /* screen */ - Line* alt; /* alternate screen */ - TCursor c; /* cursor */ - int top; /* top scroll limit */ - int bot; /* bottom scroll limit */ - int mode; /* terminal mode flags */ - int esc; /* escape state flags */ - char title[ESC_TITLE_SIZ]; - int titlelen; + int row; /* nb row */ + int col; /* nb col */ + Line *line; /* screen */ + Line *alt; /* alternate screen */ + int *dirty; /* dirtyness of lines */ + TCursor c; /* cursor */ + int ocx; /* old cursor col */ + int ocy; /* old cursor row */ + int top; /* top scroll limit */ + int bot; /* bottom scroll limit */ + int mode; /* terminal mode flags */ + int esc; /* escape state flags */ + char trantbl[4]; /* charset table translation */ + int charset; /* current charset */ + int icharset; /* selected charset for sequence */ + int *tabs; + Rune lastc; /* last printed char outside of sequence, 0 if control */ } Term; -/* Purely graphic info */ -typedef struct { - Display* dpy; - Colormap cmap; - Window win; - Pixmap buf; - XIM xim; - XIC xic; - int scr; - int w; /* window width */ - int h; /* window height */ - int bufw; /* pixmap width */ - int bufh; /* pixmap height */ - int ch; /* char height */ - int cw; /* char width */ - char state; /* focus, redraw, visible */ -} XWindow; - +/* CSI Escape sequence structs */ +/* ESC '[' [[ [] [;]] []] */ typedef struct { - KeySym k; - unsigned int mask; - char s[ESC_BUF_SIZ]; -} Key; + char buf[ESC_BUF_SIZ]; /* raw string */ + size_t len; /* raw string length */ + char priv; + int arg[ESC_ARG_SIZ]; + int narg; /* nb of args */ + char mode[2]; +} CSIEscape; -/* Drawing Context */ -typedef struct { - unsigned long col[256]; - GC gc; - struct { - int ascent; - int descent; - short lbearing; - short rbearing; - XFontSet set; - } font, bfont; -} DC; - -/* TODO: use better name for vars... */ +/* STR Escape sequence structs */ +/* ESC type [[ [] [;]] ] ESC '\' */ typedef struct { - int mode; - int bx, by; - int ex, ey; - struct {int x, y;} b, e; - char *clip; - Atom xtarget; - struct timeval tclick1; - struct timeval tclick2; -} Selection; - -#include "config.h" + char type; /* ESC type ... */ + char *buf; /* allocated raw string */ + size_t siz; /* allocation size */ + size_t len; /* raw string length */ + char *args[STR_ARG_SIZ]; + int narg; /* nb of args */ +} STREscape; -static void die(const char*, ...); -static void draw(void); -static void drawregion(int, int, int, int); -static void execsh(void); +static void execsh(char *, char **); +static char *getcwd_by_pid(pid_t pid); +static void stty(char **); static void sigchld(int); -static void run(void); +static void ttywriteraw(const char *, size_t); static void csidump(void); static void csihandle(void); static void csiparse(void); static void csireset(void); - +static int eschandle(uchar); +static void strdump(void); +static void strhandle(void); +static void strparse(void); +static void strreset(void); + +static void tprinter(char *, size_t); +static void tdumpsel(void); +static void tdumpline(int); +static void tdump(void); static void tclearregion(int, int, int, int); static void tcursor(int); static void tdeletechar(int); static void tdeleteline(int); static void tinsertblank(int); static void tinsertblankline(int); +static int tlinelen(int); static void tmoveto(int, int); -static void tnew(int, int); +static void tmoveato(int, int); static void tnewline(int); -static void tputtab(void); -static void tputc(char*); +static void tputtab(int); +static void tputc(Rune); static void treset(void); -static int tresize(int, int); static void tscrollup(int, int); static void tscrolldown(int, int); -static void tsetattr(int*, int); -static void tsetchar(char*); +static void tsetattr(int *, int); +static void tsetchar(Rune, Glyph *, int, int); +static void tsetdirt(int, int); static void tsetscroll(int, int); static void tswapscreen(void); +static void tsetmode(int, int, int *, int); +static int twrite(const char *, int, int); +static void tfulldirt(void); +static void tcontrolcode(uchar ); +static void tdectest(char ); +static void tdefutf8(char); +static int32_t tdefcolor(int *, int *, int); +static void tdeftran(char); +static void tstrsequence(uchar); -static void ttynew(void); -static void ttyread(void); -static void ttyresize(int, int); -static void ttywrite(const char *, size_t); - -static void xdraws(char *, Glyph, int, int, int, int); -static void xhints(void); -static void xclear(int, int, int, int); -static void xdrawcursor(void); -static void xinit(void); -static void xloadcols(void); -static void xseturgency(int); -static void xsetsel(char*); -static void xresize(int, int); - -static void expose(XEvent *); -static void visibility(XEvent *); -static void unmap(XEvent *); -static char* kmap(KeySym, unsigned int state); -static void kpress(XEvent *); -static void resize(XEvent *); -static void focus(XEvent *); -static void brelease(XEvent *); -static void bpress(XEvent *); -static void bmotion(XEvent *); -static void selnotify(XEvent *); -static void selrequest(XEvent *); - -static void selinit(void); -static inline int selected(int, int); -static void selcopy(void); -static void selpaste(); - -static int utf8decode(char *, long *); -static int utf8encode(long *, char *); -static int utf8size(char *); -static int isfullutf8(char *, int); - -static void (*handler[LASTEvent])(XEvent *) = { - [KeyPress] = kpress, - [ConfigureNotify] = resize, - [VisibilityNotify] = visibility, - [UnmapNotify] = unmap, - [Expose] = expose, - [EnterNotify] = focus, - [LeaveNotify] = focus, - [FocusIn] = focus, - [FocusOut] = focus, - [MotionNotify] = bmotion, - [ButtonPress] = bpress, - [ButtonRelease] = brelease, - [SelectionNotify] = selnotify, - [SelectionRequest] = selrequest, -}; +static void drawregion(int, int, int, int); + +static void selscroll(int, int); +static void selnormalize(void); + +static size_t utf8decode(const char *, Rune *, size_t); +static Rune utf8decodebyte(char, size_t *); +static char utf8encodebyte(Rune, size_t); +static size_t utf8validate(Rune *, size_t); + +static char *base64dec(const char *); +static char base64dec_getc(const char **); + +static ssize_t xwrite(int, const char *, size_t); /* Globals */ -static DC dc; -static XWindow xw; static Term term; -static CSIEscape escseq; +static Selection sel; +static CSIEscape csiescseq; +static STREscape strescseq; +static int iofd = 1; static int cmdfd; static pid_t pid; -static Selection sel; -static char **opt_cmd = NULL; -static char *opt_title = NULL; -static char *opt_embed = NULL; -static char *opt_class = NULL; + +static uchar utfbyte[UTF_SIZ + 1] = {0x80, 0, 0xC0, 0xE0, 0xF0}; +static uchar utfmask[UTF_SIZ + 1] = {0xC0, 0x80, 0xE0, 0xF0, 0xF8}; +static Rune utfmin[UTF_SIZ + 1] = { 0, 0, 0x80, 0x800, 0x10000}; +static Rune utfmax[UTF_SIZ + 1] = {0x10FFFF, 0x7F, 0x7FF, 0xFFFF, 0x10FFFF}; + +int buffCols; +extern int const buffSize; +int histOp, histMode, histOff, histOffX, insertOff, altToggle, *mark; +Line *buf = NULL; +static TCursor c[3]; +static inline int rows() { return IS_SET(MODE_ALTSCREEN) ? term.row : buffSize;} +static inline int rangeY(int i) { while (i < 0) i += rows(); return i % rows();} int -utf8decode(char *s, long *u) { - unsigned char c; - int i, n, rtn; - - rtn = 1; - c = *s; - if(~c&B7) { /* 0xxxxxxx */ - *u = c; - return rtn; - } else if((c&(B7|B6|B5)) == (B7|B6)) { /* 110xxxxx */ - *u = c&(B4|B3|B2|B1|B0); - n = 1; - } else if((c&(B7|B6|B5|B4)) == (B7|B6|B5)) { /* 1110xxxx */ - *u = c&(B3|B2|B1|B0); - n = 2; - } else if((c&(B7|B6|B5|B4|B3)) == (B7|B6|B5|B4)) { /* 11110xxx */ - *u = c&(B2|B1|B0); - n = 3; - } else - goto invalid; - for(i=n,++s; i>0; --i,++rtn,++s) { - c = *s; - if((c&(B7|B6)) != B7) /* 10xxxxxx */ - goto invalid; - *u <<= 6; - *u |= c&(B5|B4|B3|B2|B1|B0); - } - if((n == 1 && *u < 0x80) || - (n == 2 && *u < 0x800) || - (n == 3 && *u < 0x10000) || - (*u >= 0xD800 && *u <= 0xDFFF)) - goto invalid; - return rtn; -invalid: - *u = 0xFFFD; - return rtn; +subprocwd(char *path) +{ +#if defined(__linux) + if (snprintf(path, PATH_MAX, "/proc/%d/cwd", pid) < 0) + return -1; + return 0; +#elif defined(__OpenBSD__) + size_t sz = PATH_MAX; + int name[3] = {CTL_KERN, KERN_PROC_CWD, pid}; + if (sysctl(name, 3, path, &sz, 0, 0) == -1) + return -1; + return 0; +#endif } -int -utf8encode(long *u, char *s) { - unsigned char *sp; - unsigned long uc; - int i, n; - - sp = (unsigned char*) s; - uc = *u; - if(uc < 0x80) { - *sp = uc; /* 0xxxxxxx */ - return 1; - } else if(*u < 0x800) { - *sp = (uc >> 6) | (B7|B6); /* 110xxxxx */ - n = 1; - } else if(uc < 0x10000) { - *sp = (uc >> 12) | (B7|B6|B5); /* 1110xxxx */ - n = 2; - } else if(uc <= 0x10FFFF) { - *sp = (uc >> 18) | (B7|B6|B5|B4); /* 11110xxx */ - n = 3; - } else { - goto invalid; +ssize_t +xwrite(int fd, const char *s, size_t len) +{ + size_t aux = len; + ssize_t r; + + while (len > 0) { + r = write(fd, s, len); + if (r < 0) + return r; + len -= r; + s += r; } - for(i=n,++sp; i>0; --i,++sp) - *sp = ((uc >> 6*(i-1)) & (B5|B4|B3|B2|B1|B0)) | B7; /* 10xxxxxx */ - return n+1; -invalid: - /* U+FFFD */ - *s++ = '\xEF'; - *s++ = '\xBF'; - *s = '\xBD'; - return 3; + + return aux; } -/* use this if your buffer is less than UTF_SIZ, it returns 1 if you can decode - UTF-8 otherwise return 0 */ -int -isfullutf8(char *s, int b) { - unsigned char *c1, *c2, *c3; +void * +xmalloc(size_t len) +{ + void *p; - c1 = (unsigned char *) s; - c2 = (unsigned char *) ++s; - c3 = (unsigned char *) ++s; - if(b < 1) - return 0; - else if((*c1&(B7|B6|B5)) == (B7|B6) && b == 1) - return 0; - else if((*c1&(B7|B6|B5|B4)) == (B7|B6|B5) && - ((b == 1) || - ((b == 2) && (*c2&(B7|B6)) == B7))) - return 0; - else if((*c1&(B7|B6|B5|B4|B3)) == (B7|B6|B5|B4) && - ((b == 1) || - ((b == 2) && (*c2&(B7|B6)) == B7) || - ((b == 3) && (*c2&(B7|B6)) == B7 && (*c3&(B7|B6)) == B7))) - return 0; - else - return 1; + if (!(p = malloc(len))) + die("malloc: %s\n", strerror(errno)); + + return p; } -int -utf8size(char *s) { - unsigned char c = *s; +void * +xrealloc(void *p, size_t len) +{ + if ((p = realloc(p, len)) == NULL) + die("realloc: %s\n", strerror(errno)); - if(~c&B7) + return p; +} + +char * +xstrdup(char *s) +{ + if ((s = strdup(s)) == NULL) + die("strdup: %s\n", strerror(errno)); + + return s; +} + +size_t +utf8decode(const char *c, Rune *u, size_t clen) +{ + size_t i, j, len, type; + Rune udecoded; + + *u = UTF_INVALID; + if (!clen) + return 0; + udecoded = utf8decodebyte(c[0], &len); + if (!BETWEEN(len, 1, UTF_SIZ)) return 1; - else if((c&(B7|B6|B5)) == (B7|B6)) - return 2; - else if((c&(B7|B6|B5|B4)) == (B7|B6|B5)) - return 3; - else - return 4; + for (i = 1, j = 1; i < clen && j < len; ++i, ++j) { + udecoded = (udecoded << 6) | utf8decodebyte(c[i], &type); + if (type != 0) + return j; + } + if (j < len) + return 0; + *u = udecoded; + utf8validate(u, len); + + return len; } -void -selinit(void) { - sel.tclick1.tv_sec = 0; - sel.tclick1.tv_usec = 0; - sel.mode = 0; - sel.bx = -1; - sel.clip = NULL; - sel.xtarget = XInternAtom(xw.dpy, "UTF8_STRING", 0); - if(sel.xtarget == None) - sel.xtarget = XA_STRING; +Rune +utf8decodebyte(char c, size_t *i) +{ + for (*i = 0; *i < LEN(utfmask); ++(*i)) + if (((uchar)c & utfmask[*i]) == utfbyte[*i]) + return (uchar)c & ~utfmask[*i]; + + return 0; } -static inline int -selected(int x, int y) { - if(sel.ey == y && sel.by == y) { - int bx = MIN(sel.bx, sel.ex); - int ex = MAX(sel.bx, sel.ex); - return BETWEEN(x, bx, ex); +size_t +utf8encode(Rune u, char *c) +{ + size_t len, i; + + len = utf8validate(&u, 0); + if (len > UTF_SIZ) + return 0; + + for (i = len - 1; i != 0; --i) { + c[i] = utf8encodebyte(u, 0); + u >>= 6; } - return ((sel.b.y < y&&y < sel.e.y) || (y==sel.e.y && x<=sel.e.x)) - || (y==sel.b.y && x>=sel.b.x && (x<=sel.e.x || sel.b.y!=sel.e.y)); + c[0] = utf8encodebyte(u, len); + + return len; } -void -getbuttoninfo(XEvent *e, int *b, int *x, int *y) { - if(b) - *b = e->xbutton.button; +char +utf8encodebyte(Rune u, size_t i) +{ + return utfbyte[i] | (u & ~utfmask[i]); +} + +size_t +utf8validate(Rune *u, size_t i) +{ + if (!BETWEEN(*u, utfmin[i], utfmax[i]) || BETWEEN(*u, 0xD800, 0xDFFF)) + *u = UTF_INVALID; + for (i = 1; *u > utfmax[i]; ++i) + ; - *x = X2COL(e->xbutton.x); - *y = Y2ROW(e->xbutton.y); - sel.b.x = sel.by < sel.ey ? sel.bx : sel.ex; - sel.b.y = MIN(sel.by, sel.ey); - sel.e.x = sel.by < sel.ey ? sel.ex : sel.bx; - sel.e.y = MAX(sel.by, sel.ey); + return i; } -void -mousereport(XEvent *e) { - int x = X2COL(e->xbutton.x); - int y = Y2ROW(e->xbutton.y); - int button = e->xbutton.button; - int state = e->xbutton.state; - char buf[] = { '\033', '[', 'M', 0, 32+x+1, 32+y+1 }; - static int ob, ox, oy; - - /* from urxvt */ - if(e->xbutton.type == MotionNotify) { - if(!IS_SET(MODE_MOUSEMOTION) || (x == ox && y == oy)) - return; - button = ob + 32; - ox = x, oy = y; - } else if(e->xbutton.type == ButtonRelease || button == AnyButton) { - button = 3; - } else { - button -= Button1; - if(button >= 3) - button += 64 - 3; - if(e->xbutton.type == ButtonPress) { - ob = button; - ox = x, oy = y; - } +static const char base64_digits[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 62, 0, 0, 0, + 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 0, 0, 0, -1, 0, 0, 0, 0, 1, + 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 0, 0, 0, 0, 0, 0, 26, 27, 28, 29, 30, 31, 32, 33, 34, + 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 +}; + +char +base64dec_getc(const char **src) +{ + while (**src && !isprint(**src)) + (*src)++; + return **src ? *((*src)++) : '='; /* emulate padding if string ends */ +} + +char * +base64dec(const char *src) +{ + size_t in_len = strlen(src); + char *result, *dst; + + if (in_len % 4) + in_len += 4 - (in_len % 4); + result = dst = xmalloc(in_len / 4 * 3 + 1); + while (*src) { + int a = base64_digits[(unsigned char) base64dec_getc(&src)]; + int b = base64_digits[(unsigned char) base64dec_getc(&src)]; + int c = base64_digits[(unsigned char) base64dec_getc(&src)]; + int d = base64_digits[(unsigned char) base64dec_getc(&src)]; + + /* invalid input. 'a' can be -1, e.g. if src is "\n" (c-str) */ + if (a == -1 || b == -1) + break; + + *dst++ = (a << 2) | ((b & 0x30) >> 4); + if (c == -1) + break; + *dst++ = ((b & 0x0f) << 4) | ((c & 0x3c) >> 2); + if (d == -1) + break; + *dst++ = ((c & 0x03) << 6) | d; } - - buf[3] = 32 + button + (state & ShiftMask ? 4 : 0) - + (state & Mod4Mask ? 8 : 0) - + (state & ControlMask ? 16 : 0); - - ttywrite(buf, sizeof(buf)); + *dst = '\0'; + return result; } void -bpress(XEvent *e) { - if(IS_SET(MODE_MOUSE)) - mousereport(e); - else if(e->xbutton.button == Button1) { - sel.mode = 1; - sel.ex = sel.bx = X2COL(e->xbutton.x); - sel.ey = sel.by = Y2ROW(e->xbutton.y); +selinit(void) +{ + sel.mode = SEL_IDLE; + sel.snap = 0; + sel.ob.x = -1; +} + +int +tlinelen(int y) +{ + int i = term.col; + + if (term.line[y][i - 1].mode & ATTR_WRAP) + return i; + + while (i > 0 && term.line[y][i - 1].u == ' ') + --i; + + return i; +} + +void historyOpToggle(int start, int paint) { + if (!histOp == !(histOp + start)) if ((histOp += start) || 1) return; + if (histMode && paint && (!IS_SET(MODE_ALTSCREEN) || altToggle)) draw(); + tcursor(CURSOR_SAVE); + histOp += start; + if (histMode && altToggle) { + tswapscreen(); + memset(term.dirty,0,sizeof(*term.dirty)*term.row); } + tcursor(CURSOR_LOAD); + *(!IS_SET(MODE_ALTSCREEN)?&term.line:&term.alt)=&buf[histOp?histOff:insertOff]; } -void -selcopy(void) { - char *str, *ptr; - int x, y, sz, sl, ls = 0; - - if(sel.bx == -1) - str = NULL; - else { - sz = (term.col+1) * (sel.e.y-sel.b.y+1) * UTF_SIZ; - ptr = str = malloc(sz); - for(y = 0; y < term.row; y++) { - for(x = 0; x < term.col; x++) - if(term.line[y][x].state & GLYPH_SET && (ls = selected(x, y))) { - sl = utf8size(term.line[y][x].c); - memcpy(ptr, term.line[y][x].c, sl); - ptr += sl; - } - if(ls && y < sel.e.y) - *ptr++ = '\n'; - } - *ptr = 0; +void historyModeToggle(int start) { + if (!(histMode = (histOp = !!start))) { + selnormalize(); + tfulldirt(); + } else { + tcursor(CURSOR_SAVE); + histOp = 0; + histOff = insertOff; } - xsetsel(str); } -void -selnotify(XEvent *e) { - unsigned long nitems, ofs, rem; - int format; - unsigned char *data; - Atom type; - - ofs = 0; - do { - if(XGetWindowProperty(xw.dpy, xw.win, XA_PRIMARY, ofs, BUFSIZ/4, - False, AnyPropertyType, &type, &format, - &nitems, &rem, &data)) { - fprintf(stderr, "Clipboard allocation failed\n"); - return; +int historyBufferScroll(int n) { + if (IS_SET(MODE_ALTSCREEN) || !n) return histOp; + int p=abs(n=(n<0) ? max(n,-term.row) : min(n,term.row)), r=term.row-p, + s=sizeof(*term.dirty), *ptr=histOp?&histOff:&insertOff; + if (!histMode || histOp) tfulldirt(); else { + memmove(&term.dirty[-min(n,0)], &term.dirty[max(n,0)], s*r); + memset(&term.dirty[n>0 ? r : 0], 0, s * p); + } + int const prevOffBuf = sel.alt ? 0 : insertOff + term.row; + term.line = &buf[*ptr = (buffSize+*ptr+n) % buffSize]; + // Cut part of selection removed from buffer, and update sel.ne/b. + if (sel.ob.x != -1 && !histOp && n) { + int const offBuf = sel.alt ? 0 : insertOff + term.row, + pb = rangeY(sel.ob.y - prevOffBuf), + pe = rangeY(sel.oe.y - prevOffBuf); + int const b = rangeY(sel.ob.y - offBuf), nln = n < 0, + e = rangeY(sel.oe.y - offBuf), last = offBuf - nln; + if (pb != b && ((pb < b) != nln)) sel.ob.y = last; + if (pe != e && ((pe < e) != nln)) sel.oe.y = last; + if (sel.oe.y == last && sel.ob.y == last) selclear(); + } + selnormalize(); + // Clear the new region exposed by the shift. + if (!histOp) tclearregion(0, n>0?r+1:0, buffCols-1, n>0?term.row:p-1); + return 1; +} + +int historyMove(int x, int y, int ly) { + historyOpToggle(1, 1); + y += ((term.c.x += x) < 0 ?term.c.x-term.col :term.c.x) / term.col;//< x + if ((term.c.x %= term.col) < 0) term.c.x += term.col; + if ((term.c.y += y) >= term.row) ly += term.c.y - term.row + 1; //< y + else if (term.c.y < 0) ly += term.c.y; + term.c.y = MIN(MAX(term.c.y, 0), term.row - 1); + int off=insertOff-histOff, bot=rangeY(off), top=-rangeY(-term.row-off), + pTop = (-ly>-top), pBot = (ly > bot), fin=histMode&&(pTop||pBot); + if (fin && (x||y)) term.c.x = pBot ? term.col-1 : 0; + historyBufferScroll(fin ? (pBot ? bot : top) : ly); + historyOpToggle(-1, 1); + return fin; +} + +#include "normalMode.c" + +void selnormalize(void) { + historyOpToggle(1, 1); + + int const oldb = sel.nb.y, olde = sel.ne.y; + if (sel.ob.x == -1) { + sel.ne.y = sel.nb.y = -1; + } else { + int const offsetBuffer = sel.alt ? 0 : insertOff + term.row; + int const off = sel.alt ? 0 : (histMode ? histOff : insertOff); + int const nby = rangeY(sel.ob.y - off), + ney = rangeY(sel.oe.y - off); + sel.swap = rangeY(sel.ob.y - offsetBuffer) + > rangeY(sel.oe.y - offsetBuffer); + sel.nb.y = sel.swap ? ney : nby; + sel.ne.y = !sel.swap ? ney : nby; + int const cnb = sel.nb.y < term.row, cne = sel.ne.y < term.row; + if (sel.type == SEL_REGULAR && sel.ob.y != sel.oe.y) { + if (cnb) sel.nb.x = (!sel.swap) ? sel.ob.x : sel.oe.x; + if (cne) sel.ne.x = (!sel.swap) ? sel.oe.x : sel.ob.x; + } else { + if (cnb) sel.nb.x = MIN(sel.ob.x, sel.oe.x); + if (cne) sel.ne.x = MAX(sel.ob.x, sel.oe.x); } - ttywrite((const char *) data, nitems * format / 8); - XFree(data); - /* number of 32-bit chunks returned */ - ofs += nitems * format / 32; - } while(rem > 0); -} + } + int const nBet=sel.nb.y<=sel.ne.y, oBet=oldb<=olde; + for (int i = 0; i < term.row; ++i) { + int const n = nBet ? BETWEEN(i, sel.nb.y, sel.ne.y) + : OUT(i, sel.nb.y, sel.ne.y); + term.dirty[i] |= (sel.type == SEL_RECTANGULAR && n) || + (n != (oBet ? BETWEEN(i,oldb,olde) : OUT(i,oldb,olde))); -void -selpaste() { - XConvertSelection(xw.dpy, XA_PRIMARY, sel.xtarget, XA_PRIMARY, xw.win, CurrentTime); + } + if (BETWEEN(oldb, 0, term.row - 1)) term.dirty[oldb] = 1; + if (BETWEEN(olde, 0, term.row - 1)) term.dirty[olde] = 1; + if (BETWEEN(sel.nb.y, 0, term.row - 1)) term.dirty[sel.nb.y] = 1; + if (BETWEEN(sel.ne.y, 0, term.row - 1)) term.dirty[sel.ne.y] = 1; + + historyOpToggle(-1, 1); } void -selrequest(XEvent *e) { - XSelectionRequestEvent *xsre; - XSelectionEvent xev; - Atom xa_targets; - - xsre = (XSelectionRequestEvent *) e; - xev.type = SelectionNotify; - xev.requestor = xsre->requestor; - xev.selection = xsre->selection; - xev.target = xsre->target; - xev.time = xsre->time; - /* reject */ - xev.property = None; - - xa_targets = XInternAtom(xw.dpy, "TARGETS", 0); - if(xsre->target == xa_targets) { - /* respond with the supported type */ - Atom string = sel.xtarget; - XChangeProperty(xsre->display, xsre->requestor, xsre->property, - XA_ATOM, 32, PropModeReplace, - (unsigned char *) &string, 1); - xev.property = xsre->property; - } else if(xsre->target == sel.xtarget) { - XChangeProperty(xsre->display, xsre->requestor, xsre->property, - xsre->target, 8, PropModeReplace, - (unsigned char *) sel.clip, strlen(sel.clip)); - xev.property = xsre->property; - } - - /* all done, send a notification to the listener */ - if(!XSendEvent(xsre->display, xsre->requestor, True, 0, (XEvent *) &xev)) - fprintf(stderr, "Error sending SelectionNotify event\n"); +selstart(int col, int row, int snap) +{ + selclear(); + sel.mode = SEL_EMPTY; + sel.type = SEL_REGULAR; + sel.alt = IS_SET(MODE_ALTSCREEN); + sel.snap = snap; + sel.oe.x = sel.ob.x = col; + sel.oe.y = sel.ob.y = row + !sel.alt * (histMode ? histOff : insertOff); + if (sel.snap != 0) sel.mode = SEL_READY; + selnormalize(); } void -xsetsel(char *str) { - /* register the selection for both the clipboard and the primary */ - Atom clipboard; +selextend(int col, int row, int type, int done) +{ + if (sel.mode == SEL_IDLE) + return; + if (done && sel.mode == SEL_EMPTY) { + selclear(); + return; + } - free(sel.clip); - sel.clip = str; + sel.oe.x = col; + sel.oe.y = row + (sel.alt ? 0 : (histMode ? histOff : insertOff)); + selnormalize(); + sel.type = type; + sel.mode = done ? SEL_IDLE : SEL_READY; +} - XSetSelectionOwner(xw.dpy, XA_PRIMARY, xw.win, CurrentTime); +int +selected(int x, int y) +{ + if (sel.mode == SEL_EMPTY || sel.ob.x == -1 || + sel.alt != IS_SET(MODE_ALTSCREEN)) + return 0; - clipboard = XInternAtom(xw.dpy, "CLIPBOARD", 0); - XSetSelectionOwner(xw.dpy, clipboard, xw.win, CurrentTime); + if (sel.type == SEL_RECTANGULAR) + return BETWEEN(y, sel.nb.y, sel.ne.y) + && BETWEEN(x, sel.nb.x, sel.ne.x); - XFlush(xw.dpy); + return ((sel.nb.y > sel.ne.y) ? OUT(y, sel.nb.y, sel.ne.y) + : BETWEEN(y, sel.nb.y, sel.ne.y)) && + (y != sel.nb.y || x >= sel.nb.x) && + (y != sel.ne.y || x <= sel.ne.x); } -void -brelease(XEvent *e) { - if(IS_SET(MODE_MOUSE)) { - mousereport(e); - return; - } - if(e->xbutton.button == Button2) - selpaste(); - else if(e->xbutton.button == Button1) { - sel.mode = 0; - getbuttoninfo(e, NULL, &sel.ex, &sel.ey); - if(sel.bx == sel.ex && sel.by == sel.ey) { - struct timeval now; - sel.bx = -1; - gettimeofday(&now, NULL); - - if(TIMEDIFF(now, sel.tclick2) <= TRIPLECLICK_TIMEOUT) { - /* triple click on the line */ - sel.b.x = sel.bx = 0; - sel.e.x = sel.ex = term.col; - sel.b.y = sel.e.y = sel.ey; - selcopy(); - } else if(TIMEDIFF(now, sel.tclick1) <= DOUBLECLICK_TIMEOUT) { - /* double click to select word */ - sel.bx = sel.ex; - while(sel.bx > 0 && term.line[sel.ey][sel.bx-1].state & GLYPH_SET && - term.line[sel.ey][sel.bx-1].c[0] != ' ') sel.bx--; - sel.b.x = sel.bx; - while(sel.ex < term.col-1 && term.line[sel.ey][sel.ex+1].state & GLYPH_SET && - term.line[sel.ey][sel.ex+1].c[0] != ' ') sel.ex++; - sel.e.x = sel.ex; - sel.b.y = sel.e.y = sel.ey; - selcopy(); - } - } else - selcopy(); +char * +getsel(void) +{ + char *str, *ptr; + int y, yy, bufsize, lastx; + Glyph *gp, *last; + + if (sel.ob.x == -1) + return NULL; + + int const start = sel.swap ? sel.oe.y : sel.ob.y, h = rows(); + int endy = (sel.swap ? sel.ob.y : sel.oe.y); + for (; endy < start; endy += h); + Line * const cbuf = IS_SET(MODE_ALTSCREEN) ? term.line : buf; + bufsize = (term.col+1) * (endy-start+1 ) * UTF_SIZ; + assert(bufsize > 0); + ptr = str = xmalloc(bufsize); + + /* append every set & selected glyph to the selection */ + for (y = start; y <= endy; y++) { + yy = y % h; + + if (sel.type == SEL_RECTANGULAR) { + gp = &cbuf[yy][sel.nb.x]; + lastx = sel.ne.x; + } else { + gp = &cbuf[yy][start == y ? sel.nb.x : 0]; + lastx = (endy == y) ? sel.ne.x : term.col-1; + } + last = &cbuf[yy][lastx]; + if (!(cbuf[yy][term.col - 1].mode & ATTR_WRAP)) + while (last > gp && last->u == ' ') --last; + + for ( ; gp <= last; ++gp) { + if (gp->mode & ATTR_WDUMMY) continue; + ptr += utf8encode(gp->u, ptr); + } + + /* + * 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. + */ + if ((y < endy || lastx >= term.col - 1) && + (!(last->mode & ATTR_WRAP) || sel.type == SEL_RECTANGULAR)) + *ptr++ = '\n'; } - memcpy(&sel.tclick2, &sel.tclick1, sizeof(struct timeval)); - gettimeofday(&sel.tclick1, NULL); - draw(); + *ptr = 0; + return str; } void -bmotion(XEvent *e) { - if(IS_SET(MODE_MOUSE)) { - mousereport(e); +selclear(void) +{ + if (sel.ob.x == -1) return; - } - if(sel.mode) { - int oldey = sel.ey, oldex = sel.ex; - getbuttoninfo(e, NULL, &sel.ex, &sel.ey); - - if(oldey != sel.ey || oldex != sel.ex) { - int starty = MIN(oldey, sel.ey); - int endy = MAX(oldey, sel.ey); - drawregion(0, (starty > 0 ? starty : 0), term.col, (endy < term.row ? endy+1 : term.row)); - } - } + sel.mode = SEL_IDLE; + sel.ob.x = -1; + selnormalize(); } void -die(const char *errstr, ...) { +die(const char *errstr, ...) +{ va_list ap; va_start(ap, errstr); vfprintf(stderr, errstr, ap); va_end(ap); - exit(EXIT_FAILURE); + exit(1); } void -execsh(void) { - char **args; - char *envshell = getenv("SHELL"); +execsh(char *cmd, char **args) +{ + char *sh, *prog, *arg; + const struct passwd *pw; + + errno = 0; + if ((pw = getpwuid(getuid())) == NULL) { + if (errno) + die("getpwuid: %s\n", strerror(errno)); + else + die("who are you?\n"); + } + + if ((sh = getenv("SHELL")) == NULL) + sh = (pw->pw_shell[0]) ? pw->pw_shell : cmd; + + if (args) { + prog = args[0]; + arg = NULL; + } else if (scroll) { + prog = scroll; + arg = utmp ? utmp : sh; + } else if (utmp) { + prog = utmp; + arg = NULL; + } else { + prog = sh; + arg = NULL; + } + DEFAULT(args, ((char *[]) {prog, arg, NULL})); - DEFAULT(envshell, "sh"); - putenv("TERM="TNAME); - args = opt_cmd ? opt_cmd : (char*[]){envshell, "-i", NULL}; - execvp(args[0], args); - exit(EXIT_FAILURE); + unsetenv("COLUMNS"); + unsetenv("LINES"); + unsetenv("TERMCAP"); + setenv("LOGNAME", pw->pw_name, 1); + setenv("USER", pw->pw_name, 1); + setenv("SHELL", sh, 1); + setenv("HOME", pw->pw_dir, 1); + setenv("TERM", termname, 1); + + signal(SIGCHLD, SIG_DFL); + signal(SIGHUP, SIG_DFL); + signal(SIGINT, SIG_DFL); + signal(SIGQUIT, SIG_DFL); + signal(SIGTERM, SIG_DFL); + signal(SIGALRM, SIG_DFL); + + execvp(prog, args); + _exit(1); } void -sigchld(int a) { - int stat = 0; - if(waitpid(pid, &stat, 0) < 0) - die("Waiting for pid %hd failed: %s\n", pid, SERRNO); - if(WIFEXITED(stat)) - exit(WEXITSTATUS(stat)); - else - exit(EXIT_FAILURE); +sigchld(int a) +{ + int stat; + pid_t p; + + if ((p = waitpid(pid, &stat, WNOHANG)) < 0) + die("waiting for pid %hd failed: %s\n", pid, strerror(errno)); + + if (pid != p) + return; + + if (WIFEXITED(stat) && WEXITSTATUS(stat)) + die("child exited with status %d\n", WEXITSTATUS(stat)); + else if (WIFSIGNALED(stat)) + die("child terminated due to signal %d\n", WTERMSIG(stat)); + _exit(0); } void -ttynew(void) { +stty(char **args) +{ + char cmd[_POSIX_ARG_MAX], **p, *q, *s; + size_t n, siz; + + if ((n = strlen(stty_args)) > sizeof(cmd)-1) + die("incorrect stty parameters\n"); + memcpy(cmd, stty_args, n); + q = cmd + n; + siz = sizeof(cmd) - n; + for (p = args; p && (s = *p); ++p) { + if ((n = strlen(s)) > siz-1) + die("stty parameter length too long\n"); + *q++ = ' '; + memcpy(q, s, n); + q += n; + siz -= n + 1; + } + *q = '\0'; + if (system(cmd) != 0) + perror("Couldn't call stty"); +} + +int +ttynew(char *line, char *cmd, char *out, char **args) +{ int m, s; - + + if (out) { + term.mode |= MODE_PRINT; + iofd = (!strcmp(out, "-")) ? + 1 : open(out, O_WRONLY | O_CREAT, 0666); + if (iofd < 0) { + fprintf(stderr, "Error opening %s:%s\n", + out, strerror(errno)); + } + } + + if (line) { + if ((cmdfd = open(line, O_RDWR)) < 0) + die("open line '%s' failed: %s\n", + line, strerror(errno)); + dup2(cmdfd, 0); + stty(args); + return cmdfd; + } + /* seems to work fine on linux, openbsd and freebsd */ - struct winsize w = {term.row, term.col, 0, 0}; - if(openpty(&m, &s, NULL, NULL, &w) < 0) - die("openpty failed: %s\n", SERRNO); + if (openpty(&m, &s, NULL, NULL, NULL) < 0) + die("openpty failed: %s\n", strerror(errno)); - switch(pid = fork()) { + switch (pid = fork()) { case -1: - die("fork failed\n"); + die("fork failed: %s\n", strerror(errno)); break; case 0: + close(iofd); setsid(); /* create a new process group */ - dup2(s, STDIN_FILENO); - dup2(s, STDOUT_FILENO); - dup2(s, STDERR_FILENO); - if(ioctl(s, TIOCSCTTY, NULL) < 0) - die("ioctl TIOCSCTTY failed: %s\n", SERRNO); + dup2(s, 0); + dup2(s, 1); + dup2(s, 2); + if (ioctl(s, TIOCSCTTY, NULL) < 0) + die("ioctl TIOCSCTTY failed: %s\n", strerror(errno)); close(s); close(m); - execsh(); +#ifdef __OpenBSD__ + if (pledge("stdio getpw proc exec", NULL) == -1) + die("pledge\n"); +#endif + execsh(cmd, args); break; default: +#ifdef __OpenBSD__ + if (pledge("stdio rpath tty proc ps exec", NULL) == -1) + die("pledge\n"); +#endif close(s); cmdfd = m; signal(SIGCHLD, sigchld); + break; } + return cmdfd; } -void -dump(char c) { - static int col; - fprintf(stderr, " %02x '%c' ", c, isprint(c)?c:'.'); - if(++col % 10 == 0) - fprintf(stderr, "\n"); -} - -void -ttyread(void) { +size_t +ttyread(void) +{ static char buf[BUFSIZ]; static int buflen = 0; - char *ptr; - char s[UTF_SIZ]; - int charsize; /* size of utf8 char in bytes */ - long utf8c; - int ret; + int ret, written; /* append read bytes to unprocessed bytes */ - if((ret = read(cmdfd, buf+buflen, LEN(buf)-buflen)) < 0) - die("Couldn't read from shell: %s\n", SERRNO); + ret = read(cmdfd, buf+buflen, LEN(buf)-buflen); + + switch (ret) { + case 0: + exit(0); + case -1: + die("couldn't read from shell: %s\n", strerror(errno)); + default: + buflen += ret; + written = twrite(buf, buflen, 0); + buflen -= written; + /* keep any incomplete UTF-8 byte sequence for the next call */ + if (buflen > 0) + memmove(buf, buf + written, buflen); + return ret; + } +} + +void +ttywrite(const char *s, size_t n, int may_echo) +{ + const char *next; - /* process every complete utf8 char */ - buflen += ret; - ptr = buf; - while(buflen >= UTF_SIZ || isfullutf8(ptr,buflen)) { - charsize = utf8decode(ptr, &utf8c); - utf8encode(&utf8c, s); - tputc(s); - ptr += charsize; - buflen -= charsize; + if (may_echo && IS_SET(MODE_ECHO)) + twrite(s, n, 1); + + if (!IS_SET(MODE_CRLF)) { + ttywriteraw(s, n); + return; } - /* keep any uncomplete utf8 char for the next call */ - memmove(buf, ptr, buflen); + /* This is similar to how the kernel handles ONLCR for ttys */ + while (n > 0) { + if (*s == '\r') { + next = s + 1; + ttywriteraw("\r\n", 2); + } else { + next = memchr(s, '\r', n); + DEFAULT(next, s + n); + ttywriteraw(s, next - s); + } + n -= next - s; + s = next; + } } void -ttywrite(const char *s, size_t n) { - if(write(cmdfd, s, n) == -1) - die("write error on tty: %s\n", SERRNO); +ttywriteraw(const char *s, size_t n) +{ + fd_set wfd, rfd; + ssize_t r; + size_t lim = 256; + + /* + * 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); + FD_ZERO(&rfd); + FD_SET(cmdfd, &wfd); + FD_SET(cmdfd, &rfd); + + /* Check if we can write. */ + if (pselect(cmdfd+1, &rfd, &wfd, NULL, NULL, NULL) < 0) { + if (errno == EINTR) + continue; + die("select failed: %s\n", strerror(errno)); + } + if (FD_ISSET(cmdfd, &wfd)) { + /* + * 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. + */ + if ((r = write(cmdfd, s, (n < lim)? n : lim)) < 0) + goto write_error; + if (r < n) { + /* + * We weren't able to write out everything. + * This means the buffer is getting full + * again. Empty it. + */ + if (n < lim) + lim = ttyread(); + n -= r; + s += r; + } else { + /* All bytes have been written. */ + break; + } + } + if (FD_ISSET(cmdfd, &rfd)) + lim = ttyread(); + } + return; + +write_error: + die("write error on tty: %s\n", strerror(errno)); } void -ttyresize(int x, int y) { +ttyresize(int tw, int th) +{ struct winsize w; w.ws_row = term.row; w.ws_col = term.col; - w.ws_xpixel = w.ws_ypixel = 0; - if(ioctl(cmdfd, TIOCSWINSZ, &w) < 0) - fprintf(stderr, "Couldn't set window size: %s\n", SERRNO); + w.ws_xpixel = tw; + w.ws_ypixel = th; + if (ioctl(cmdfd, TIOCSWINSZ, &w) < 0) + fprintf(stderr, "Couldn't set window size: %s\n", strerror(errno)); } void -tcursor(int mode) { - static TCursor c; +ttyhangup() +{ + /* Send SIGHUP to shell */ + kill(pid, SIGHUP); +} + +int +tattrset(int attr) +{ + int i, j; + + for (i = 0; i < term.row-1; i++) { + for (j = 0; j < term.col-1; j++) { + if (term.line[i][j].mode & attr) + return 1; + } + } + + return 0; +} + +void +tsetdirt(int top, int bot) +{ + int i; + + LIMIT(top, 0, term.row-1); + LIMIT(bot, 0, term.row-1); + + for (i = top; i <= bot; i++) + term.dirty[i] = 1; +} + +void +tsetdirtattr(int attr) +{ + int i, j; + + for (i = 0; i < term.row-1; i++) { + for (j = 0; j < term.col-1; j++) { + if (term.line[i][j].mode & attr) { + tsetdirt(i, i); + break; + } + } + } +} + +void +tfulldirt(void) +{ + tsetdirt(0, term.row-1); +} - if(mode == CURSOR_SAVE) - c = term.c; - else if(mode == CURSOR_LOAD) - term.c = c, tmoveto(c.x, c.y); +void +tcursor(int mode) +{ + int alt = (histOp) ? 0 : (IS_SET(MODE_ALTSCREEN) + 1); + + if (mode == CURSOR_SAVE) { + c[alt] = term.c; + } else if (mode == CURSOR_LOAD) { + term.c = c[alt]; + tmoveto(c[alt].x, c[alt].y); + } } void -treset(void) { +treset(void) +{ + uint i; + term.c = (TCursor){{ .mode = ATTR_NULL, - .fg = DefaultFG, - .bg = DefaultBG + .fg = defaultfg, + .bg = defaultbg }, .x = 0, .y = 0, .state = CURSOR_DEFAULT}; - - term.top = 0, term.bot = term.row - 1; - term.mode = MODE_WRAP; - tclearregion(0, 0, term.col-1, term.row-1); + + memset(term.tabs, 0, term.col * sizeof(*term.tabs)); + for (i = tabspaces; i < term.col; i += tabspaces) + term.tabs[i] = 1; + term.top = 0; + term.bot = term.row - 1; + term.mode = MODE_WRAP|MODE_UTF8; + memset(term.trantbl, CS_USA, sizeof(term.trantbl)); + term.charset = 0; + + for (i = 0; i < 2; i++) { + tmoveto(0, 0); + tcursor(CURSOR_SAVE); + tclearregion(0, 0, term.col-1, term.row-1); + tswapscreen(); + } } void -tnew(int col, int row) { - /* set screen size */ - term.row = row, term.col = col; - term.line = malloc(term.row * sizeof(Line)); - term.alt = malloc(term.row * sizeof(Line)); - for(row = 0; row < term.row; row++) { - term.line[row] = malloc(term.col * sizeof(Glyph)); - term.alt [row] = malloc(term.col * sizeof(Glyph)); - } - /* setup screen */ +tnew(int col, int row) +{ + term = (Term){ .c = { .attr = { .fg = defaultfg, .bg = defaultbg } } }; + tresize(col, row); treset(); } void -tswapscreen(void) { - Line* tmp = term.line; +tswapscreen(void) +{ + Line *tmp = term.line; + term.line = term.alt; term.alt = tmp; term.mode ^= MODE_ALTSCREEN; + tfulldirt(); +} + +void +newterm(const Arg* a) +{ + switch (fork()) { + case -1: + die("fork failed: %s\n", strerror(errno)); + break; + case 0: + chdir(getcwd_by_pid(pid)); + execlp("st", "./st", NULL); + break; + } +} + +static char *getcwd_by_pid(pid_t pid) { + char buf[32]; + snprintf(buf, sizeof buf, "/proc/%d/cwd", pid); + return realpath(buf, NULL); } void -tscrolldown(int orig, int n) { +tscrolldown(int orig, int n) +{ + if (historyBufferScroll(-n)) return; int i; Line temp; - + LIMIT(n, 0, term.bot-orig+1); + tsetdirt(orig, term.bot-n); tclearregion(0, term.bot-n+1, term.col-1, term.bot); - - for(i = term.bot; i >= orig+n; i--) { + + for (i = term.bot; i >= orig+n; i--) { temp = term.line[i]; term.line[i] = term.line[i-n]; term.line[i-n] = temp; } + + selscroll(orig, n); } void -tscrollup(int orig, int n) { +tscrollup(int orig, int n) +{ + if (historyBufferScroll(n)) return; int i; Line temp; + LIMIT(n, 0, term.bot-orig+1); - + tclearregion(0, orig, term.col-1, orig+n-1); - - for(i = orig; i <= term.bot-n; i++) { - temp = term.line[i]; - term.line[i] = term.line[i+n]; - term.line[i+n] = temp; + tsetdirt(orig+n, term.bot); + + for (i = orig; i <= term.bot-n; i++) { + temp = term.line[i]; + term.line[i] = term.line[i+n]; + term.line[i+n] = temp; + } + + selscroll(orig, -n); +} + +void +selscroll(int orig, int n) +{ + if (sel.ob.x == -1) + return; + + if (BETWEEN(sel.nb.y, orig, term.bot) != BETWEEN(sel.ne.y, orig, term.bot)) { + selclear(); + } else if (BETWEEN(sel.nb.y, orig, term.bot)) { + sel.ob.y += n; + sel.oe.y += n; + if (sel.ob.y < term.top || sel.ob.y > term.bot || + sel.oe.y < term.top || sel.oe.y > term.bot) { + selclear(); + } else { + selnormalize(); + } } } void -tnewline(int first_col) { +tnewline(int first_col) +{ int y = term.c.y; - if(y == term.bot) + + if (y == term.bot) { tscrollup(term.top, 1); - else + } else { y++; + } tmoveto(first_col ? 0 : term.c.x, y); } void -csiparse(void) { - /* int noarg = 1; */ - char *p = escseq.buf; - - escseq.narg = 0; - if(*p == '?') - escseq.priv = 1, p++; - - while(p < escseq.buf+escseq.len) { - while(isdigit(*p)) { - escseq.arg[escseq.narg] *= 10; - escseq.arg[escseq.narg] += *p++ - '0'/*, noarg = 0 */; - } - if(*p == ';' && escseq.narg+1 < ESC_ARG_SIZ) - escseq.narg++, p++; - else { - escseq.mode = *p; - escseq.narg++; - return; - } +csiparse(void) +{ + char *p = csiescseq.buf, *np; + long int v; + + csiescseq.narg = 0; + if (*p == '?') { + csiescseq.priv = 1; + p++; } + + csiescseq.buf[csiescseq.len] = '\0'; + while (p < csiescseq.buf+csiescseq.len) { + np = NULL; + v = strtol(p, &np, 10); + if (np == p) + v = 0; + if (v == LONG_MAX || v == LONG_MIN) + v = -1; + csiescseq.arg[csiescseq.narg++] = v; + p = np; + if (*p != ';' || csiescseq.narg == ESC_ARG_SIZ) + break; + p++; + } + csiescseq.mode[0] = *p++; + csiescseq.mode[1] = (p < csiescseq.buf+csiescseq.len) ? *p : '\0'; } +/* for absolute user moves, when decom is set */ void -tmoveto(int x, int y) { - LIMIT(x, 0, term.col-1); - LIMIT(y, 0, term.row-1); +tmoveato(int x, int y) +{ + tmoveto(x, y + ((term.c.state & CURSOR_ORIGIN) ? term.top: 0)); +} + +void +tmoveto(int x, int y) +{ + int miny, maxy; + + if (term.c.state & CURSOR_ORIGIN) { + miny = term.top; + maxy = term.bot; + } else { + miny = 0; + maxy = term.row - 1; + } term.c.state &= ~CURSOR_WRAPNEXT; - term.c.x = x; - term.c.y = y; + term.c.x = LIMIT(x, 0, term.col-1); + term.c.y = LIMIT(y, miny, maxy); } void -tsetchar(char *c) { - term.line[term.c.y][term.c.x] = term.c.attr; - memcpy(term.line[term.c.y][term.c.x].c, c, UTF_SIZ); - term.line[term.c.y][term.c.x].state |= GLYPH_SET; +tsetchar(Rune u, Glyph *attr, int x, int y) +{ + static char *vt100_0[62] = { /* 0x41 - 0x7e */ + "↑", "↓", "→", "←", "█", "▚", "☃", /* 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 - ~ */ + }; + + /* + * The table is proudly stolen from rxvt. + */ + if (term.trantbl[term.charset] == CS_GRAPHIC0 && + BETWEEN(u, 0x41, 0x7e) && vt100_0[u - 0x41]) + utf8decode(vt100_0[u - 0x41], &u, UTF_SIZ); + + if (term.line[y][x].mode & ATTR_WIDE) { + if (x+1 < term.col) { + term.line[y][x+1].u = ' '; + term.line[y][x+1].mode &= ~ATTR_WDUMMY; + } + } else if (term.line[y][x].mode & ATTR_WDUMMY) { + term.line[y][x-1].u = ' '; + term.line[y][x-1].mode &= ~ATTR_WIDE; + } + + term.dirty[y] = 1; + term.line[y][x] = *attr; + term.line[y][x].u = u; } void -tclearregion(int x1, int y1, int x2, int y2) { +tclearregion(int x1, int y1, int x2, int y2) +{ int x, y, temp; + Glyph *gp; - if(x1 > x2) + if (x1 > x2) temp = x1, x1 = x2, x2 = temp; - if(y1 > y2) + if (y1 > y2) temp = y1, y1 = y2, y2 = temp; - LIMIT(x1, 0, term.col-1); - LIMIT(x2, 0, term.col-1); + LIMIT(x1, 0, buffCols-1); + LIMIT(x2, 0, buffCols-1); LIMIT(y1, 0, term.row-1); LIMIT(y2, 0, term.row-1); - for(y = y1; y <= y2; y++) - for(x = x1; x <= x2; x++) - term.line[y][x].state = 0; + for (y = y1; y <= y2; y++) { + term.dirty[y] = 1; + for (x = x1; x <= x2; x++) { + gp = &term.line[y][x]; + gp->fg = term.c.attr.fg; + gp->bg = term.c.attr.bg; + gp->mode = 0; + gp->u = ' '; + } + } } void -tdeletechar(int n) { - int src = term.c.x + n; - int dst = term.c.x; - int size = term.col - src; +tdeletechar(int n) +{ + int dst, src, size; + Glyph *line; - if(src >= term.col) { - tclearregion(term.c.x, term.c.y, term.col-1, term.c.y); - return; - } - memmove(&term.line[term.c.y][dst], &term.line[term.c.y][src], size * sizeof(Glyph)); + LIMIT(n, 0, term.col - term.c.x); + + dst = term.c.x; + src = term.c.x + n; + size = term.col - src; + line = term.line[term.c.y]; + + memmove(&line[dst], &line[src], size * sizeof(Glyph)); tclearregion(term.col-n, term.c.y, term.col-1, term.c.y); } void -tinsertblank(int n) { - int src = term.c.x; - int dst = src + n; - int size = term.col - dst; +tinsertblank(int n) +{ + int dst, src, size; + Glyph *line; - if(dst >= term.col) { - tclearregion(term.c.x, term.c.y, term.col-1, term.c.y); - return; - } - memmove(&term.line[term.c.y][dst], &term.line[term.c.y][src], size * sizeof(Glyph)); + LIMIT(n, 0, term.col - term.c.x); + + dst = term.c.x + n; + src = term.c.x; + size = term.col - dst; + line = term.line[term.c.y]; + + memmove(&line[dst], &line[src], size * sizeof(Glyph)); tclearregion(src, term.c.y, dst - 1, term.c.y); } void -tinsertblankline(int n) { - if(term.c.y < term.top || term.c.y > term.bot) - return; - - tscrolldown(term.c.y, n); +tinsertblankline(int n) +{ + if (BETWEEN(term.c.y, term.top, term.bot)) + tscrolldown(term.c.y, n); } void -tdeleteline(int n) { - if(term.c.y < term.top || term.c.y > term.bot) - return; +tdeleteline(int n) +{ + if (BETWEEN(term.c.y, term.top, term.bot)) + tscrollup(term.c.y, n); +} + +int32_t +tdefcolor(int *attr, int *npar, int l) +{ + int32_t idx = -1; + uint r, g, b; + + switch (attr[*npar + 1]) { + case 2: /* direct color in RGB space */ + 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; + if (!BETWEEN(r, 0, 255) || !BETWEEN(g, 0, 255) || !BETWEEN(b, 0, 255)) + fprintf(stderr, "erresc: bad rgb color (%u,%u,%u)\n", + r, g, b); + else + idx = TRUECOLOR(r, g, b); + break; + case 5: /* indexed color */ + if (*npar + 2 >= l) { + fprintf(stderr, + "erresc(38): Incorrect number of parameters (%d)\n", + *npar); + break; + } + *npar += 2; + if (!BETWEEN(attr[*npar], 0, 255)) + fprintf(stderr, "erresc: bad fgcolor %d\n", attr[*npar]); + else + idx = attr[*npar]; + break; + case 0: /* implemented defined (only foreground) */ + case 1: /* transparent */ + case 3: /* direct color in CMY space */ + case 4: /* direct color in CMYK space */ + default: + fprintf(stderr, + "erresc(38): gfx attr %d unknown\n", attr[*npar]); + break; + } - tscrollup(term.c.y, n); + return idx; } void -tsetattr(int *attr, int l) { +tsetattr(int *attr, int l) +{ int i; + int32_t idx; - for(i = 0; i < l; i++) { - switch(attr[i]) { + for (i = 0; i < l; i++) { + switch (attr[i]) { case 0: - term.c.attr.mode &= ~(ATTR_REVERSE | ATTR_UNDERLINE | ATTR_BOLD); - term.c.attr.fg = DefaultFG; - term.c.attr.bg = DefaultBG; + term.c.attr.mode &= ~( + ATTR_BOLD | + ATTR_FAINT | + ATTR_ITALIC | + ATTR_UNDERLINE | + ATTR_BLINK | + ATTR_REVERSE | + ATTR_INVISIBLE | + ATTR_STRUCK ); + term.c.attr.fg = defaultfg; + term.c.attr.bg = defaultbg; break; case 1: term.c.attr.mode |= ATTR_BOLD; break; + case 2: + term.c.attr.mode |= ATTR_FAINT; + break; + case 3: + term.c.attr.mode |= ATTR_ITALIC; + break; case 4: term.c.attr.mode |= ATTR_UNDERLINE; break; + case 5: /* slow blink */ + /* FALLTHROUGH */ + case 6: /* rapid blink */ + term.c.attr.mode |= ATTR_BLINK; + break; case 7: term.c.attr.mode |= ATTR_REVERSE; break; + case 8: + term.c.attr.mode |= ATTR_INVISIBLE; + break; + case 9: + term.c.attr.mode |= ATTR_STRUCK; + break; case 22: - term.c.attr.mode &= ~ATTR_BOLD; + term.c.attr.mode &= ~(ATTR_BOLD | ATTR_FAINT); + break; + case 23: + term.c.attr.mode &= ~ATTR_ITALIC; break; case 24: term.c.attr.mode &= ~ATTR_UNDERLINE; break; + case 25: + term.c.attr.mode &= ~ATTR_BLINK; + break; case 27: term.c.attr.mode &= ~ATTR_REVERSE; break; + case 28: + term.c.attr.mode &= ~ATTR_INVISIBLE; + break; + case 29: + term.c.attr.mode &= ~ATTR_STRUCK; + break; case 38: - if(i + 2 < l && attr[i + 1] == 5) { - i += 2; - if(BETWEEN(attr[i], 0, 255)) - term.c.attr.fg = attr[i]; - else - fprintf(stderr, "erresc: bad fgcolor %d\n", attr[i]); - } - else - fprintf(stderr, "erresc: gfx attr %d unknown\n", attr[i]); + if ((idx = tdefcolor(attr, &i, l)) >= 0) + term.c.attr.fg = idx; break; case 39: - term.c.attr.fg = DefaultFG; + term.c.attr.fg = defaultfg; break; case 48: - if(i + 2 < l && attr[i + 1] == 5) { - i += 2; - if(BETWEEN(attr[i], 0, 255)) - term.c.attr.bg = attr[i]; - else - fprintf(stderr, "erresc: bad bgcolor %d\n", attr[i]); - } - else - fprintf(stderr, "erresc: gfx attr %d unknown\n", attr[i]); + if ((idx = tdefcolor(attr, &i, l)) >= 0) + term.c.attr.bg = idx; break; case 49: - term.c.attr.bg = DefaultBG; + term.c.attr.bg = defaultbg; break; default: - if(BETWEEN(attr[i], 30, 37)) + if (BETWEEN(attr[i], 30, 37)) { term.c.attr.fg = attr[i] - 30; - else if(BETWEEN(attr[i], 40, 47)) + } else if (BETWEEN(attr[i], 40, 47)) { term.c.attr.bg = attr[i] - 40; - else if(BETWEEN(attr[i], 90, 97)) + } else if (BETWEEN(attr[i], 90, 97)) { term.c.attr.fg = attr[i] - 90 + 8; - else if(BETWEEN(attr[i], 100, 107)) - term.c.attr.fg = attr[i] - 100 + 8; - else - fprintf(stderr, "erresc: gfx attr %d unknown\n", attr[i]), csidump(); - + } else if (BETWEEN(attr[i], 100, 107)) { + term.c.attr.bg = attr[i] - 100 + 8; + } else { + fprintf(stderr, + "erresc(default): gfx attr %d unknown\n", + attr[i]); + csidump(); + } break; } } } void -tsetscroll(int t, int b) { +tsetscroll(int t, int b) +{ int temp; LIMIT(t, 0, term.row-1); LIMIT(b, 0, term.row-1); - if(t > b) { + if (t > b) { temp = t; t = b; b = temp; @@ -1019,8 +1511,142 @@ tsetscroll(int t, int b) { } void -csihandle(void) { - switch(escseq.mode) { +tsetmode(int priv, int set, int *args, int narg) +{ + int alt, *lim; + + for (lim = args + narg; args < lim; ++args) { + if (priv) { + switch (*args) { + case 1: /* DECCKM -- Cursor key */ + xsetmode(set, MODE_APPCURSOR); + break; + case 5: /* DECSCNM -- Reverse video */ + xsetmode(set, MODE_REVERSE); + break; + case 6: /* DECOM -- Origin */ + MODBIT(term.c.state, set, CURSOR_ORIGIN); + tmoveato(0, 0); + break; + case 7: /* DECAWM -- Auto wrap */ + MODBIT(term.mode, set, MODE_WRAP); + break; + case 0: /* Error (IGNORED) */ + 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) */ + case 12: /* att610 -- Start blinking cursor (IGNORED) */ + break; + case 25: /* DECTCEM -- Text Cursor Enable Mode */ + xsetmode(!set, MODE_HIDE); + break; + case 9: /* X10 mouse compatibility mode */ + xsetpointermotion(0); + xsetmode(0, MODE_MOUSE); + xsetmode(set, MODE_MOUSEX10); + break; + case 1000: /* 1000: report button press */ + xsetpointermotion(0); + xsetmode(0, MODE_MOUSE); + xsetmode(set, MODE_MOUSEBTN); + break; + case 1002: /* 1002: report motion on button press */ + xsetpointermotion(0); + xsetmode(0, MODE_MOUSE); + xsetmode(set, MODE_MOUSEMOTION); + break; + case 1003: /* 1003: enable all mouse motions */ + xsetpointermotion(set); + xsetmode(0, MODE_MOUSE); + xsetmode(set, MODE_MOUSEMANY); + break; + case 1004: /* 1004: send focus events to tty */ + xsetmode(set, MODE_FOCUS); + break; + case 1006: /* 1006: extended reporting mode */ + xsetmode(set, MODE_MOUSESGR); + break; + case 1034: + xsetmode(set, MODE_8BIT); + break; + case 1049: /* swap screen & set/restore cursor as xterm */ + if (!allowaltscreen) + break; + tcursor((set) ? CURSOR_SAVE : CURSOR_LOAD); + /* FALLTHROUGH */ + case 47: /* swap screen */ + case 1047: + if (!allowaltscreen) + break; + alt = IS_SET(MODE_ALTSCREEN); + if (alt) { + tclearregion(0, 0, term.col-1, + term.row-1); + } + if (set ^ alt) /* set is always 1 or 0 */ + tswapscreen(); + if (*args != 1049) + break; + /* FALLTHROUGH */ + case 1048: + tcursor((set) ? CURSOR_SAVE : CURSOR_LOAD); + break; + case 2004: /* 2004: bracketed paste mode */ + xsetmode(set, MODE_BRCKTPASTE); + break; + /* Not implemented mouse modes. See comments there. */ + case 1001: /* mouse highlight mode; can hang the + 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. */ + break; + default: + fprintf(stderr, + "erresc: unknown private set/reset mode %d\n", + *args); + break; + } + } else { + switch (*args) { + case 0: /* Error (IGNORED) */ + break; + case 2: + xsetmode(set, MODE_KBDLOCK); + break; + case 4: /* IRM -- Insertion-replacement */ + MODBIT(term.mode, set, MODE_INSERT); + break; + case 12: /* SRM -- Send/Receive */ + MODBIT(term.mode, !set, MODE_ECHO); + break; + case 20: /* LNM -- Linefeed/new line */ + MODBIT(term.mode, set, MODE_CRLF); + break; + default: + fprintf(stderr, + "erresc: unknown set/reset mode %d\n", + *args); + break; + } + } + } +} + +void +csihandle(void) +{ + char buf[40]; + int len; + + switch (csiescseq.mode[0]) { default: unknown: fprintf(stderr, "erresc: unknown csi "); @@ -1028,56 +1654,102 @@ csihandle(void) { /* die(""); */ break; case '@': /* ICH -- Insert blank char */ - DEFAULT(escseq.arg[0], 1); - tinsertblank(escseq.arg[0]); + DEFAULT(csiescseq.arg[0], 1); + tinsertblank(csiescseq.arg[0]); break; case 'A': /* CUU -- Cursor Up */ - case 'e': - DEFAULT(escseq.arg[0], 1); - tmoveto(term.c.x, term.c.y-escseq.arg[0]); + DEFAULT(csiescseq.arg[0], 1); + tmoveto(term.c.x, term.c.y-csiescseq.arg[0]); break; case 'B': /* CUD -- Cursor Down */ - DEFAULT(escseq.arg[0], 1); - tmoveto(term.c.x, term.c.y+escseq.arg[0]); + case 'e': /* VPR --Cursor Down */ + DEFAULT(csiescseq.arg[0], 1); + tmoveto(term.c.x, term.c.y+csiescseq.arg[0]); + break; + case 'i': /* MC -- Media Copy */ + switch (csiescseq.arg[0]) { + case 0: + tdump(); + break; + case 1: + tdumpline(term.c.y); + break; + case 2: + tdumpsel(); + break; + case 4: + term.mode &= ~MODE_PRINT; + break; + case 5: + term.mode |= MODE_PRINT; + break; + } + break; + case 'c': /* DA -- Device Attributes */ + if (csiescseq.arg[0] == 0) + ttywrite(vtiden, strlen(vtiden), 0); + break; + case 'b': /* REP -- if last char is printable print it more times */ + DEFAULT(csiescseq.arg[0], 1); + if (term.lastc) + while (csiescseq.arg[0]-- > 0) + tputc(term.lastc); break; case 'C': /* CUF -- Cursor Forward */ - case 'a': - DEFAULT(escseq.arg[0], 1); - tmoveto(term.c.x+escseq.arg[0], term.c.y); + case 'a': /* HPR -- Cursor Forward */ + DEFAULT(csiescseq.arg[0], 1); + tmoveto(term.c.x+csiescseq.arg[0], term.c.y); break; case 'D': /* CUB -- Cursor Backward */ - DEFAULT(escseq.arg[0], 1); - tmoveto(term.c.x-escseq.arg[0], term.c.y); + DEFAULT(csiescseq.arg[0], 1); + tmoveto(term.c.x-csiescseq.arg[0], term.c.y); break; case 'E': /* CNL -- Cursor Down and first col */ - DEFAULT(escseq.arg[0], 1); - tmoveto(0, term.c.y+escseq.arg[0]); + DEFAULT(csiescseq.arg[0], 1); + tmoveto(0, term.c.y+csiescseq.arg[0]); break; case 'F': /* CPL -- Cursor Up and first col */ - DEFAULT(escseq.arg[0], 1); - tmoveto(0, term.c.y-escseq.arg[0]); + DEFAULT(csiescseq.arg[0], 1); + tmoveto(0, term.c.y-csiescseq.arg[0]); + break; + case 'g': /* TBC -- Tabulation clear */ + switch (csiescseq.arg[0]) { + 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; case 'G': /* CHA -- Move to */ - case '`': /* XXX: HPA -- same? */ - DEFAULT(escseq.arg[0], 1); - tmoveto(escseq.arg[0]-1, term.c.y); + case '`': /* HPA */ + DEFAULT(csiescseq.arg[0], 1); + tmoveto(csiescseq.arg[0]-1, term.c.y); break; case 'H': /* CUP -- Move to */ - case 'f': /* XXX: HVP -- same? */ - DEFAULT(escseq.arg[0], 1); - DEFAULT(escseq.arg[1], 1); - tmoveto(escseq.arg[1]-1, escseq.arg[0]-1); + case 'f': /* HVP */ + DEFAULT(csiescseq.arg[0], 1); + DEFAULT(csiescseq.arg[1], 1); + tmoveato(csiescseq.arg[1]-1, csiescseq.arg[0]-1); + break; + case 'I': /* CHT -- Cursor Forward Tabulation tab stops */ + DEFAULT(csiescseq.arg[0], 1); + tputtab(csiescseq.arg[0]); break; - /* XXX: (CSI n I) CHT -- Cursor Forward Tabulation tab stops */ case 'J': /* ED -- Clear screen */ - switch(escseq.arg[0]) { + switch (csiescseq.arg[0]) { case 0: /* below */ tclearregion(term.c.x, term.c.y, term.col-1, term.c.y); - if(term.c.y < term.row-1) - tclearregion(0, term.c.y+1, term.col-1, term.row-1); + if (term.c.y < term.row-1) { + tclearregion(0, term.c.y+1, term.col-1, + term.row-1); + } break; case 1: /* above */ - if(term.c.y > 1) + if (term.c.y > 1) tclearregion(0, 0, term.col-1, term.c.y-1); tclearregion(0, term.c.y, term.c.x, term.c.y); break; @@ -1089,9 +1761,10 @@ csihandle(void) { } break; case 'K': /* EL -- Clear line */ - switch(escseq.arg[0]) { + switch (csiescseq.arg[0]) { case 0: /* right */ - tclearregion(term.c.x, term.c.y, term.col-1, term.c.y); + tclearregion(term.c.x, term.c.y, term.col-1, + term.c.y); break; case 1: /* left */ tclearregion(0, term.c.y, term.c.x, term.c.y); @@ -1102,153 +1775,62 @@ csihandle(void) { } break; case 'S': /* SU -- Scroll line up */ - DEFAULT(escseq.arg[0], 1); - tscrollup(term.top, escseq.arg[0]); + DEFAULT(csiescseq.arg[0], 1); + tscrollup(term.top, csiescseq.arg[0]); break; case 'T': /* SD -- Scroll line down */ - DEFAULT(escseq.arg[0], 1); - tscrolldown(term.top, escseq.arg[0]); + DEFAULT(csiescseq.arg[0], 1); + tscrolldown(term.top, csiescseq.arg[0]); break; case 'L': /* IL -- Insert blank lines */ - DEFAULT(escseq.arg[0], 1); - tinsertblankline(escseq.arg[0]); + DEFAULT(csiescseq.arg[0], 1); + tinsertblankline(csiescseq.arg[0]); break; case 'l': /* RM -- Reset Mode */ - if(escseq.priv) { - switch(escseq.arg[0]) { - case 1: - term.mode &= ~MODE_APPKEYPAD; - break; - case 5: /* DECSCNM -- Remove reverse video */ - if(IS_SET(MODE_REVERSE)) { - term.mode &= ~MODE_REVERSE; - draw(); - } - break; - case 7: - term.mode &= ~MODE_WRAP; - break; - case 12: /* att610 -- Stop blinking cursor (IGNORED) */ - break; - case 20: - term.mode &= ~MODE_CRLF; - break; - case 25: - term.c.state |= CURSOR_HIDE; - break; - case 1000: /* disable X11 xterm mouse reporting */ - term.mode &= ~MODE_MOUSEBTN; - break; - case 1002: - term.mode &= ~MODE_MOUSEMOTION; - break; - case 1049: /* = 1047 and 1048 */ - case 47: - case 1047: - if(IS_SET(MODE_ALTSCREEN)) { - tclearregion(0, 0, term.col-1, term.row-1); - tswapscreen(); - } - if(escseq.arg[0] != 1049) - break; - case 1048: - tcursor(CURSOR_LOAD); - break; - default: - goto unknown; - } - } else { - switch(escseq.arg[0]) { - case 4: - term.mode &= ~MODE_INSERT; - break; - default: - goto unknown; - } - } + tsetmode(csiescseq.priv, 0, csiescseq.arg, csiescseq.narg); break; case 'M': /* DL -- Delete lines */ - DEFAULT(escseq.arg[0], 1); - tdeleteline(escseq.arg[0]); + DEFAULT(csiescseq.arg[0], 1); + tdeleteline(csiescseq.arg[0]); break; case 'X': /* ECH -- Erase char */ - DEFAULT(escseq.arg[0], 1); - tclearregion(term.c.x, term.c.y, term.c.x + escseq.arg[0], term.c.y); + DEFAULT(csiescseq.arg[0], 1); + tclearregion(term.c.x, term.c.y, + term.c.x + csiescseq.arg[0] - 1, term.c.y); break; case 'P': /* DCH -- Delete char */ - DEFAULT(escseq.arg[0], 1); - tdeletechar(escseq.arg[0]); + DEFAULT(csiescseq.arg[0], 1); + tdeletechar(csiescseq.arg[0]); + break; + case 'Z': /* CBT -- Cursor Backward Tabulation tab stops */ + DEFAULT(csiescseq.arg[0], 1); + tputtab(-csiescseq.arg[0]); break; - /* XXX: (CSI n Z) CBT -- Cursor Backward Tabulation tab stops */ case 'd': /* VPA -- Move to */ - DEFAULT(escseq.arg[0], 1); - tmoveto(term.c.x, escseq.arg[0]-1); + DEFAULT(csiescseq.arg[0], 1); + tmoveato(term.c.x, csiescseq.arg[0]-1); break; case 'h': /* SM -- Set terminal mode */ - if(escseq.priv) { - switch(escseq.arg[0]) { - case 1: - term.mode |= MODE_APPKEYPAD; - break; - case 5: /* DECSCNM -- Reverve video */ - if(!IS_SET(MODE_REVERSE)) { - term.mode |= MODE_REVERSE; - draw(); - } - break; - case 7: - term.mode |= MODE_WRAP; - break; - case 20: - term.mode |= MODE_CRLF; - break; - case 12: /* att610 -- Start blinking cursor (IGNORED) */ - /* fallthrough for xterm cvvis = CSI [ ? 12 ; 25 h */ - if(escseq.narg > 1 && escseq.arg[1] != 25) - break; - case 25: - term.c.state &= ~CURSOR_HIDE; - break; - case 1000: /* 1000,1002: enable xterm mouse report */ - term.mode |= MODE_MOUSEBTN; - break; - case 1002: - term.mode |= MODE_MOUSEMOTION; - break; - case 1049: /* = 1047 and 1048 */ - case 47: - case 1047: - if(IS_SET(MODE_ALTSCREEN)) - tclearregion(0, 0, term.col-1, term.row-1); - else - tswapscreen(); - if(escseq.arg[0] != 1049) - break; - case 1048: - tcursor(CURSOR_SAVE); - break; - default: goto unknown; - } - } else { - switch(escseq.arg[0]) { - case 4: - term.mode |= MODE_INSERT; - break; - default: goto unknown; - } - }; + tsetmode(csiescseq.priv, 1, csiescseq.arg, csiescseq.narg); break; case 'm': /* SGR -- Terminal attribute (color) */ - tsetattr(escseq.arg, escseq.narg); + tsetattr(csiescseq.arg, csiescseq.narg); + break; + case 'n': /* DSR – Device Status Report (cursor position) */ + if (csiescseq.arg[0] == 6) { + len = snprintf(buf, sizeof(buf), "\033[%i;%iR", + term.c.y+1, term.c.x+1); + ttywrite(buf, len, 0); + } break; case 'r': /* DECSTBM -- Set Scrolling Region */ - if(escseq.priv) + if (csiescseq.priv) { goto unknown; - else { - DEFAULT(escseq.arg[0], 1); - DEFAULT(escseq.arg[1], term.row); - tsetscroll(escseq.arg[0]-1, escseq.arg[1]-1); - tmoveto(0, 0); + } else { + DEFAULT(csiescseq.arg[0], 1); + DEFAULT(csiescseq.arg[1], term.row); + tsetscroll(csiescseq.arg[0]-1, csiescseq.arg[1]-1); + tmoveato(0, 0); } break; case 's': /* DECSC -- Save cursor position (ANSI.SYS) */ @@ -1257,717 +1839,815 @@ csihandle(void) { case 'u': /* DECRC -- Restore cursor position (ANSI.SYS) */ tcursor(CURSOR_LOAD); break; + case ' ': + switch (csiescseq.mode[1]) { + case 'q': /* DECSCUSR -- Set Cursor Style */ + if (xsetcursor(csiescseq.arg[0])) + goto unknown; + break; + default: + goto unknown; + } + break; } } void -csidump(void) { - int i; - printf("ESC [ %s", escseq.priv ? "? " : ""); - if(escseq.narg) - for(i = 0; i < escseq.narg; i++) - printf("%d ", escseq.arg[i]); - if(escseq.mode) - putchar(escseq.mode); - putchar('\n'); -} - -void -csireset(void) { - memset(&escseq, 0, sizeof(escseq)); +csidump(void) +{ + size_t i; + uint c; + + fprintf(stderr, "ESC["); + for (i = 0; i < csiescseq.len; i++) { + c = csiescseq.buf[i] & 0xff; + if (isprint(c)) { + putc(c, stderr); + } else if (c == '\n') { + fprintf(stderr, "(\\n)"); + } else if (c == '\r') { + fprintf(stderr, "(\\r)"); + } else if (c == 0x1b) { + fprintf(stderr, "(\\e)"); + } else { + fprintf(stderr, "(%02x)", c); + } + } + putc('\n', stderr); } void -tputtab(void) { - int space = TAB - term.c.x % TAB; - tmoveto(term.c.x + space, term.c.y); +csireset(void) +{ + memset(&csiescseq, 0, sizeof(csiescseq)); } void -tputc(char *c) { - char ascii = *c; - if(term.esc & ESC_START) { - if(term.esc & ESC_CSI) { - escseq.buf[escseq.len++] = ascii; - if(BETWEEN(ascii, 0x40, 0x7E) || escseq.len >= ESC_BUF_SIZ) { - term.esc = 0; - csiparse(), csihandle(); - } - /* TODO: handle other OSC */ - } else if(term.esc & ESC_OSC) { - if(ascii == ';') { - term.titlelen = 0; - term.esc = ESC_START | ESC_TITLE; - } - } else if(term.esc & ESC_TITLE) { - if(ascii == '\a' || term.titlelen+1 >= ESC_TITLE_SIZ) { - term.esc = 0; - term.title[term.titlelen] = '\0'; - XStoreName(xw.dpy, xw.win, term.title); - } else { - term.title[term.titlelen++] = ascii; - } - } else if(term.esc & ESC_ALTCHARSET) { - switch(ascii) { - case '0': /* Line drawing crap */ - term.c.attr.mode |= ATTR_GFX; - break; - case 'B': /* Back to regular text */ - term.c.attr.mode &= ~ATTR_GFX; - break; - default: - fprintf(stderr, "esc unhandled charset: ESC ( %c\n", ascii); +strhandle(void) +{ + char *p = NULL, *dec; + int j, narg, par; + + term.esc &= ~(ESC_STR_END|ESC_STR); + strparse(); + par = (narg = strescseq.narg) ? atoi(strescseq.args[0]) : 0; + + switch (strescseq.type) { + case ']': /* OSC -- Operating System Command */ + switch (par) { + case 0: + case 1: + case 2: + if (narg > 1) + xsettitle(strescseq.args[1]); + return; + case 52: + if (narg > 2 && allowwindowops) { + dec = base64dec(strescseq.args[2]); + if (dec) { + xsetsel(dec); + xclipcopy(); + } else { + fprintf(stderr, "erresc: invalid base64\n"); + } } - term.esc = 0; - } else { - switch(ascii) { - case '[': - term.esc |= ESC_CSI; - break; - case ']': - term.esc |= ESC_OSC; - break; - case '(': - term.esc |= ESC_ALTCHARSET; - break; - case 'D': /* IND -- Linefeed */ - if(term.c.y == term.bot) - tscrollup(term.top, 1); - else - tmoveto(term.c.x, term.c.y+1); - term.esc = 0; - break; - case 'E': /* NEL -- Next line */ - tnewline(1); /* always go to first col */ - term.esc = 0; - break; - case 'M': /* RI -- Reverse index */ - if(term.c.y == term.top) - tscrolldown(term.top, 1); - else - tmoveto(term.c.x, term.c.y-1); - term.esc = 0; - break; - case 'c': /* RIS -- Reset to inital state */ - treset(); - term.esc = 0; - break; - case '=': /* DECPAM -- Application keypad */ - term.mode |= MODE_APPKEYPAD; - term.esc = 0; - break; - case '>': /* DECPNM -- Normal keypad */ - term.mode &= ~MODE_APPKEYPAD; - term.esc = 0; - break; - case '7': /* DECSC -- Save Cursor */ - tcursor(CURSOR_SAVE); - term.esc = 0; - break; - case '8': /* DECRC -- Restore Cursor */ - tcursor(CURSOR_LOAD); - term.esc = 0; + return; + case 4: /* color set */ + if (narg < 3) break; - default: - fprintf(stderr, "erresc: unknown sequence ESC 0x%02X '%c'\n", - (unsigned char) ascii, isprint(ascii)?ascii:'.'); - term.esc = 0; + p = strescseq.args[2]; + /* FALLTHROUGH */ + case 104: /* color reset, here p = NULL */ + j = (narg > 1) ? atoi(strescseq.args[1]) : -1; + if (xsetcolorname(j, p)) { + if (par == 104 && narg <= 1) + return; /* color reset without parameter */ + fprintf(stderr, "erresc: invalid color j=%d, p=%s\n", + j, p ? p : "(null)"); + } else { + /* + * TODO if defaultbg color is changed, borders + * are dirty + */ + redraw(); } + return; } - } else { - switch(ascii) { - case '\t': - tputtab(); - break; - case '\b': - tmoveto(term.c.x-1, term.c.y); - break; - case '\r': - tmoveto(0, term.c.y); - break; - case '\f': - case '\v': - case '\n': - /* go to first col if the mode is set */ - tnewline(IS_SET(MODE_CRLF)); - break; - case '\a': - if(!(xw.state & WIN_FOCUSED)) - xseturgency(1); - break; - case '\033': - csireset(); - term.esc = ESC_START; - break; - default: - if(IS_SET(MODE_WRAP) && term.c.state & CURSOR_WRAPNEXT) - tnewline(1); /* always go to first col */ - tsetchar(c); - if(term.c.x+1 < term.col) - tmoveto(term.c.x+1, term.c.y); - else - term.c.state |= CURSOR_WRAPNEXT; - } + break; + case 'k': /* old title set compatibility */ + xsettitle(strescseq.args[0]); + return; + case 'P': /* DCS -- Device Control String */ + case '_': /* APC -- Application Program Command */ + case '^': /* PM -- Privacy Message */ + return; } + + fprintf(stderr, "erresc: unknown str "); + strdump(); } -int -tresize(int col, int row) { - int i, x; - int minrow = MIN(row, term.row); - int mincol = MIN(col, term.col); - int slide = term.c.y - row + 1; +void +strparse(void) +{ + int c; + char *p = strescseq.buf; - if(col < 1 || row < 1) - return 0; + strescseq.narg = 0; + strescseq.buf[strescseq.len] = '\0'; - /* free unneeded rows */ - i = 0; - if(slide > 0) { - /* 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 */ - for(/* i = 0 */; i < slide; i++) { - free(term.line[i]); - free(term.alt[i]); - } - memmove(term.line, term.line + slide, row * sizeof(Line)); - memmove(term.alt, term.alt + slide, row * sizeof(Line)); - } - for(i += row; i < term.row; i++) { - free(term.line[i]); - free(term.alt[i]); - } - - /* resize to new height */ - term.line = realloc(term.line, row * sizeof(Line)); - term.alt = realloc(term.alt, row * sizeof(Line)); + if (*p == '\0') + return; - /* resize each row to new width, zero-pad if needed */ - for(i = 0; i < minrow; i++) { - term.line[i] = realloc(term.line[i], col * sizeof(Glyph)); - term.alt[i] = realloc(term.alt[i], col * sizeof(Glyph)); - for(x = mincol; x < col; x++) { - term.line[i][x].state = 0; - term.alt[i][x].state = 0; - } + while (strescseq.narg < STR_ARG_SIZ) { + strescseq.args[strescseq.narg++] = p; + while ((c = *p) != ';' && c != '\0') + ++p; + if (c == '\0') + return; + *p++ = '\0'; } +} - /* allocate any new rows */ - for(/* i == minrow */; i < row; i++) { - term.line[i] = calloc(col, sizeof(Glyph)); - term.alt [i] = calloc(col, sizeof(Glyph)); +void +strdump(void) +{ + size_t i; + uint c; + + fprintf(stderr, "ESC%c", strescseq.type); + for (i = 0; i < strescseq.len; i++) { + c = strescseq.buf[i] & 0xff; + if (c == '\0') { + putc('\n', stderr); + return; + } else if (isprint(c)) { + putc(c, stderr); + } else if (c == '\n') { + fprintf(stderr, "(\\n)"); + } else if (c == '\r') { + fprintf(stderr, "(\\r)"); + } else if (c == 0x1b) { + fprintf(stderr, "(\\e)"); + } else { + fprintf(stderr, "(%02x)", c); + } } - - /* update terminal size */ - term.col = col, term.row = row; - /* make use of the LIMIT in tmoveto */ - tmoveto(term.c.x, term.c.y); - /* reset scrolling region */ - tsetscroll(0, row-1); - return (slide > 0); + fprintf(stderr, "ESC\\\n"); } void -xresize(int col, int row) { - Pixmap newbuf; - int oldw, oldh; - - oldw = xw.bufw; - oldh = xw.bufh; - xw.bufw = MAX(1, col * xw.cw); - xw.bufh = MAX(1, row * xw.ch); - newbuf = XCreatePixmap(xw.dpy, xw.win, xw.bufw, xw.bufh, XDefaultDepth(xw.dpy, xw.scr)); - XCopyArea(xw.dpy, xw.buf, newbuf, dc.gc, 0, 0, xw.bufw, xw.bufh, 0, 0); - XFreePixmap(xw.dpy, xw.buf); - XSetForeground(xw.dpy, dc.gc, dc.col[DefaultBG]); - if(xw.bufw > oldw) - XFillRectangle(xw.dpy, newbuf, dc.gc, oldw, 0, - xw.bufw-oldw, MIN(xw.bufh, oldh)); - else if(xw.bufw < oldw && (BORDER > 0 || xw.w > xw.bufw)) - XClearArea(xw.dpy, xw.win, BORDER+xw.bufw, BORDER, - xw.w-xw.bufh-BORDER, BORDER+MIN(xw.bufh, oldh), - False); - if(xw.bufh > oldh) - XFillRectangle(xw.dpy, newbuf, dc.gc, 0, oldh, - xw.bufw, xw.bufh-oldh); - else if(xw.bufh < oldh && (BORDER > 0 || xw.h > xw.bufh)) - XClearArea(xw.dpy, xw.win, BORDER, BORDER+xw.bufh, - xw.w-2*BORDER, xw.h-xw.bufh-BORDER, - False); - xw.buf = newbuf; +strreset(void) +{ + strescseq = (STREscape){ + .buf = xrealloc(strescseq.buf, STR_BUF_SIZ), + .siz = STR_BUF_SIZ, + }; } void -xloadcols(void) { - int i, r, g, b; - XColor color; - unsigned long white = WhitePixel(xw.dpy, xw.scr); - - for(i = 0; i < 16; i++) { - if(!XAllocNamedColor(xw.dpy, xw.cmap, colorname[i], &color, &color)) { - dc.col[i] = white; - fprintf(stderr, "Could not allocate color '%s'\n", colorname[i]); - } else - dc.col[i] = color.pixel; - } - - /* same colors as xterm */ - for(r = 0; r < 6; r++) - for(g = 0; g < 6; g++) - for(b = 0; b < 6; b++) { - color.red = r == 0 ? 0 : 0x3737 + 0x2828 * r; - color.green = g == 0 ? 0 : 0x3737 + 0x2828 * g; - color.blue = b == 0 ? 0 : 0x3737 + 0x2828 * b; - if(!XAllocColor(xw.dpy, xw.cmap, &color)) { - dc.col[i] = white; - fprintf(stderr, "Could not allocate color %d\n", i); - } else - dc.col[i] = color.pixel; - i++; - } +sendbreak(const Arg *arg) +{ + if (tcsendbreak(cmdfd, 0)) + perror("Error sending break"); +} - for(r = 0; r < 24; r++, i++) { - color.red = color.green = color.blue = 0x0808 + 0x0a0a * r; - if (!XAllocColor(xw.dpy, xw.cmap, &color)) { - dc.col[i] = white; - fprintf(stderr, "Could not allocate color %d\n", i); - } else - dc.col[i] = color.pixel; +void +tprinter(char *s, size_t len) +{ + if (iofd != -1 && xwrite(iofd, s, len) < 0) { + perror("Error writing to output file"); + close(iofd); + iofd = -1; } } void -xclear(int x1, int y1, int x2, int y2) { - XSetForeground(xw.dpy, dc.gc, dc.col[IS_SET(MODE_REVERSE) ? DefaultFG : DefaultBG]); - XFillRectangle(xw.dpy, xw.buf, dc.gc, - x1 * xw.cw, y1 * xw.ch, - (x2-x1+1) * xw.cw, (y2-y1+1) * xw.ch); +toggleprinter(const Arg *arg) +{ + term.mode ^= MODE_PRINT; } void -xhints(void) { - XClassHint class = {opt_class ? opt_class : TNAME, TNAME}; - XWMHints wm = {.flags = InputHint, .input = 1}; - XSizeHints size = { - .flags = PSize | PResizeInc | PBaseSize, - .height = xw.h, - .width = xw.w, - .height_inc = xw.ch, - .width_inc = xw.cw, - .base_height = 2*BORDER, - .base_width = 2*BORDER, - }; - XSetWMProperties(xw.dpy, xw.win, NULL, NULL, NULL, 0, &size, &wm, &class); +printscreen(const Arg *arg) +{ + tdump(); } -XFontSet -xinitfont(char *fontstr) { - XFontSet set; - char *def, **missing; - int n; - - missing = NULL; - set = XCreateFontSet(xw.dpy, fontstr, &missing, &n, &def); - if(missing) { - while(n--) - fprintf(stderr, "st: missing fontset: %s\n", missing[n]); - XFreeStringList(missing); - } - return set; +void +printsel(const Arg *arg) +{ + tdumpsel(); } void -xgetfontinfo(XFontSet set, int *ascent, int *descent, short *lbearing, short *rbearing) { - XFontStruct **xfonts; - char **font_names; - int i, n; +tdumpsel(void) +{ + char *ptr; - *ascent = *descent = *lbearing = *rbearing = 0; - n = XFontsOfFontSet(set, &xfonts, &font_names); - for(i = 0; i < n; i++) { - *ascent = MAX(*ascent, (*xfonts)->ascent); - *descent = MAX(*descent, (*xfonts)->descent); - *lbearing = MAX(*lbearing, (*xfonts)->min_bounds.lbearing); - *rbearing = MAX(*rbearing, (*xfonts)->max_bounds.rbearing); - xfonts++; + if ((ptr = getsel())) { + tprinter(ptr, strlen(ptr)); + free(ptr); } } void -initfonts(char *fontstr, char *bfontstr) { - if((dc.font.set = xinitfont(fontstr)) == NULL || - (dc.bfont.set = xinitfont(bfontstr)) == NULL) - die("Can't load font %s\n", dc.font.set ? BOLDFONT : FONT); - xgetfontinfo(dc.font.set, &dc.font.ascent, &dc.font.descent, - &dc.font.lbearing, &dc.font.rbearing); - xgetfontinfo(dc.bfont.set, &dc.bfont.ascent, &dc.bfont.descent, - &dc.bfont.lbearing, &dc.bfont.rbearing); -} - -void -xinit(void) { - XSetWindowAttributes attrs; - Cursor cursor; - Window parent; - - if(!(xw.dpy = XOpenDisplay(NULL))) - die("Can't open display\n"); - xw.scr = XDefaultScreen(xw.dpy); - - /* font */ - initfonts(FONT, BOLDFONT); - - /* XXX: Assuming same size for bold font */ - xw.cw = dc.font.rbearing - dc.font.lbearing; - xw.ch = dc.font.ascent + dc.font.descent; - - /* colors */ - xw.cmap = XDefaultColormap(xw.dpy, xw.scr); - xloadcols(); - - /* window - default size */ - xw.bufh = 24 * xw.ch; - xw.bufw = 80 * xw.cw; - xw.h = xw.bufh + 2*BORDER; - xw.w = xw.bufw + 2*BORDER; - - attrs.background_pixel = dc.col[DefaultBG]; - attrs.border_pixel = dc.col[DefaultBG]; - attrs.bit_gravity = NorthWestGravity; - attrs.event_mask = FocusChangeMask | KeyPressMask - | ExposureMask | VisibilityChangeMask | StructureNotifyMask - | ButtonMotionMask | ButtonPressMask | ButtonReleaseMask - | EnterWindowMask | LeaveWindowMask; - attrs.colormap = xw.cmap; - - parent = opt_embed ? strtol(opt_embed, NULL, 0) : XRootWindow(xw.dpy, xw.scr); - xw.win = XCreateWindow(xw.dpy, parent, 0, 0, - xw.w, xw.h, 0, XDefaultDepth(xw.dpy, xw.scr), InputOutput, - XDefaultVisual(xw.dpy, xw.scr), - CWBackPixel | CWBorderPixel | CWBitGravity | CWEventMask - | CWColormap, - &attrs); - xw.buf = XCreatePixmap(xw.dpy, xw.win, xw.bufw, xw.bufh, XDefaultDepth(xw.dpy, xw.scr)); - - - /* input methods */ - xw.xim = XOpenIM(xw.dpy, NULL, NULL, NULL); - xw.xic = XCreateIC(xw.xim, XNInputStyle, XIMPreeditNothing - | XIMStatusNothing, XNClientWindow, xw.win, - XNFocusWindow, xw.win, NULL); - /* gc */ - dc.gc = XCreateGC(xw.dpy, xw.win, 0, NULL); - - /* white cursor, black outline */ - cursor = XCreateFontCursor(xw.dpy, XC_xterm); - XDefineCursor(xw.dpy, xw.win, cursor); - XRecolorCursor(xw.dpy, cursor, - &(XColor){.red = 0xffff, .green = 0xffff, .blue = 0xffff}, - &(XColor){.red = 0x0000, .green = 0x0000, .blue = 0x0000}); - - XStoreName(xw.dpy, xw.win, opt_title ? opt_title : "st"); - XMapWindow(xw.dpy, xw.win); - xhints(); - XSync(xw.dpy, 0); +tdumpline(int n) +{ + char buf[UTF_SIZ]; + Glyph *bp, *end; + + bp = &term.line[n][0]; + end = &bp[MIN(tlinelen(n), term.col) - 1]; + if (bp != end || bp->u != ' ') { + for ( ; bp <= end; ++bp) + tprinter(buf, utf8encode(bp->u, buf)); + } + tprinter("\n", 1); } void -xdraws(char *s, Glyph base, int x, int y, int charlen, int bytelen) { - unsigned long xfg = dc.col[base.fg], xbg = dc.col[base.bg], temp; - int winx = x*xw.cw, winy = y*xw.ch + dc.font.ascent, width = charlen*xw.cw; +tdump(void) +{ int i; - - /* only switch default fg/bg if term is in RV mode */ - if(IS_SET(MODE_REVERSE)) { - if(base.fg == DefaultFG) - xfg = dc.col[DefaultBG]; - if(base.bg == DefaultBG) - xbg = dc.col[DefaultFG]; - } - - if(base.mode & ATTR_REVERSE) - temp = xfg, xfg = xbg, xbg = temp; - - XSetBackground(xw.dpy, dc.gc, xbg); - XSetForeground(xw.dpy, dc.gc, xfg); - - if(base.mode & ATTR_GFX) { - for(i = 0; i < bytelen; i++) { - char c = gfx[(unsigned int)s[i] % 256]; - if(c) - s[i] = c; - else if(s[i] > 0x5f) - s[i] -= 0x5f; - } - } - XmbDrawImageString(xw.dpy, xw.buf, base.mode & ATTR_BOLD ? dc.bfont.set : dc.font.set, - dc.gc, winx, winy, s, bytelen); - - if(base.mode & ATTR_UNDERLINE) - XDrawLine(xw.dpy, xw.buf, dc.gc, winx, winy+1, winx+width-1, winy+1); + for (i = 0; i < term.row; ++i) + tdumpline(i); } void -xdrawcursor(void) { - static int oldx = 0; - static int oldy = 0; - int sl; - Glyph g = {{' '}, ATTR_NULL, DefaultBG, DefaultCS, 0}; - - LIMIT(oldx, 0, term.col-1); - LIMIT(oldy, 0, term.row-1); - - if(term.line[term.c.y][term.c.x].state & GLYPH_SET) - memcpy(g.c, term.line[term.c.y][term.c.x].c, UTF_SIZ); - - /* remove the old cursor */ - if(term.line[oldy][oldx].state & GLYPH_SET) { - sl = utf8size(term.line[oldy][oldx].c); - xdraws(term.line[oldy][oldx].c, term.line[oldy][oldx], oldx, oldy, 1, sl); - } else - xclear(oldx, oldy, oldx, oldy); - - /* draw the new one */ - if(!(term.c.state & CURSOR_HIDE) && (xw.state & WIN_FOCUSED)) { - sl = utf8size(g.c); - if(IS_SET(MODE_REVERSE)) - g.mode |= ATTR_REVERSE, g.fg = DefaultCS, g.bg = DefaultFG; - xdraws(g.c, g, term.c.x, term.c.y, 1, sl); - oldx = term.c.x, oldy = term.c.y; +tputtab(int n) +{ + uint x = term.c.x; + + if (n > 0) { + while (x < term.col && n--) + for (++x; x < term.col && !term.tabs[x]; ++x) + /* nothing */ ; + } else if (n < 0) { + while (x > 0 && n++) + for (--x; x > 0 && !term.tabs[x]; --x) + /* nothing */ ; } + term.c.x = LIMIT(x, 0, term.col-1); } void -draw() { - drawregion(0, 0, term.col, term.row); +tdefutf8(char ascii) +{ + if (ascii == 'G') + term.mode |= MODE_UTF8; + else if (ascii == '@') + term.mode &= ~MODE_UTF8; } void -drawregion(int x1, int y1, int x2, int y2) { - int ic, ib, x, y, ox, sl; - Glyph base, new; - char buf[DRAW_BUF_SIZ]; - - if(!(xw.state & WIN_VISIBLE)) - return; - - xclear(x1, y1, x2-1, y2-1); - for(y = y1; y < y2; y++) { - base = term.line[y][0]; - ic = ib = ox = 0; - for(x = x1; x < x2; x++) { - new = term.line[y][x]; - if(sel.bx != -1 && *(new.c) && selected(x, y)) - new.mode ^= ATTR_REVERSE; - if(ib > 0 && (!(new.state & GLYPH_SET) || ATTRCMP(base, new) || - ib >= DRAW_BUF_SIZ-UTF_SIZ)) { - xdraws(buf, base, ox, y, ic, ib); - ic = ib = 0; - } - if(new.state & GLYPH_SET) { - if(ib == 0) { - ox = x; - base = new; - } - sl = utf8size(new.c); - memcpy(buf+ib, new.c, sl); - ib += sl; - ++ic; - } - } - if(ib > 0) - xdraws(buf, base, ox, y, ic, ib); +tdeftran(char ascii) +{ + static char cs[] = "0B"; + static int vcs[] = {CS_GRAPHIC0, CS_USA}; + char *p; + + if ((p = strchr(cs, ascii)) == NULL) { + fprintf(stderr, "esc unhandled charset: ESC ( %c\n", ascii); + } else { + term.trantbl[term.icharset] = vcs[p - cs]; } - xdrawcursor(); - XCopyArea(xw.dpy, xw.buf, xw.win, dc.gc, 0, 0, xw.bufw, xw.bufh, BORDER, BORDER); } void -expose(XEvent *ev) { - XExposeEvent *e = &ev->xexpose; - if(xw.state & WIN_REDRAW) { - if(!e->count) { - xw.state &= ~WIN_REDRAW; - draw(); +tdectest(char c) +{ + int x, y; + + if (c == '8') { /* DEC screen alignment test. */ + for (x = 0; x < term.col; ++x) { + for (y = 0; y < term.row; ++y) + tsetchar('E', &term.c.attr, x, y); } - } else - XCopyArea(xw.dpy, xw.buf, xw.win, dc.gc, e->x-BORDER, e->y-BORDER, - e->width, e->height, e->x, e->y); + } } void -visibility(XEvent *ev) { - XVisibilityEvent *e = &ev->xvisibility; - if(e->state == VisibilityFullyObscured) - xw.state &= ~WIN_VISIBLE; - else if(!(xw.state & WIN_VISIBLE)) - /* need a full redraw for next Expose, not just a buf copy */ - xw.state |= WIN_VISIBLE | WIN_REDRAW; +tstrsequence(uchar c) +{ + switch (c) { + case 0x90: /* DCS -- Device Control String */ + c = 'P'; + break; + case 0x9f: /* APC -- Application Program Command */ + c = '_'; + break; + case 0x9e: /* PM -- Privacy Message */ + c = '^'; + break; + case 0x9d: /* OSC -- Operating System Command */ + c = ']'; + break; + } + strreset(); + strescseq.type = c; + term.esc |= ESC_STR; } void -unmap(XEvent *ev) { - xw.state &= ~WIN_VISIBLE; +tcontrolcode(uchar ascii) +{ + switch (ascii) { + case '\t': /* HT */ + tputtab(1); + return; + case '\b': /* BS */ + tmoveto(term.c.x-1, term.c.y); + return; + case '\r': /* CR */ + tmoveto(0, term.c.y); + return; + case '\f': /* LF */ + case '\v': /* VT */ + case '\n': /* LF */ + /* go to first col if the mode is set */ + tnewline(IS_SET(MODE_CRLF)); + return; + case '\a': /* BEL */ + if (term.esc & ESC_STR_END) { + /* backwards compatibility to xterm */ + strhandle(); + } else { + xbell(); + } + break; + case '\033': /* ESC */ + csireset(); + term.esc &= ~(ESC_CSI|ESC_ALTCHARSET|ESC_TEST); + term.esc |= ESC_START; + return; + case '\016': /* SO (LS1 -- Locking shift 1) */ + case '\017': /* SI (LS0 -- Locking shift 0) */ + term.charset = 1 - (ascii - '\016'); + return; + case '\032': /* SUB */ + tsetchar('?', &term.c.attr, term.c.x, term.c.y); + /* FALLTHROUGH */ + 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) */ + return; + case 0x80: /* TODO: PAD */ + case 0x81: /* TODO: HOP */ + case 0x82: /* TODO: BPH */ + case 0x83: /* TODO: NBH */ + case 0x84: /* TODO: IND */ + break; + case 0x85: /* NEL -- Next line */ + tnewline(1); /* always go to first col */ + break; + case 0x86: /* TODO: SSA */ + case 0x87: /* TODO: ESA */ + break; + case 0x88: /* HTS -- Horizontal tab stop */ + term.tabs[term.c.x] = 1; + break; + case 0x89: /* TODO: HTJ */ + case 0x8a: /* TODO: VTS */ + case 0x8b: /* TODO: PLD */ + case 0x8c: /* TODO: PLU */ + case 0x8d: /* TODO: RI */ + case 0x8e: /* TODO: SS2 */ + case 0x8f: /* TODO: SS3 */ + 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 */ + case 0x98: /* TODO: SOS */ + case 0x99: /* TODO: SGCI */ + break; + case 0x9a: /* DECID -- Identify Terminal */ + ttywrite(vtiden, strlen(vtiden), 0); + break; + case 0x9b: /* TODO: CSI */ + case 0x9c: /* TODO: ST */ + break; + case 0x90: /* DCS -- Device Control String */ + case 0x9d: /* OSC -- Operating System Command */ + case 0x9e: /* PM -- Privacy Message */ + case 0x9f: /* APC -- Application Program Command */ + tstrsequence(ascii); + return; + } + /* only CAN, SUB, \a and C1 chars interrupt a sequence */ + term.esc &= ~(ESC_STR_END|ESC_STR); } -void -xseturgency(int add) { - XWMHints *h = XGetWMHints(xw.dpy, xw.win); - h->flags = add ? (h->flags | XUrgencyHint) : (h->flags & ~XUrgencyHint); - XSetWMHints(xw.dpy, xw.win, h); - XFree(h); +/* + * returns 1 when the sequence is finished and it hasn't to read + * more characters for this sequence, otherwise 0 + */ +int +eschandle(uchar ascii) +{ + switch (ascii) { + case '[': + term.esc |= ESC_CSI; + return 0; + case '#': + term.esc |= ESC_TEST; + return 0; + case '%': + term.esc |= ESC_UTF8; + return 0; + 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; + case 'n': /* LS2 -- Locking shift 2 */ + case 'o': /* LS3 -- Locking shift 3 */ + term.charset = 2 + (ascii - 'n'); + break; + case '(': /* GZD4 -- set primary charset G0 */ + case ')': /* G1D4 -- set secondary charset G1 */ + case '*': /* G2D4 -- set tertiary charset G2 */ + case '+': /* G3D4 -- set quaternary charset G3 */ + term.icharset = ascii - '('; + term.esc |= ESC_ALTCHARSET; + return 0; + case 'D': /* IND -- Linefeed */ + if (term.c.y == term.bot) { + tscrollup(term.top, 1); + } else { + tmoveto(term.c.x, term.c.y+1); + } + 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 */ + if (term.c.y == term.top) { + tscrolldown(term.top, 1); + } else { + tmoveto(term.c.x, term.c.y-1); + } + break; + case 'Z': /* DECID -- Identify Terminal */ + ttywrite(vtiden, strlen(vtiden), 0); + break; + case 'c': /* RIS -- Reset to initial state */ + treset(); + resettitle(); + xloadcols(); + break; + case '=': /* DECPAM -- Application keypad */ + xsetmode(1, MODE_APPKEYPAD); + break; + case '>': /* DECPNM -- Normal keypad */ + xsetmode(0, 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 */ + if (term.esc & ESC_STR_END) + strhandle(); + break; + default: + fprintf(stderr, "erresc: unknown sequence ESC 0x%02X '%c'\n", + (uchar) ascii, isprint(ascii)? ascii:'.'); + break; + } + return 1; } void -focus(XEvent *ev) { - if(ev->type == FocusIn || ev->type == EnterNotify) { - xw.state |= WIN_FOCUSED; - xseturgency(0); - } else - xw.state &= ~WIN_FOCUSED; - draw(); -} +tputc(Rune u) +{ + char c[UTF_SIZ]; + int control; + int width, len; + Glyph *gp; + + control = ISCONTROL(u); + if (u < 127 || !IS_SET(MODE_UTF8)) { + c[0] = u; + width = len = 1; + } else { + len = utf8encode(u, c); + if (!control && (width = wcwidth(u)) == -1) + width = 1; + } -char* -kmap(KeySym k, unsigned int state) { - int i; - for(i = 0; i < LEN(key); i++) - if(key[i].k == k && (key[i].mask == 0 || key[i].mask & state)) - return (char*)key[i].s; - return NULL; -} + if (IS_SET(MODE_PRINT)) + tprinter(c, len); + + /* + * 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. + */ + if (term.esc & ESC_STR) { + if (u == '\a' || u == 030 || u == 032 || u == 033 || + ISCONTROLC1(u)) { + term.esc &= ~(ESC_START|ESC_STR); + term.esc |= ESC_STR_END; + goto check_control_code; + } -void -kpress(XEvent *ev) { - XKeyEvent *e = &ev->xkey; - KeySym ksym; - char buf[32]; - char *customkey; - int len; - int meta; - int shift; - Status status; - - meta = e->state & Mod1Mask; - shift = e->state & ShiftMask; - len = XmbLookupString(xw.xic, e, buf, sizeof(buf), &ksym, &status); - - /* 1. custom keys from config.h */ - if((customkey = kmap(ksym, e->state))) - ttywrite(customkey, strlen(customkey)); - /* 2. hardcoded (overrides X lookup) */ - else - switch(ksym) { - case XK_Up: - case XK_Down: - case XK_Left: - case XK_Right: - /* XXX: shift up/down doesn't work */ - sprintf(buf, "\033%c%c", IS_SET(MODE_APPKEYPAD) ? 'O' : '[', (shift ? "dacb":"DACB")[ksym - XK_Left]); - ttywrite(buf, 3); - break; - case XK_Insert: - if(shift) - selpaste(); - break; - case XK_Return: - if(IS_SET(MODE_CRLF)) - ttywrite("\r\n", 2); - else - ttywrite("\r", 1); - break; - /* 3. X lookup */ - default: - if(len > 0) { - if(meta && len == 1) - ttywrite("\033", 1); - ttywrite(buf, len); - } - break; + if (strescseq.len+len >= strescseq.siz) { + /* + * 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(); + */ + if (strescseq.siz > (SIZE_MAX - UTF_SIZ) / 2) + return; + strescseq.siz *= 2; + strescseq.buf = xrealloc(strescseq.buf, strescseq.siz); } -} -void -resize(XEvent *e) { - int col, row; - - if(e->xconfigure.width == xw.w && e->xconfigure.height == xw.h) + memmove(&strescseq.buf[strescseq.len], c, len); + strescseq.len += len; return; - - xw.w = e->xconfigure.width; - xw.h = e->xconfigure.height; - col = (xw.w - 2*BORDER) / xw.cw; - row = (xw.h - 2*BORDER) / xw.ch; - if(col == term.col && row == term.row) + } + +check_control_code: + /* + * 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. + */ + if (control) { + tcontrolcode(u); + /* + * control codes are not shown ever + */ + if (!term.esc) + term.lastc = 0; return; - if(tresize(col, row)) - draw(); - ttyresize(col, row); - xresize(col, row); -} + } else if (term.esc & ESC_START) { + if (term.esc & ESC_CSI) { + csiescseq.buf[csiescseq.len++] = u; + if (BETWEEN(u, 0x40, 0x7E) + || csiescseq.len >= \ + sizeof(csiescseq.buf)-1) { + term.esc = 0; + csiparse(); + csihandle(); + } + return; + } else if (term.esc & ESC_UTF8) { + tdefutf8(u); + } else if (term.esc & ESC_ALTCHARSET) { + tdeftran(u); + } else if (term.esc & ESC_TEST) { + tdectest(u); + } else { + if (!eschandle(u)) + return; + /* sequence already finished */ + } + term.esc = 0; + /* + * All characters which form part of a sequence are not + * printed + */ + return; + } + //if (selected(term.c.x, term.c.y)) + // selclear(); + + gp = &term.line[term.c.y][term.c.x]; + if (IS_SET(MODE_WRAP) && (term.c.state & CURSOR_WRAPNEXT)) { + gp->mode |= ATTR_WRAP; + tnewline(1); + gp = &term.line[term.c.y][term.c.x]; + } -void -run(void) { - XEvent ev; - fd_set rfd; - int xfd = XConnectionNumber(xw.dpy); + if (IS_SET(MODE_INSERT) && term.c.x+width < term.col) + memmove(gp+width, gp, (term.col - term.c.x - width) * sizeof(Glyph)); - for(;;) { - FD_ZERO(&rfd); - FD_SET(cmdfd, &rfd); - FD_SET(xfd, &rfd); - if(select(MAX(xfd, cmdfd)+1, &rfd, NULL, NULL, NULL) < 0) { - if(errno == EINTR) - continue; - die("select failed: %s\n", SERRNO); + if (term.c.x+width > term.col) { + tnewline(1); + gp = &term.line[term.c.y][term.c.x]; + } + + tsetchar(u, &term.c.attr, term.c.x, term.c.y); + term.lastc = u; + + if (width == 2) { + gp->mode |= ATTR_WIDE; + if (term.c.x+1 < term.col) { + gp[1].u = '\0'; + gp[1].mode = ATTR_WDUMMY; } - if(FD_ISSET(cmdfd, &rfd)) { - ttyread(); - draw(); + } + if (term.c.x+width < term.col) { + tmoveto(term.c.x+width, term.c.y); + } else { + term.c.state |= CURSOR_WRAPNEXT; + } +} + +int +twrite(const char *buf, int buflen, int show_ctrl) +{ + int charsize; + Rune u; + int n; + + for (n = 0; n < buflen; n += charsize) { + if (IS_SET(MODE_UTF8)) { + /* process a complete utf8 char */ + charsize = utf8decode(buf + n, &u, buflen - n); + if (charsize == 0) + break; + } else { + u = buf[n] & 0xFF; + charsize = 1; } - while(XPending(xw.dpy)) { - XNextEvent(xw.dpy, &ev); - if(XFilterEvent(&ev, xw.win)) - continue; - if(handler[ev.type]) - (handler[ev.type])(&ev); + if (show_ctrl && ISCONTROL(u)) { + if (u & 0x80) { + u &= 0x7f; + tputc('^'); + tputc('['); + } else if (u != '\n' && u != '\r' && u != '\t') { + u ^= 0x40; + tputc('^'); + } } + tputc(u); } + return n; } -int -main(int argc, char *argv[]) { +void +tresize(int col, int row) +{ int i; - - for(i = 1; i < argc; i++) { - switch(argv[i][0] != '-' || argv[i][2] ? -1 : argv[i][1]) { - case 't': - if(++i < argc) opt_title = argv[i]; - break; - case 'c': - if(++i < argc) opt_class = argv[i]; - break; - case 'w': - if(++i < argc) opt_embed = argv[i]; - break; - case 'e': - /* eat every remaining arguments */ - if(++i < argc) opt_cmd = &argv[i]; - goto run; - case 'v': - default: - die(USAGE); + int const colSet = col, alt = IS_SET(MODE_ALTSCREEN), ini = buf == NULL; + col = MAX(col, buffCols); + row = MIN(row, buffSize); + int const minrow = MIN(row, term.row), mincol = MIN(col, buffCols); + int *bp; + TCursor c; + + if (col < 1 || row < 1) { + fprintf(stderr, + "tresize: error resizing to %dx%d\n", col, row); + return; + } + if (alt) tswapscreen(); + + /* + * 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 + */ + for (i = 0; i <= term.c.y - row; i++) { + free(term.alt[i]); + } + /* ensure that both src and dst are not NULL */ + if (i > 0) { + memmove(term.alt, term.alt + i, row * sizeof(Line)); + } + for (i += row; i < term.row; i++) { + free(term.alt[i]); + } + + /* resize to new height */ + buf = xrealloc(buf, (buffSize + row) * sizeof(Line)); + term.alt = xrealloc(term.alt, row * sizeof(Line)); + term.dirty = xrealloc(term.dirty, row * sizeof(*term.dirty)); + mark = xrealloc(mark, col * row * sizeof(*mark)); + term.tabs = xrealloc(term.tabs, col * sizeof(*term.tabs)); + + /* resize each row to new width, zero-pad if needed */ + for (i = 0; i < minrow; i++) { + term.alt[i] = xrealloc(term.alt[i], col * sizeof(Glyph)); + } + + /* allocate any new rows */ + for (/* i = minrow */; i < row; i++) { + term.alt[i] = xmalloc(col * sizeof(Glyph)); + } + if (col > buffCols) { + bp = term.tabs + buffCols; + + memset(bp, 0, sizeof(*term.tabs) * (col - buffCols)); + while (--bp > term.tabs && !*bp) + /* nothing */ ; + for (bp += tabspaces; bp < term.tabs + col; bp += tabspaces) + *bp = 1; + } + Glyph g=(Glyph){.bg=term.c.attr.bg, .fg=term.c.attr.fg, .u=' ', .mode=0}; + for (i = 0; i < buffSize; ++i) { + buf[i] = xrealloc(ini ? NULL : buf[i], col*sizeof(Glyph)); + for (int j = ini ? 0 : buffCols; j < col; ++j) buf[i][j] = g; + } + for (i = 0; i < row; ++i) buf[buffSize + i] = buf[i]; + term.line = &buf[*(histOp?&histOff:&insertOff) +=MAX(term.c.y-row+1,0)]; + memset(mark, 0, col * row * sizeof(*mark)); + /* update terminal size */ + term.col = colSet; + buffCols = col; + term.row = row; + if (alt) tswapscreen(); + /* reset scrolling region */ + tsetscroll(0, row-1); + /* make use of the LIMIT in tmoveto */ + tmoveto(term.c.x, term.c.y); + /* Clearing both screens (it makes dirty all lines) */ + c = term.c; + for (i = 0; i < 2; i++) { + if (mincol < col && 0 < minrow) { + tclearregion(mincol, 0, col - 1, minrow - 1); + } + if (0 < col && minrow < row) { + tclearregion(0, minrow, col - 1, row - 1); } + tswapscreen(); + tcursor(CURSOR_LOAD); } + term.c = c; +} - run: - setlocale(LC_CTYPE, ""); - tnew(80, 24); - ttynew(); - xinit(); - selinit(); - run(); - return 0; +void +resettitle(void) +{ + xsettitle(NULL); +} + +void +drawregion(int x1, int y1, int x2, int y2) +{ + if (altToggle && histMode && !histOp) + memset(term.dirty, 0, sizeof(*term.dirty) * term.row); + int const o = !IS_SET(MODE_ALTSCREEN) && histMode && !histOp, h =rows(); + int y; + + for (y = y1; y < y2; y++) { + int const oy = o ? (y + insertOff - histOff + h) % h : y; + if (!BETWEEN(oy, 0, term.row-1) || !term.dirty[y]) continue; + xdrawline(term.line[y], x1, oy, x2); + } + memset(&term.dirty[y1], 0, sizeof(*term.dirty) * (y2 - y1)); +} + +void +draw(void) +{ + int cx = term.c.x, ocx = term.ocx, ocy = term.ocy; + + if (!xstartdraw()) + return; + + /* adjust cursor position */ + LIMIT(term.ocx, 0, term.col-1); + LIMIT(term.ocy, 0, term.row-1); + if (term.line[term.ocy][term.ocx].mode & ATTR_WDUMMY) + term.ocx--; + if (term.line[term.c.y][cx].mode & ATTR_WDUMMY) + cx--; + + if (histMode) historyPreDraw(); + drawregion(0, 0, term.col, term.row); + if (!histMode) + xdrawcursor(cx, term.c.y, term.line[term.c.y][cx], + term.ocx, term.ocy, term.line[term.ocy][term.ocx]); + term.ocx = cx; + term.ocy = term.c.y; + xfinishdraw(); + if (ocx != term.ocx || ocy != term.ocy) + xximspot(term.ocx, term.ocy); +} + +void +redraw(void) +{ + tfulldirt(); + draw(); }