ref: 2500e3f06f9b8a9fc4806e0aab81a157ea36dceb
parent: 04c22e3803910733329fc61859aabb47bdc2a31b
author: qwx <qwx@sciops.net>
date: Sun Aug 13 23:26:29 EDT 2023
vt: theme + anti-shrink patch
--- /dev/null
+++ b/sys/src/cmd/vt/cons.h
@@ -1,0 +1,81 @@
+/* console state (for consctl) */
+typedef struct Consstate Consstate;
+struct Consstate{+ int raw;
+ int hold;
+ int winch;
+};
+extern Consstate cs[];
+
+#define INSET 2
+#define BUFS 256
+#define HISTSIZ (64*1024) /* number of history characters */
+#define BSIZE (8*1024)
+#define WDIR 1024
+
+extern char osc7cwd[];
+
+#define SCROLL 2
+#define NEWLINE 1
+#define OTHER 0
+
+#define COOKED 0
+#define RAW 1
+
+/* text attributes */
+enum {+ THighIntensity = 1<<0,
+ TUnderline = 1<<1,
+ TBlink = 1<<2,
+ TReverse = 1<<3,
+ TInvisible = 1<<4,
+};
+
+struct ttystate {+ int crnl;
+ int nlcr;
+};
+extern struct ttystate ttystate[];
+
+struct funckey {+ char *name;
+ char *sequence;
+};
+extern struct funckey *fk, *appfk;
+extern struct funckey ansifk[], ansiappfk[], vt220fk[], xtermfk[];
+
+extern int x, y, xmax, ymax, olines;
+extern int peekc, attribute;
+extern char* term;
+
+extern void emulate(void);
+extern int host_avail(void);
+extern void clear(int,int,int,int);
+extern void newline(void);
+extern int get_next_char(void);
+extern void ringbell(void);
+extern int number(Rune *, int *);
+extern void shift(int,int,int,int);
+extern void scroll(int,int,int,int);
+extern void backup(int);
+extern void sendnchars(int, char *);
+extern Point pt(int, int);
+extern Point pos(Point);
+extern void funckey(int);
+extern void drawstring(Rune*, int);
+
+extern int yscrmin, yscrmax;
+extern int attr;
+extern int defattr;
+
+extern Image *fgcolor;
+extern Image *bgcolor;
+extern Image *colors[];
+extern Image *hicolors[];
+
+extern int cursoron;
+extern int nocolor;
+extern int bracketed;
+
+extern void setdim(int, int);
+extern void mountcons(void);
--- /dev/null
+++ b/sys/src/cmd/vt/fs.c
@@ -1,0 +1,212 @@
+#include <u.h>
+#include <libc.h>
+#include <draw.h>
+
+#include "cons.h"
+
+#include <thread.h>
+#include <fcall.h>
+#include <9p.h>
+
+extern Channel *hc[2];
+
+static File *devcons, *devconsctl;
+
+static Channel *readreq;
+static Channel *flushreq;
+
+static void
+fsreader(void*)
+{+ Req *r, *fr;
+ char *s, *p;
+
+ r = nil;
+ s = p = nil;
+ for(;;){+ Alt a[] = {+ { flushreq, &fr, CHANRCV },+ { readreq, &r, r == nil ? CHANRCV : CHANNOP },+ { hc[0], &s, s == nil ? CHANRCV : CHANNOP },+ { nil, nil, s == nil || r == nil ? CHANEND : CHANNOBLK },+ };
+ if(alt(a) == 0){+ if(fr->oldreq == r){+ respond(r, "interrupted");
+ r = nil;
+ }
+ respond(fr, nil);
+ }
+ if(s == nil || r == nil)
+ continue;
+ if(p == nil)
+ p = s;
+ r->ofcall.count = 0;
+ while(r->ifcall.count > r->ofcall.count){+ if(*p == 0)
+ break;
+ r->ofcall.data[r->ofcall.count++] = *p++;
+ if(*p == 0){+ free(s);
+ if((p = s = nbrecvp(hc[0])) == nil)
+ break;
+ }
+ }
+ respond(r, nil);
+ r = nil;
+ }
+}
+
+static void
+fsread(Req *r)
+{+ if(r->fid->file == devcons){+ sendp(readreq, r);
+ return;
+ }
+ respond(r, "not implemented");
+}
+
+typedef struct Partutf Partutf;
+struct Partutf
+{+ int n;
+ char s[UTFmax];
+};
+
+static Rune*
+cvtc2r(char *b, int n, Partutf *u)
+{+ char *cp, *ep;
+ Rune *rp, *rb;
+
+ cp = b, ep = b + n;
+ rp = rb = emalloc9p(sizeof(Rune)*(n+2));
+
+ while(u->n > 0 && cp < ep){+ u->s[u->n++] = *cp++;
+ if(fullrune(u->s, u->n)){+ chartorune(rp, u->s);
+ if(*rp != 0)
+ rp++;
+ u->n = 0;
+ break;
+ }
+ }
+ if(u->n == 0){+ while(cp < ep && fullrune(cp, ep - cp)){+ cp += chartorune(rp, cp);
+ if(*rp != 0)
+ rp++;
+ }
+ n = ep - cp;
+ if(n > 0){+ memmove(u->s, cp, n);
+ u->n = n;
+ }
+ }
+ if(rb == rp){+ free(rb);
+ return nil;
+ }
+ *rp = 0;
+
+ return rb;
+}
+
+static void
+fswrite(Req *r)
+{+ if(r->fid->file == devcons){+ Partutf *u;
+ Rune *rp;
+
+ if((u = r->fid->aux) == nil)
+ u = r->fid->aux = emalloc9p(sizeof(*u));
+ if((rp = cvtc2r((char*)r->ifcall.data, r->ifcall.count, u)) != nil)
+ sendp(hc[1], rp);
+
+ r->ofcall.count = r->ifcall.count;
+ respond(r, nil);
+ return;
+ }
+ if(r->fid->file == devconsctl){+ char *s = r->ifcall.data;
+ int n = r->ifcall.count;
+
+ if(n >= 5 && strncmp(s, "rawon", 5) == 0)
+ cs->raw = 1;
+ else if(n >= 6 && strncmp(s, "rawoff", 6) == 0)
+ cs->raw = 0;
+ else if(n >= 6 && strncmp(s, "holdon", 6) == 0)
+ cs->hold = 1;
+ else if(n >= 7 && strncmp(s, "holdoff", 7) == 0)
+ cs->hold = 0;
+ else if(n >= 7 && strncmp(s, "winchon", 7) == 0)
+ cs->winch = 1;
+ else if(n >= 8 && strncmp(s, "winchoff", 8) == 0)
+ cs->winch = 0;
+
+ r->ofcall.count = r->ifcall.count;
+ respond(r, nil);
+ return;
+ }
+
+ respond(r, "not implemented");
+}
+
+static void
+fsflush(Req *r)
+{+ sendp(flushreq, r);
+}
+
+static void
+fsdestroyfid(Fid *f)
+{+ if(f->file == devconsctl && f->omode >= 0){+ cs->raw = 0;
+ cs->hold = 0;
+ cs->winch = 0;
+ }
+ if(f->aux != nil){+ free(f->aux);
+ f->aux = nil;
+ }
+}
+
+static void
+fsstart(Srv*)
+{+ flushreq = chancreate(sizeof(Req*), 4);
+ readreq = chancreate(sizeof(Req*), 4);
+ proccreate(fsreader, nil, 16*1024);
+}
+
+static void
+fsend(Srv*)
+{+ sendp(hc[1], nil);
+}
+
+Srv fs = {+.read=fsread,
+.write=fswrite,
+.flush=fsflush,
+.destroyfid=fsdestroyfid,
+.start=fsstart,
+.end=fsend,
+};
+
+void
+mountcons(void)
+{+ fs.tree = alloctree("vt", "vt", DMDIR|0555, nil);+ devcons = createfile(fs.tree->root, "cons", "vt", 0666, nil);
+ if(devcons == nil)
+ sysfatal("creating /dev/cons: %r");+ devconsctl = createfile(fs.tree->root, "consctl", "vt", 0666, nil);
+ if(devconsctl == nil)
+ sysfatal("creating /dev/consctl: %r");+ threadpostmountsrv(&fs, nil, "/dev", MBEFORE);
+}
--- /dev/null
+++ b/sys/src/cmd/vt/main.c
@@ -1,0 +1,1512 @@
+#include <u.h>
+#include <libc.h>
+#include <draw.h>
+
+#include "cons.h"
+
+#include <thread.h>
+#include <fcall.h>
+#include <9p.h>
+
+#include <bio.h>
+#include <mouse.h>
+#include <keyboard.h>
+#include <plumb.h>
+
+enum menuact2{+ Mbackup,
+ Mforward,
+ Mreset,
+ Mpaste,
+ Msnarf,
+ Mplumb,
+ Mpage,
+};
+
+enum menuact3{+ Mnil,
+ M24x80,
+ Mcrnl,
+ Mnl,
+ Mraw,
+ Mblocksel,
+ Mexit,
+};
+
+char *menutext2[] = {+ [Mbackup] "backup",
+ [Mforward] "forward",
+ [Mreset] "reset",
+ [Mpaste] "paste",
+ [Msnarf] "snarf",
+ [Mplumb] "plumb",
+ [Mpage] "page",
+ nil
+};
+
+char *menutext3[] = {+ [Mnil] "-",
+ [M24x80] "24x80",
+ [Mcrnl] "crnl",
+ [Mnl] "nl",
+ [Mraw] "raw",
+ [Mblocksel] "blocksel",
+ [Mexit] "exit",
+ nil
+};
+
+/* variables associated with the screen */
+
+int x, y; /* character positions */
+Rune *backp;
+int backc;
+int nbacklines;
+int xmax, ymax;
+int blocked;
+int winchgen;
+int resize_flag = 1;
+int pagemode;
+int olines;
+int peekc;
+int blocksel = 0;
+int cursoron = 1;
+int chording = 0;
+int hostclosed = 0;
+Menu menu2;
+Menu menu3;
+Rune *histp;
+Rune hist[HISTSIZ];
+Rune *onscreenrbuf;
+uchar *onscreenabuf;
+uchar *onscreencbuf;
+
+#define onscreenr(x, y) &onscreenrbuf[((y)*(xmax+2) + (x))]
+#define onscreena(x, y) &onscreenabuf[((y)*(xmax+2) + (x))]
+#define onscreenc(x, y) &onscreencbuf[((y)*(xmax+2) + (x))]
+
+uchar *screenchangebuf;
+uint scrolloff;
+
+#define screenchange(y) screenchangebuf[((y)+scrolloff) % (ymax+1)]
+
+int yscrmin, yscrmax;
+int attr, defattr;
+
+Rectangle selrect;
+
+Image *cursorsave;
+Image *bordercol;
+Image *colors[8];
+Image *hicolors[8];
+Image *red;
+Image *green;
+Image *fgcolor;
+Image *bgcolor;
+Image *fgselected;
+Image *bgselected;
+Image *highlight;
+
+uint rgbacolors[8] = {+ 0x000000FF, /* black */
+ 0xAA0000FF, /* red */
+ 0x00AA00FF, /* green */
+ 0xFF5500FF, /* brown */
+ 0x0000FFFF, /* blue */
+ 0xAA00AAFF, /* purple */
+ 0x00AAAAFF, /* cyan */
+ 0x7F7F7FFF, /* white */
+};
+
+ulong rgbahicolors[8] = {+ 0x555555FF, /* light black aka grey */
+ 0xFF5555FF, /* light red */
+ 0x55FF55FF, /* light green */
+ 0xFFFF55FF, /* light brown aka yellow */
+ 0x5555FFFF, /* light blue */
+ 0xFF55FFFF, /* light purple */
+ 0x55FFFFFF, /* light cyan */
+ 0xFFFFFFFF, /* light grey aka white */
+};
+
+/* terminal control */
+struct ttystate ttystate[2] = { {0, 1}, {0, 0} };+
+Point margin;
+Point ftsize;
+
+Rune kbdchar;
+
+#define button(num) (mc->buttons == (1<<((num)-1)))
+
+Mousectl *mc;
+Keyboardctl *kc;
+Channel *hc[2];
+Consstate cs[1];
+
+int nocolor;
+int logfd = -1;
+int hostpid = -1;
+Biobuf *snarffp = 0;
+Rune *hostbuf, *hostbufp;
+char *hostin;
+char echo_input[BSIZE];
+char *echop = echo_input; /* characters to echo, after canon */
+char sendbuf[BSIZE]; /* hope you can't type ahead more than BSIZE chars */
+char *sendbufp = sendbuf;
+
+char *term;
+struct funckey *fk, *appfk;
+
+/* functions */
+int input(void);
+int waitchar(void);
+void waitio(void);
+int rcvchar(void);
+void bigscroll(void);
+void readmenu(void);
+void selecting(void);
+int selected(int, int);
+void resized(void);
+void drawcursor(void);
+void send_interrupt(void);
+int alnum(int);
+void escapedump(int,uchar *,int);
+void paste(void);
+void snarfsel(void);
+void plumbsel(void);
+
+static Channel *pidchan;
+
+static void
+runcmd(void *args)
+{+ char **argv = args;
+ char *cmd;
+
+ rfork(RFNAMEG);
+ mountcons();
+
+ rfork(RFFDG);
+ close(0);
+ open("/dev/cons", OREAD);+ close(1);
+ open("/dev/cons", OWRITE);+ dup(1, 2);
+
+ cmd = nil;
+ while(*argv != nil){+ if(cmd == nil)
+ cmd = strdup(*argv);
+ else
+ cmd = smprint("%s %q", cmd, *argv);+ argv++;
+ }
+
+ procexecl(pidchan, "/bin/rc", "rcX", cmd == nil ? nil : "-c", cmd, nil);
+ sysfatal("%r");+}
+
+void
+send_interrupt(void)
+{+ if(hostpid > 0)
+ postnote(PNGROUP, hostpid, "interrupt");
+}
+
+void
+sendnchars(int n, char *p)
+{+ if((n = utfnlen(p, n)) < 1)
+ return;
+ hostin = smprint("%.*s", n, p);+ while(hostin != nil){+ if(nbsendp(hc[0], hostin)){+ hostin = nil;
+ break;
+ }
+ drawcursor();
+ waitio();
+ if(resize_flag)
+ resized();
+ }
+}
+
+static void
+shutdown(void)
+{+ send_interrupt();
+ threadexitsall(nil);
+}
+
+static void
+catch(void*, char*)
+{+ shutdown();
+}
+
+void
+usage(void)
+{+ fprint(2, "usage: %s [-2abcrx] [-f font] [-l logfile] [cmd...]\n", argv0);
+ exits("usage");+}
+
+void
+threadmain(int argc, char **argv)
+{+ int rflag;
+ int i, reverse;
+ char *fontname, *p;
+
+ fontname = nil;
+ fk = ansifk;
+ term = "vt100";
+ reverse = 0;
+ rflag = 0;
+ attr = defattr;
+ ARGBEGIN{+ case '2':
+ fk = vt220fk;
+ term = "vt220";
+ break;
+ case 'a':
+ term = "ansi";
+ break;
+ case 'b':
+ reverse = ~0xFF; /* e.g., for linux colored output */
+ break;
+ case 'c':
+ nocolor = 1;
+ break;
+ case 'f':
+ fontname = EARGF(usage());
+ break;
+ case 'l':
+ p = EARGF(usage());
+ logfd = create(p, OWRITE|OCEXEC, 0666);
+ if(logfd < 0)
+ sysfatal("could not create log file: %s: %r", p);+ break;
+ case 'x':
+ fk = xtermfk;
+ term = "xterm";
+ break;
+ case 'r':
+ rflag = 1;
+ break;
+ default:
+ usage();
+ break;
+ }ARGEND;
+
+ if(rfork(RFENVG) < 0)
+ sysfatal("rfork: %r");+ doquote = needsrcquote;
+ quotefmtinstall();
+ notify(catch);
+ atexit(shutdown);
+
+ if(initdraw(0, fontname, term) < 0)
+ sysfatal("inidraw failed: %r");+ if((mc = initmouse("/dev/mouse", screen)) == nil)+ sysfatal("initmouse failed: %r");+ if((kc = initkeyboard("/dev/cons")) == nil)+ sysfatal("initkeyboard failed: %r");+
+ hc[0] = chancreate(sizeof(char*), 256); /* input to host */
+ hc[1] = chancreate(sizeof(Rune*), 256); /* output from host */
+
+ cs->raw = rflag;
+
+ histp = hist;
+ menu2.item = menutext2;
+ menu3.item = menutext3;
+ pagemode = 0;
+ blocked = 0;
+ ftsize.y = font->height;
+ ftsize.x = stringwidth(font, "m");
+
+ red = allocimage(display, Rect(0,0,1,1), screen->chan, 1, DRed);
+ green = allocimage(display, Rect(0,0,1,1), screen->chan, 1, DGreen);
+ bordercol = allocimage(display, Rect(0,0,1,1), screen->chan, 1, 0xCCCCCCCC);
+ highlight = allocimage(display, Rect(0,0,1,1), CHAN1(CAlpha,8), 1, 0x80);
+
+ for(i=0; i<8; i++){+ colors[i] = allocimage(display, Rect(0,0,1,1), screen->chan, 1,
+ rgbacolors[i]);
+ hicolors[i] = allocimage(display, Rect(0,0,1,1), screen->chan, 1,
+ rgbahicolors[i]);
+ }
+
+ enum{+ BACK,
+ HIGH,
+ TEXT,
+ HTEXT,
+ Ncols,
+ };
+ Theme th[Ncols] = {+ [BACK] { "back", DBlack },+ [TEXT] { "text", DWhite },+ [HIGH] { "high", 0xCCCCCCFF },+ [HTEXT] { "back", 0x333333FF },+ };
+ readtheme(th, nelem(th), nil);
+ if(reverse)
+ for(i=0; i<nelem(th); i++)
+ th[i].c ^= reverse;
+ bgcolor = allocimage(display, Rect(0,0,1,1), screen->chan, 1, th[BACK].c);
+ fgcolor = allocimage(display, Rect(0,0,1,1), screen->chan, 1, th[TEXT].c);
+ bgselected = allocimage(display, Rect(0,0,1,1), screen->chan, 1, th[HIGH].c);
+ fgselected = allocimage(display, Rect(0,0,1,1), screen->chan, 1, th[HTEXT].c);
+
+ resized();
+
+ pidchan = chancreate(sizeof(int), 0);
+ proccreate(runcmd, argv, 16*1024);
+ hostpid = recvul(pidchan);
+
+ emulate();
+}
+
+Image*
+bgcol(int a, int c, int sel)
+{+ if(sel)
+ return bgselected;
+ if(nocolor || (c & (1<<0)) == 0){+ if(a & TReverse)
+ return fgcolor;
+ return bgcolor;
+ }
+ if((a & TReverse) != 0)
+ c >>= 4;
+ return colors[(c>>1)&7];
+}
+
+Image*
+fgcol(int a, int c, int sel)
+{+ if(sel)
+ return fgselected;
+ if(nocolor || (c & (1<<4)) == 0){+ if(a & TReverse)
+ return bgcolor;
+ return fgcolor;
+ }
+ if((a & TReverse) == 0)
+ c >>= 4;
+ if(a & THighIntensity)
+ return hicolors[(c>>1)&7];
+ return colors[(c>>1)&7];
+}
+
+void
+hidecursor(void)
+{+ if(cursorsave == nil)
+ return;
+ draw(screen, cursorsave->r, cursorsave, nil, cursorsave->r.min);
+ freeimage(cursorsave);
+ cursorsave = nil;
+}
+
+void
+drawscreen(void)
+{+ int x, y, n;
+ uchar *ap, *cp;
+ Image *c;
+ Rune *rp;
+ Point p, q;
+
+ hidecursor();
+
+ if(scrolloff && scrolloff <= ymax)
+ draw(screen, Rpt(pt(0,0), pt(xmax+2, ymax+1-scrolloff)),
+ screen, nil, pt(0, scrolloff));
+
+ for(y = 0; y <= ymax; y++){+ if(!screenchange(y))
+ continue;
+ screenchange(y) = 0;
+
+ for(x = 0; x <= xmax; x += n){+ cp = onscreenc(x, y);
+ ap = onscreena(x, y);
+ c = bgcol(*ap, *cp, selected(x, y));
+ for(n = 1; x+n <= xmax && bgcol(ap[n], cp[n], selected(x + n, y)) == c; n++)
+ ;
+ draw(screen, Rpt(pt(x, y), pt(x+n, y+1)), c, nil, ZP);
+ }
+ draw(screen, Rpt(pt(x, y), pt(x+1, y+1)), bgcolor, nil, ZP);
+
+ for(x = 0; x <= xmax; x += n){+ rp = onscreenr(x, y);
+ if(*rp == 0){+ n = 1;
+ continue;
+ }
+ ap = onscreena(x, y);
+ cp = onscreenc(x, y);
+ c = fgcol(*ap, *cp, selected(x, y));
+ for(n = 1; x+n <= xmax && rp[n] != 0 && fgcol(ap[n], cp[n], selected(x + n, y)) == c
+ && ((ap[n] ^ *ap) & TUnderline) == 0; n++)
+ ;
+ p = pt(x, y);
+ q = runestringn(screen, p, c, ZP, font, rp, n);
+ if(*ap & TUnderline){+ p.y += font->ascent+1;
+ q.y += font->ascent+2;
+ draw(screen, Rpt(p, q), c, nil, ZP);
+ }
+ }
+ if(*onscreenr(x, y) == 0)
+ runestringn(screen, pt(x, y),
+ bordercol,
+ ZP, font, L">", 1);
+ }
+
+ scrolloff = 0;
+}
+
+void
+drawcursor(void)
+{+ Image *col;
+ Rectangle r;
+
+ hidecursor();
+ if(cursoron == 0)
+ return;
+
+ col = (hostin != nil || blocked || hostclosed) ? red : bordercol;
+ r = Rpt(pt(x, y), pt(x+1, y+1));
+
+ cursorsave = allocimage(display, r, screen->chan, 0, DNofill);
+ draw(cursorsave, r, screen, nil, r.min);
+
+ border(screen, r, 2, col, ZP);
+
+}
+
+void
+clear(int x1, int y1, int x2, int y2)
+{+ int c = (attr & 0x0F00)>>8; /* bgcolor */
+
+ if(y1 < 0 || y1 > ymax || x1 < 0 || x1 > xmax || y2 <= y1 || x2 <= x1)
+ return;
+
+ while(y1 < y2){+ screenchange(y1) = 1;
+ if(x1 < x2){+ memset(onscreenr(x1, y1), 0, (x2-x1)*sizeof(Rune));
+ memset(onscreena(x1, y1), 0, x2-x1);
+ memset(onscreenc(x1, y1), c, x2-x1);
+ }
+ if(x2 > xmax)
+ *onscreenr(xmax+1, y1) = '\n';
+ y1++;
+ }
+}
+
+void
+newline(void)
+{+ if(x > xmax)
+ *onscreenr(xmax+1, y) = 0; /* wrap arround, remove hidden newline */
+ nbacklines--;
+ if(y >= yscrmax) {+ y = yscrmax;
+ if(pagemode && olines >= yscrmax){+ blocked = 1;
+ return;
+ }
+ scroll(yscrmin+1, yscrmax+1, yscrmin, yscrmax);
+ } else
+ y++;
+ olines++;
+}
+
+int
+get_next_char(void)
+{+ int c = peekc;
+
+ peekc = 0;
+ if(c > 0)
+ return(c);
+ while(c <= 0) {+ if(backp) {+ c = *backp;
+ if(c && nbacklines >= 0){+ backp++;
+ if(backp >= &hist[HISTSIZ])
+ backp = hist;
+ return(c);
+ }
+ backp = 0;
+ }
+ c = waitchar();
+ if(c > 0 && logfd >= 0)
+ fprint(logfd, "%C", (Rune)c);
+ }
+ *histp++ = c;
+ if(histp >= &hist[HISTSIZ])
+ histp = hist;
+ *histp = '\0';
+ return(c);
+}
+
+char*
+backrune(char *start, char *cp)
+{+ char *ep;
+
+ ep = cp;
+ cp -= UTFmax;
+ if(cp < start)
+ cp = start;
+ while(cp < ep){+ Rune r;
+ int n;
+
+ n = chartorune(&r, cp);
+ if(cp + n >= ep)
+ break;
+ cp += n;
+ }
+ return cp;
+}
+
+int
+canon(char *ep, Rune c)
+{+ switch(c) {+ case Kdown:
+ case Kpgdown:
+ return SCROLL;
+ case '\b':
+ if(sendbufp > sendbuf){+ sendbufp = backrune(sendbuf, sendbufp);
+ *ep++ = '\b';
+ *ep++ = ' ';
+ *ep++ = '\b';
+ }
+ break;
+ case 0x15: /* ^U line kill */
+ sendbufp = sendbuf;
+ *ep++ = '^';
+ *ep++ = 'U';
+ *ep++ = '\n';
+ break;
+ case 0x17: /* ^W word kill */
+ while(sendbufp > sendbuf && !alnum(*sendbufp)) {+ sendbufp = backrune(sendbuf, sendbufp);
+ *ep++ = '\b';
+ *ep++ = ' ';
+ *ep++ = '\b';
+ }
+ while(sendbufp > sendbuf && alnum(*sendbufp)) {+ sendbufp = backrune(sendbuf, sendbufp);
+ *ep++ = '\b';
+ *ep++ = ' ';
+ *ep++ = '\b';
+ }
+ break;
+ case '\177': /* interrupt */
+ sendbufp = sendbuf;
+ send_interrupt();
+ return(NEWLINE);
+ case '\021': /* quit */
+ case '\r':
+ case '\n':
+ if(sendbufp < &sendbuf[BSIZE])
+ *sendbufp++ = '\n';
+ sendnchars((int)(sendbufp-sendbuf), sendbuf);
+ sendbufp = sendbuf;
+ if(c == '\n' || c == '\r')
+ *ep++ = '\n';
+ *ep = 0;
+ return(NEWLINE);
+ case '\004': /* EOT */
+ if(sendbufp == sendbuf) {+ sendnchars(0,sendbuf);
+ *ep = 0;
+ return(NEWLINE);
+ }
+ /* fall through */
+ default:
+ if(sendbufp < &sendbuf[BSIZE-UTFmax])
+ sendbufp += runetochar(sendbufp, &c);
+ ep += runetochar(ep, &c);
+ break;
+ }
+ *ep = 0;
+ return(OTHER);
+}
+
+char*
+lookfk(struct funckey *fk, char *name)
+{+ int i;
+
+ for(i=0; fk[i].name; i++){+ if(strcmp(name, fk[i].name)==0)
+ return fk[i].sequence;
+ }
+ return nil;
+}
+
+int
+sendfk(char *name)
+{+ char *s = lookfk(appfk != nil ? appfk : fk, name);
+ if(s == nil && appfk != nil)
+ s = lookfk(fk, name);
+ if(s != nil){+ sendnchars(strlen(s), s);
+ return 1;
+ }
+ return 0;
+}
+
+int
+input(void)
+{+ static char echobuf[4*BSIZE];
+ static int pasting;
+
+Again:
+ if(resize_flag)
+ resized();
+ if(backp)
+ return(0);
+ if(snarffp) {+ int c;
+
+ if(bracketed && !pasting){+ sendnchars(6, "\033[200~");
+ pasting = 1;
+ }
+ if((c = Bgetrune(snarffp)) < 0) {+ Bterm(snarffp);
+ snarffp = nil;
+ if(bracketed){+ sendnchars(6, "\033[201~");
+ pasting = 0;
+ }
+ goto Again;
+ }
+ kbdchar = c;
+ }
+ if(kbdchar) {+ if(backc){+ backc = 0;
+ backup(backc);
+ }
+ if(blocked)
+ resize_flag = 1;
+ if(cs->raw) {+ switch(kbdchar){+ case Kins:
+ if(!sendfk("insert"))+ goto Send;
+ break;
+ case Kdel:
+ if(!sendfk("delete"))+ goto Send;
+ break;
+ case Khome:
+ if(!sendfk("home"))+ goto Send;
+ break;
+ case Kend:
+ if(!sendfk("end"))+ goto Send;
+ break;
+
+ case Kpgup:
+ sendfk("page up");+ break;
+ case Kpgdown:
+ sendfk("page down");+ break;
+
+ case Kup:
+ sendfk("up key");+ break;
+ case Kdown:
+ sendfk("down key");+ break;
+ case Kleft:
+ sendfk("left key");+ break;
+ case Kright:
+ sendfk("right key");+ break;
+
+ case KF|1:
+ sendfk("F1");+ break;
+ case KF|2:
+ sendfk("F2");+ break;
+ case KF|3:
+ sendfk("F3");+ break;
+ case KF|4:
+ sendfk("F4");+ break;
+ case KF|5:
+ sendfk("F5");+ break;
+ case KF|6:
+ sendfk("F6");+ break;
+ case KF|7:
+ sendfk("F7");+ break;
+ case KF|8:
+ sendfk("F8");+ break;
+ case KF|9:
+ sendfk("F9");+ break;
+ case KF|10:
+ sendfk("F10");+ break;
+ case KF|11:
+ sendfk("F11");+ break;
+ case KF|12:
+ sendfk("F12");+ break;
+
+ case '\n':
+ echobuf[0] = '\r';
+ sendnchars(1, echobuf);
+ break;
+ case '\r':
+ echobuf[0] = '\n';
+ sendnchars(1, echobuf);
+ break;
+ default:
+ Send:
+ sendnchars(runetochar(echobuf, &kbdchar), echobuf);
+ break;
+ }
+ } else {+ switch(canon(echobuf, kbdchar)){+ case SCROLL:
+ if(!blocked)
+ bigscroll();
+ break;
+ default:
+ strcat(echo_input,echobuf);
+ }
+ }
+ blocked = 0;
+ kbdchar = 0;
+ goto Again;
+ } else if(nbrecv(kc->c, &kbdchar))
+ goto Again;
+ if(!blocked){+ if(host_avail())
+ return(rcvchar());
+ free(hostbuf);
+ hostbufp = hostbuf = nbrecvp(hc[1]);
+ if(host_avail() && nrand(32))
+ return(rcvchar());
+ }
+ return -1;
+}
+
+
+int
+waitchar(void)
+{+ int r;
+
+ for(;;) {+ r = input();
+ if(r != -1)
+ return r;
+ drawscreen();
+ drawcursor();
+ waitio();
+ }
+}
+
+void
+waitio(void)
+{+ enum { AMOUSE, ARESIZE, AKBD, AHOSTIN, AHOSTOUT, AEND, };+ Alt a[AEND+1] = {+ { mc->c, &mc->Mouse, CHANRCV },+ { mc->resizec, nil, CHANRCV },+ { kc->c, &kbdchar, CHANRCV },+ { hc[0], &hostin, CHANSND },+ { hc[1], &hostbuf, CHANRCV },+ { nil, nil, CHANEND },+ };
+ if(kbdchar != 0)
+ a[AKBD].op = CHANNOP;
+ if(hostin == nil)
+ a[AHOSTIN].op = CHANNOP;
+ if(blocked)
+ a[AHOSTOUT].op = CHANNOP;
+ else if(hostbuf != nil)
+ a[AHOSTOUT].op = CHANNOBLK;
+Next:
+ if(display->bufp > display->buf)
+ flushimage(display, 1);
+ switch(alt(a)){+ case AMOUSE:
+ if(button(1) || chording)
+ selecting();
+ else if(button(2) || button(3))
+ readmenu();
+ else if(button(4))
+ backup(backc+1);
+ else if(button(5) && backc > 0)
+ backup(--backc);
+ else if(resize_flag == 0)
+ goto Next;
+ break;
+ case ARESIZE:
+ resize_flag = 2;
+ break;
+ case AHOSTIN:
+ hostin = nil;
+ break;
+ case AHOSTOUT:
+ hostbufp = hostbuf;
+ if(hostbuf == nil)
+ hostclosed = 1;
+ break;
+ }
+}
+
+void
+putenvint(char *name, int x)
+{+ char buf[20];
+
+ snprint(buf, sizeof buf, "%d", x);
+ putenv(name, buf);
+}
+
+void
+exportsize(void)
+{+ putenvint("WINCH", ++winchgen);+ putenvint("XPIXELS", (xmax+1)*ftsize.x);+ putenvint("YPIXELS", (ymax+1)*ftsize.y);+ putenvint("LINES", ymax+1);+ putenvint("COLS", xmax+1);+ putenv("TERM", term);+ if(cs->winch)
+ send_interrupt();
+}
+
+void
+setdim(int ht, int wid)
+{+ char tmp[128];
+ int n, fd;
+
+ if(wid > 0) xmax = wid-1;
+ if(ht > 0) ymax = ht-1;
+
+ x = 0;
+ y = 0;
+ yscrmin = 0;
+ yscrmax = ymax;
+ olines = 0;
+
+ margin.x = (Dx(screen->r) - (xmax+1)*ftsize.x) / 2;
+ margin.y = (Dy(screen->r) - (ymax+1)*ftsize.y) / 2;
+
+ free(screenchangebuf);
+ screenchangebuf = emalloc9p(ymax+1);
+ scrolloff = 0;
+ selrect = ZR;
+
+ free(onscreenrbuf);
+ onscreenrbuf = emalloc9p((ymax+1)*(xmax+2)*sizeof(Rune));
+ free(onscreenabuf);
+ onscreenabuf = emalloc9p((ymax+1)*(xmax+2));
+ free(onscreencbuf);
+ onscreencbuf = emalloc9p((ymax+1)*(xmax+2));
+ clear(0,0,xmax+1,ymax+1);
+
+ draw(screen, screen->r, bgcolor, nil, ZP);
+
+ if(resize_flag || backc)
+ return;
+
+ exportsize();
+
+ fd = open("/dev/wctl", ORDWR);+ if(fd >= 0){+ ht = (ymax+1) * ftsize.y + 2*INSET + 2*Borderwidth;
+ wid = (xmax+1) * ftsize.x + ftsize.x + 2*INSET + 2*Borderwidth;
+ if((n = read(fd, tmp, sizeof(tmp)-1)) < 0)
+ n = 0;
+ tmp[n] = 0;
+ if(strstr(tmp, "hidden") == nil)
+ fprint(fd, "resize -dx %d -dy %d\n", wid, ht);
+ close(fd);
+ }
+}
+
+void
+resized(void)
+{+ if(resize_flag > 1 && getwindow(display, Refnone) < 0){+ fprint(2, "can't reattach to window: %r\n");
+ exits("can't reattach to window");+ }
+ setdim((Dy(screen->r) - 2*INSET)/ftsize.y, (Dx(screen->r) - 2*INSET - ftsize.x)/ftsize.x);
+ exportsize();
+ if(resize_flag > 1)
+ backup(backc);
+ resize_flag = 0;
+ werrstr(""); /* clear spurious error messages */+}
+
+char*
+selrange(char *d, int x0, int y0, int x1, int y1)
+{+ Rune *s, *e;
+ int z, p;
+
+ s = onscreenr(x0, y0);
+ e = onscreenr(x1, y1);
+ for(z = p = 0; s < e; s++){+ if(*s){+ if(*s == '\n')
+ z = p = 0;
+ else if(p++ == 0){+ while(z-- > 0) *d++ = ' ';
+ }
+ d += runetochar(d, s);
+ } else {+ z++;
+ }
+ }
+ return d;
+}
+
+char*
+selection(void)
+{+ char *s, *p;
+ int y;
+
+ /* generous, but we can spare a few bytes for a few microseconds */
+ s = p = malloc(UTFmax*(xmax+1)*(Dy(selrect)+1)+1);
+ if(s == nil)
+ return nil;
+ if(blocksel){+ for(y = selrect.min.y; y <= selrect.max.y; y++){+ p = selrange(p, selrect.min.x, y, selrect.max.x, y);
+ *p++ = '\n';
+ }
+ } else {+ p = selrange(p, selrect.min.x, selrect.min.y, selrect.max.x, selrect.max.y);
+ }
+ *p = 0;
+ return s;
+}
+
+void
+snarfsel(void)
+{+ Biobuf *b;
+ char *s;
+
+ if((s = selection()) == nil)
+ return;
+ if((b = Bopen("/dev/snarf", OWRITE|OTRUNC)) == nil){+ free(s);
+ return;
+ }
+ Bprint(b, "%s", s);
+ Bterm(b);
+ free(s);
+}
+
+void
+plumbsel(void)
+{+ char *s, *e, wdir[WDIR];
+ Plumbmsg msg;
+ int plumb;
+
+ s = selection();
+ if(s == nil || *s == 0)
+ return;
+ memset(&msg, 0, sizeof(msg));
+ msg.src = "vt";
+ msg.type = "text";
+ msg.ndata = strlen(s);
+ msg.data = s;
+ msg.wdir = wdir;
+ if(*osc7cwd != 0){+ strcpy(wdir, osc7cwd);
+ /* absolute path? adjust wdir and path */
+ if(*s == '/'){+ if((e = strchr(wdir+3, '/')) != nil){+ *e = 0;
+ msg.data++;
+ msg.ndata--;
+ }
+ }
+ }else if(getwd(wdir, sizeof wdir) == nil){+ free(s);
+ return;
+ }
+ if((plumb = plumbopen("send", OWRITE)) < 0){+ free(s);
+ return;
+ }
+ plumbsend(plumb, &msg);
+ close(plumb);
+ free(s);
+}
+
+void
+paste(void)
+{+ if(snarffp == nil)
+ snarffp = Bopen("/dev/snarf",OREAD);+}
+
+int
+isalnum(Rune c)
+{+ /*
+ * Hard to get absolutely right. Use what we know about ASCII
+ * and assume anything above the Latin control characters is
+ * potentially an alphanumeric.
+ */
+ if(c <= ' ')
+ return 0;
+ if(0x7F<=c && c<=0xA0)
+ return 0;
+ if(utfrune("!\"#$%&'()*+,-./:;<=>?@[\\]^`{|}~", c))+ return 0;
+ return 1;
+}
+
+int
+isspace(Rune c)
+{+ return c == 0 || c == ' ' || c == '\t' ||
+ c == '\n' || c == '\r' || c == '\v';
+}
+
+void
+unselect(void)
+{+ int y;
+
+ for(y = selrect.min.y; y <= selrect.max.y; y++)
+ screenchange(y) = 1;
+ selrect = ZR;
+}
+
+int
+inmode(Rune r, int mode)
+{+ return (mode == 1) ? isalnum(r) : r && !isspace(r);
+}
+
+/*
+ * Selects different things based on mode.
+ * 0: selects swept-over text.
+ * 1: selects alphanumeric segment
+ * 2: selects non-whitespace segment.
+ */
+void
+select(Point p, Point q, int mode)
+{+ if(onscreenr(p.x, p.y) > onscreenr(q.x, q.y)){+ select(q, p, mode);
+ return;
+ }
+ unselect();
+ if(p.y < 0 || p.y > ymax)
+ return;
+ if(p.y < 0){+ p.y = 0;
+ if(!blocksel) p.x = 0;
+ }
+ if(q.y > ymax){+ q.y = ymax;
+ if(!blocksel) q.x = xmax+1;
+ }
+ if(mode != 0 && eqpt(p, q)){+ while(p.x > 0 && inmode(*onscreenr(p.x-1, p.y), mode))
+ p.x--;
+ while(q.x <= xmax && inmode(*onscreenr(q.x, q.y), mode))
+ q.x++;
+ if(p.x != q.x)
+ mode = 0;
+ }
+ if(p.x < 0 || mode)
+ p.x = 0;
+ if(q.x > xmax+1 || mode)
+ q.x = xmax+1;
+ selrect = Rpt(p, q);
+ for(; p.y <= q.y; p.y++)
+ screenchange(p.y) = 1;
+}
+
+void
+selecting(void)
+{+ Point p, q;
+ static ulong t, mode;
+
+ if(!chording){+ p = pos(mc->xy);
+ t += mc->msec;
+ mode++;
+ do{+ q = pos(mc->xy);
+ if(t > 200)
+ mode = 0;
+ if(mode > 2)
+ mode = 2;
+ select(p, q, mode);
+ drawscreen();
+ readmouse(mc);
+ } while(button(1));
+ }
+ if(mc->buttons != chording){+ switch(mc->buttons & 0x7){+ case 0: /* nothing */ break;
+ case 3: snarfsel(); break;
+ case 5: paste(); break;
+ }
+ }
+ drawscreen();
+ t = -mc->msec;
+ chording = mc->buttons;
+}
+
+int
+selected(int x, int y)
+{+ int s;
+
+ s = y >= selrect.min.y && y <= selrect.max.y;
+ if (blocksel)
+ s = s && x >= selrect.min.x && x < selrect.max.x;
+ else{+ if(y == selrect.min.y)
+ s = s && x >= selrect.min.x;
+ if(y == selrect.max.y)
+ s = s && x < selrect.max.x;
+ if(y > selrect.min.y && y < selrect.max.y)
+ s = 1;
+ }
+ return s;
+}
+
+void
+readmenu(void)
+{+ Point p;
+
+ p = pos(mc->xy);
+ if(button(3)) {+ menu3.lasthit = 0;
+ menu3.item[Mcrnl] = ttystate[cs->raw].crnl ? "cr" : "crnl";
+ menu3.item[Mnl] = ttystate[cs->raw].nlcr ? "nl" : "nlcr";
+ menu3.item[Mraw] = cs->raw ? "cooked" : "raw";
+ menu3.item[Mblocksel] = blocksel ? "linesel" : "blocksel";
+
+ switch(menuhit(3, mc, &menu3, nil)) {+ case M24x80: /* 24x80 */
+ setdim(24, 80);
+ backup(backc);
+ return;
+ case Mcrnl: /* newline after cr? */
+ ttystate[cs->raw].crnl = !ttystate[cs->raw].crnl;
+ return;
+ case Mnl: /* cr after newline? */
+ ttystate[cs->raw].nlcr = !ttystate[cs->raw].nlcr;
+ return;
+ case Mraw: /* switch raw mode */
+ cs->raw = !cs->raw;
+ return;
+ case Mblocksel:
+ unselect();
+ blocksel = !blocksel;
+ return;
+ case Mexit:
+ exits(0);
+ }
+ return;
+ }
+
+ menu2.item[Mpage] = pagemode? "scroll": "page";
+
+ switch(menuhit(2, mc, &menu2, nil)) {+ case Mbackup: /* back up */
+ backup(backc+1);
+ return;
+
+ case Mforward: /* move forward */
+ if(backc > 0)
+ backup(--backc);
+ return;
+
+ case Mreset: /* reset */
+ backc = 0;
+ backup(0);
+ return;
+
+ case Mpaste: /* paste the snarf buffer */
+ paste();
+ return;
+
+ case Msnarf: /* send the snarf buffer */
+ snarfsel();
+ return;
+
+ case Mplumb:
+ plumbsel();
+ return;
+
+ case Mpage: /* pause and clear at end of screen */
+ pagemode = 1-pagemode;
+ if(blocked && !pagemode) {+ resize_flag = 1;
+ blocked = 0;
+ }
+ return;
+ }
+}
+
+void
+backup(int count)
+{+ Rune *cp;
+ int left, n;
+
+ unselect();
+
+ resize_flag = 1;
+ if(count == 0 && !pagemode) {+ n = ymax;
+ nbacklines = HISTSIZ; /* make sure we scroll to the very end */
+ } else{+ n = 3*(count+1)*ymax/4;
+ nbacklines = ymax-1;
+ }
+ cp = histp;
+ left = 1;
+ while (n >= 0) {+ cp--;
+ if(cp < hist)
+ cp = &hist[HISTSIZ-1];
+ if(*cp == '\0') {+ left = 0;
+ break;
+ }
+ if(*cp == '\n')
+ n--;
+ }
+ cp++;
+ if(cp >= &hist[HISTSIZ])
+ cp = hist;
+ backp = cp;
+ if(left)
+ backc = count;
+}
+
+Point
+pt(int x, int y)
+{+ return addpt(screen->r.min, Pt(x*ftsize.x+margin.x,y*ftsize.y+margin.y));
+}
+
+Point
+pos(Point pt)
+{+ pt.x -= screen->r.min.x + margin.x;
+ pt.y -= screen->r.min.y + margin.y;
+ pt.x /= ftsize.x;
+ pt.y /= ftsize.y;
+ if(pt.x < 0)
+ pt.x = 0;
+ else if(pt.x > xmax+1)
+ pt.x = xmax+1;
+ if(pt.y < 0)
+ pt.y = 0;
+ else if(pt.y > ymax+1)
+ pt.y = ymax+1;
+ return pt;
+}
+
+void
+shift(int x1, int y, int x2, int w)
+{+ if(y < 0 || y > ymax || x1 < 0 || x2 < 0 || w <= 0)
+ return;
+
+ if(x1+w > xmax+1)
+ w = xmax+1 - x1;
+ if(x2+w > xmax+1)
+ w = xmax+1 - x2;
+
+ screenchange(y) = 1;
+ memmove(onscreenr(x1, y), onscreenr(x2, y), w*sizeof(Rune));
+ memmove(onscreena(x1, y), onscreena(x2, y), w);
+ memmove(onscreenc(x1, y), onscreenc(x2, y), w);
+}
+
+void
+scroll(int sy, int ly, int dy, int cy) /* source, limit, dest, which line to clear */
+{+ int n, d, i;
+
+ if(sy < 0 || sy > ymax || dy < 0 || dy > ymax)
+ return;
+
+ n = ly - sy;
+ if(sy + n > ymax+1)
+ n = ymax+1 - sy;
+ if(dy + n > ymax+1)
+ n = ymax+1 - dy;
+
+ d = sy - dy;
+ if(n > 0 && d != 0){+ if(d > 0 && dy == 0 && n >= ymax){+ scrolloff += d;
+ } else {+ for(i = 0; i < n; i++)
+ screenchange(dy+i) = 1;
+ }
+ memmove(onscreenr(0, dy), onscreenr(0, sy), n*(xmax+2)*sizeof(Rune));
+ memmove(onscreena(0, dy), onscreena(0, sy), n*(xmax+2));
+ memmove(onscreenc(0, dy), onscreenc(0, sy), n*(xmax+2));
+ }
+
+ /* move selection */
+ selrect.min.y -= d;
+ selrect.max.y -= d;
+ select(selrect.min, selrect.max, 0);
+
+ clear(0, cy, xmax+1, cy+1);
+}
+
+void
+bigscroll(void) /* scroll up half a page */
+{+ int half = ymax/3;
+
+ if(x == 0 && y == 0)
+ return;
+ if(y < half) {+ clear(0, 0, xmax+1, ymax+1);
+ scrolloff = 0;
+ x = y = 0;
+ return;
+ }
+ scroll(half, ymax+1, 0, ymax);
+ clear(0, y-half+1, xmax+1, ymax+1);
+
+ y -= half;
+ if(olines)
+ olines -= half;
+}
+
+int
+number(Rune *p, int *got)
+{+ int c, n = 0;
+
+ if(got)
+ *got = 0;
+ while ((c = get_next_char()) >= '0' && c <= '9'){+ if(got)
+ *got = 1;
+ n = n*10 + c - '0';
+ }
+ *p = c;
+ return(n);
+}
+
+/* stubs */
+
+int
+host_avail(void)
+{+ if(*echop != 0 && fullrune(echop, strlen(echop)))
+ return 1;
+ if(hostbuf == nil)
+ return 0;
+ return *hostbufp != 0;
+}
+
+int
+rcvchar(void)
+{+ Rune r;
+
+ if(*echop != 0) {+ echop += chartorune(&r, echop);
+ if(*echop == 0) {+ echop = echo_input;
+ *echop = 0;
+ }
+ return r;
+ }
+ return *hostbufp++;
+}
+
+void
+ringbell(void){+}
+
+int
+alnum(int c)
+{+ if(c >= 'a' && c <= 'z')
+ return 1;
+ if(c >= 'A' && c <= 'Z')
+ return 1;
+ if(c >= '0' && c <= '9')
+ return 1;
+ return 0;
+}
+
+void
+escapedump(int fd,uchar *str,int len)
+{+ int i;
+
+ for(i = 0; i < len; i++) {+ if((str[i] < ' ' || str[i] > '\177') &&
+ str[i] != '\n' && str[i] != '\t') fprint(fd,"^%c",str[i]+64);
+ else if(str[i] == '\177') fprint(fd,"^$");
+ else if(str[i] == '\n') fprint(fd,"^J\n");
+ else fprint(fd,"%c",str[i]);
+ }
+}
+
+void
+drawstring(Rune *str, int n)
+{+ screenchange(y) = 1;
+ memmove(onscreenr(x, y), str, n*sizeof(Rune));
+ memset(onscreena(x, y), attr & 0xFF, n);
+ memset(onscreenc(x, y), attr >> 8, n);
+}
--- /dev/null
+++ b/sys/src/cmd/vt/mkfile
@@ -1,0 +1,13 @@
+</$objtype/mkfile
+
+TARG=vt
+
+OFILES=\
+ main.$O\
+ vt.$O\
+ fs.$O\
+
+HFILES=cons.h
+
+BIN=/$objtype/bin
+</sys/src/cmd/mkone
--- /dev/null
+++ b/sys/src/cmd/vt/termcap
@@ -1,0 +1,5 @@
+h2|2621|hp2621|hp2621a|hp2621p|2621|2621a|2621p|hp 2621:\
+ :is=\E&j@\r\E3\r:bt=\Ei:cm=\E&a%r%dc%dY:dc=2\EP:ip=2:\
+ :kh=\Ep\r:ku=\Et\r:kl=\Eu\r:kr=\Ev\r:kd=\Ew\r:\
+ :kn#8:k1=\Ep\r:k2=\Eq\r:k3=\Er\r:k4=\Es\r:k5=\Et\r:k6=\Eu\r:k7=\Ev\r:\
+ :k8=\Ew\r:ks=\E&jB:ke=\E&j@:ta=2^I:tc=hp:
--- /dev/null
+++ b/sys/src/cmd/vt/vt.c
@@ -1,0 +1,1033 @@
+/*
+ * Known bugs:
+ *
+ * 1. We don't handle cursor movement characters inside escape sequences.
+ * That is, ESC[2C moves two to the right, so ESC[2\bC is supposed to back
+ * up one and then move two to the right.
+ *
+ * 2. We don't handle tabstops past nelem(tabcol) columns.
+ *
+ * 3. We don't respect requests to do reverse video for the whole screen.
+ *
+ * 4. We ignore the ESC#n codes, so that we don't do double-width nor
+ * double-height lines, nor the ``fill the screen with E's'' confidence check.
+ *
+ * 5. Cursor key sequences aren't selected by keypad application mode.
+ *
+ * 6. "VT220" mode (-2) currently just switches the default cursor key
+ * functions (same as -a); it's still just a VT100 emulation.
+ *
+ * 7. VT52 mode and a few other rarely used features are not implemented.
+ */
+
+#include <u.h>
+#include <libc.h>
+#include <draw.h>
+
+#include "cons.h"
+
+#include <ctype.h>
+
+int wraparound = 1;
+int originrelative = 0;
+int bracketed = 0;
+
+int tabcol[200];
+char osc7cwd[WDIR];
+
+struct funckey ansifk[] = {+ { "up key", "\033[A", },+ { "down key", "\033[B", },+ { "left key", "\033[D", },+ { "right key", "\033[C", },+ { "F1", "\033OP", },+ { "F2", "\033OQ", },+ { "F3", "\033OR", },+ { "F4", "\033OS", },+ { "F5", "\033OT", },+ { "F6", "\033OU", },+ { "F7", "\033OV", },+ { "F8", "\033OW", },+ { "F9", "\033OX", },+ { "F10", "\033OY", },+ { "F11", "\033OZ", },+ { "F12", "\033O1", },+ { 0 },+};
+
+struct funckey ansiappfk[] = {+ { "up key", "\033OA", },+ { "down key", "\033OB", },+ { "left key", "\033OD", },+ { "right key", "\033OC", },+
+ { 0 },+};
+
+struct funckey vt220fk[] = {+ { "insert", "\033[2~", },+ { "delete", "\033[3~", },+ { "home", "\033[1~", },+ { "end", "\033[4~", },+ { "page up", "\033[5~", },+ { "page down", "\033[6~", },+
+ { "up key", "\033[A", },+ { "down key", "\033[B", },+ { "left key", "\033[D", },+ { "right key", "\033[C", },+
+ { "F1", "\033OP", },+ { "F2", "\033OQ", },+ { "F3", "\033OR", },+ { "F4", "\033OS", },+ { "F5", "\033[15~", },+ { "F6", "\033[17~", },+ { "F7", "\033[18~", },+ { "F8", "\033[19~", },+ { "F9", "\033[20~", },+ { "F10", "\033[21~", },+ { "F11", "\033[23~", },+ { "F12", "\033[24~", },+
+ { 0 },+};
+
+struct funckey xtermfk[] = {+ { "insert", "\033[2~", },+ { "delete", "\033[3~", },+ { "home", "\033OH", },+ { "end", "\033OF", },+ { "page up", "\033[5~", },+ { "page down", "\033[6~", },+
+ { "up key", "\033[A", },+ { "down key", "\033[B", },+ { "left key", "\033[D", },+ { "right key", "\033[C", },+
+ { "F1", "\033OP", },+ { "F2", "\033OQ", },+ { "F3", "\033OR", },+ { "F4", "\033OS", },+ { "F5", "\033[15~", },+ { "F6", "\033[17~", },+ { "F7", "\033[18~", },+ { "F8", "\033[19~", },+ { "F9", "\033[20~", },+ { "F10", "\033[21~", },+ { "F11", "\033[23~", },+ { "F12", "\033[24~", },+
+ { 0 },+};
+
+char gmap[256] = {+ ['_'] ' ', /* blank */
+ ['\\'] '*', /* diamond */
+ ['a'] 'X', /* checkerboard */
+ ['b'] '\t', /* HT */
+ ['c'] '\x0C', /* FF */
+ ['d'] '\r', /* CR */
+ ['e'] '\n', /* LF */
+ ['f'] 'o', /* degree */
+ ['g'] '+', /* plus/minus */
+ ['h'] '\n', /* NL, but close enough */
+ ['i'] '\v', /* VT */
+ ['j'] '+', /* lower right corner */
+ ['k'] '+', /* upper right corner */
+ ['l'] '+', /* upper left corner */
+ ['m'] '+', /* lower left corner */
+ ['n'] '+', /* crossing lines */
+ ['o'] '-', /* horiz line - scan 1 */
+ ['p'] '-', /* horiz line - scan 3 */
+ ['q'] '-', /* horiz line - scan 5 */
+ ['r'] '-', /* horiz line - scan 7 */
+ ['s'] '-', /* horiz line - scan 9 */
+ ['t'] '+', /* |- */
+ ['u'] '+', /* -| */
+ ['v'] '+', /* upside down T */
+ ['w'] '+', /* rightside up T */
+ ['x'] '|', /* vertical bar */
+ ['y'] '<', /* less/equal */
+ ['z'] '>', /* gtr/equal */
+ ['{'] 'p', /* pi */+ ['|'] '!', /* not equal */
+ ['}'] 'L', /* pound symbol */
+ ['~'] '.', /* centered dot: · */
+};
+
+static void setattr(int argc, int *argv);
+static void osc(void);
+
+void
+fixops(int *operand)
+{+ if(operand[0] < 1)
+ operand[0] = 1;
+}
+
+void
+emulate(void)
+{+ Rune buf[BUFS+1];
+ int i;
+ int n;
+ int c;
+ int operand[10];
+ int noperand;
+ int savex, savey, saveattr, saveisgraphics;
+ int isgraphics;
+ int g0set, g1set;
+
+ isgraphics = 0;
+ g0set = 'B'; /* US ASCII */
+ g1set = 'B'; /* US ASCII */
+ savex = savey = 0;
+ yscrmin = 0;
+ yscrmax = ymax;
+ saveattr = 0;
+ saveisgraphics = 0;
+ /* set initial tab stops to DEC-standard 8-column spacing */
+ for(c=0; (c+=8)<nelem(tabcol);)
+ tabcol[c] = 1;
+
+ for (;;) {+ if (y > ymax) {+ x = 0;
+ newline();
+ }
+ buf[0] = get_next_char();
+ buf[1] = '\0';
+ switch(buf[0]) {+
+ case '\000':
+ case '\001':
+ case '\002':
+ case '\003':
+ case '\004':
+ case '\005':
+ case '\006':
+ goto Default;
+
+ case '\007': /* bell */
+ ringbell();
+ break;
+
+ case '\010': /* backspace */
+ if (x > 0)
+ --x;
+ break;
+
+ case '\011': /* tab to next tab stop; if none, to right margin */
+ for(c=x+1; c<nelem(tabcol) && !tabcol[c]; c++)
+ ;
+ if(c < nelem(tabcol))
+ x = c;
+ else
+ x = xmax;
+ break;
+
+ case '\012': /* linefeed */
+ case '\013':
+ case '\014':
+ newline();
+ if (ttystate[cs->raw].nlcr)
+ x = 0;
+ break;
+
+ case '\015': /* carriage return */
+ x = 0;
+ if (ttystate[cs->raw].crnl)
+ newline();
+ break;
+
+ case '\016': /* SO: invoke G1 char set */
+ isgraphics = (isdigit(g1set));
+ break;
+ case '\017': /* SI: invoke G0 char set */
+ isgraphics = (isdigit(g0set));
+ break;
+
+ case '\020': /* DLE */
+ case '\021': /* DC1 */
+ case '\022': /* XON */
+ case '\023': /* DC3 */
+ case '\024': /* XOFF */
+ case '\025': /* NAK */
+ case '\026': /* SYN */
+ case '\027': /* ETB */
+ case '\030': /* CAN: cancel escape sequence, display checkerboard (not implemented) */
+ case '\031': /* EM */
+ case '\032': /* SUB: same as CAN */
+ goto Default;
+;
+ /* ESC, \033, is handled below */
+ case '\034': /* FS */
+ case '\035': /* GS */
+ case '\036': /* RS */
+ case '\037': /* US */
+ break;
+ case '\177': /* delete: ignored */
+ break;
+
+ case '\033':
+ switch(get_next_char()){+ /*
+ * 1 - graphic processor option on (no-op; not installed)
+ */
+ case '1':
+ break;
+
+ /*
+ * 2 - graphic processor option off (no-op; not installed)
+ */
+ case '2':
+ break;
+
+ /*
+ * 7 - save cursor position.
+ */
+ case '7':
+ savex = x;
+ savey = y;
+ saveattr = attr;
+ saveisgraphics = isgraphics;
+ break;
+
+ /*
+ * 8 - restore cursor position.
+ */
+ case '8':
+ x = savex;
+ y = savey;
+ attr = saveattr;
+ isgraphics = saveisgraphics;
+ break;
+
+ /*
+ * c - Reset terminal.
+ */
+ case 'c':
+ cursoron = 1;
+ ttystate[cs->raw].nlcr = 0;
+ break;
+
+ /*
+ * D - active position down a line, scroll if at bottom margin.
+ * (Original VT100 had a bug: tracked new-line/line-feed mode.)
+ */
+ case 'D':
+ if(++y > yscrmax) {+ y = yscrmax;
+ scroll(yscrmin+1, yscrmax+1, yscrmin, yscrmax);
+ }
+ break;
+
+ /*
+ * E - active position to start of next line, scroll if at bottom margin.
+ */
+ case 'E':
+ x = 0;
+ if(++y > yscrmax) {+ y = yscrmax;
+ scroll(yscrmin+1, yscrmax+1, yscrmin, yscrmax);
+ }
+ break;
+
+ /*
+ * H - set tab stop at current column.
+ * (This is cursor home in VT52 mode (not implemented).)
+ */
+ case 'H':
+ if(x < nelem(tabcol))
+ tabcol[x] = 1;
+ break;
+
+ /*
+ * M - active position up a line, scroll if at top margin..
+ */
+ case 'M':
+ if(--y < yscrmin) {+ y = yscrmin;
+ scroll(yscrmin, yscrmax, yscrmin+1, yscrmin);
+ }
+ break;
+
+ /*
+ * Z - identification. the terminal
+ * emulator will return the response
+ * code for a generic VT100.
+ */
+ case 'Z':
+ Ident:
+ sendnchars(7, "\033[?1;2c"); /* VT100 with AVO option */
+ break;
+
+ /*
+ * < - enter ANSI mode
+ */
+ case '<':
+ break;
+
+ /*
+ * > - set numeric keypad mode on (not implemented)
+ */
+ case '>':
+ break;
+
+ /*
+ * = - set numeric keypad mode off (not implemented)
+ */
+ case '=':
+ break;
+
+ /*
+ * # - Takes a one-digit argument
+ */
+ case '#':
+ switch(get_next_char()){+ case '3': /* Top half of double-height line */
+ case '4': /* Bottom half of double-height line */
+ case '5': /* Single-width single-height line */
+ case '6': /* Double-width line */
+ case '7': /* Screen print */
+ case '8': /* Fill screen with E's */
+ break;
+ }
+ break;
+
+ /*
+ * ( - switch G0 character set
+ */
+ case '(':+ g0set = get_next_char();
+ break;
+
+ /*
+ * - switch G1 character set
+ */
+ case ')':
+ g1set = get_next_char();
+ break;
+
+ /*
+ * Received left bracket.
+ */
+ case '[':
+ /*
+ * A semi-colon or ? delimits arguments.
+ */
+ memset(operand, 0, sizeof(operand));
+ operand[0] = number(buf, &i);
+ noperand = 1;
+ while(buf[0] == ';' || buf[0] == '?'){+ if(noperand < nelem(operand))
+ operand[noperand++] = number(buf, nil);
+ else
+ number(buf, nil);
+ }
+
+ /*
+ * do escape2 stuff
+ */
+ switch(buf[0]){+ /*
+ * c - same as ESC Z: what are you?
+ */
+ case 'c':
+ goto Ident;
+
+ /*
+ * g - various tabstop manipulation
+ */
+ case 'g':
+ switch(operand[0]){+ case 0: /* clear tab at current column */
+ if(x < nelem(tabcol))
+ tabcol[x] = 0;
+ break;
+ case 3: /* clear all tabs */
+ memset(tabcol, 0, sizeof tabcol);
+ break;
+ }
+ break;
+
+ /*
+ * l - clear various options.
+ */
+ case 'l':
+ if(noperand == 1){+ switch(operand[0]){ + case 20: /* set line feed mode */
+ ttystate[cs->raw].nlcr = 1;
+ break;
+ case 30: /* screen invisible (? not supported through VT220) */
+ break;
+ }
+ }else while(--noperand > 0){+ switch(operand[noperand]){+ case 1: /* set cursor keys to send ANSI functions: ESC [ A..D */
+ appfk = nil;
+ break;
+ case 2: /* set VT52 mode (not implemented) */
+ break;
+ case 3: /* set 80 columns */
+ setdim(-1, 80);
+ break;
+ case 4: /* set jump scrolling */
+ break;
+ case 5: /* set normal video on screen */
+ break;
+ case 6: /* set origin to absolute */
+ originrelative = 0;
+ x = y = 0;
+ break;
+ case 7: /* reset auto-wrap mode */
+ wraparound = 0;
+ break;
+ case 8: /* reset auto-repeat mode */
+ break;
+ case 9: /* reset interlacing mode */
+ break;
+ case 25: /* text cursor off (VT220) */
+ cursoron = 0;
+ break;
+ case 2004: /* bracketed paste mode off */
+ bracketed = 0;
+ break;
+ }
+ }
+ break;
+
+ /*
+ * s - some dec private stuff. actually [ ? num s, but we can't detect it.
+ */
+ case 's':
+ break;
+
+ /*
+ * h - set various options.
+ */
+ case 'h':
+ if(noperand == 1){+ switch(operand[0]){+ default:
+ break;
+ case 20: /* set newline mode */
+ ttystate[cs->raw].nlcr = 0;
+ break;
+ case 30: /* screen visible (? not supported through VT220) */
+ break;
+ }
+ }else while(--noperand > 0){+ switch(operand[noperand]){+ default:
+ break;
+ case 1: /* set cursor keys to send application function: ESC O A..D */
+ appfk = ansiappfk;
+ break;
+ case 2: /* set ANSI */
+ break;
+ case 3: /* set 132 columns */
+ setdim(-1, 132);
+ break;
+ case 4: /* set smooth scrolling */
+ break;
+ case 5: /* set screen to reverse video (not implemented) */
+ break;
+ case 6: /* set origin to relative */
+ originrelative = 1;
+ x = 0;
+ y = yscrmin;
+ break;
+ case 7: /* set auto-wrap mode */
+ wraparound = 1;
+ break;
+ case 8: /* set auto-repeat mode */
+ break;
+ case 9: /* set interlacing mode */
+ break;
+ case 25: /* text cursor on (VT220) */
+ cursoron = 1;
+ break;
+ case 2004: /* bracketed paste mode on */
+ bracketed = 1;
+ break;
+ }
+ }
+ break;
+
+ /*
+ * m - change character attrs.
+ */
+ case 'm':
+ setattr(noperand, operand);
+ break;
+
+ /*
+ * n - request various reports
+ */
+ case 'n':
+ switch(operand[0]){+ case 5: /* status */
+ sendnchars(4, "\033[0n"); /* terminal ok */
+ break;
+ case 6: /* cursor position */
+ sendnchars(sprint((char*)buf, "\033[%d;%dR",
+ originrelative ? y+1 - yscrmin : y+1, x+1), (char*)buf);
+ break;
+ }
+ break;
+
+ /*
+ * q - turn on list of LEDs; turn off others.
+ */
+ case 'q':
+ break;
+
+ /*
+ * r - change scrolling region. operand[0] is
+ * min scrolling region and operand[1] is max
+ * scrolling region.
+ */
+ case 'r':
+ yscrmin = 0;
+ yscrmax = ymax;
+ switch(noperand){+ case 2:
+ yscrmax = operand[1]-1;
+ if(yscrmax > ymax)
+ yscrmax = ymax;
+ case 1:
+ yscrmin = operand[0]-1;
+ if(yscrmin < 0)
+ yscrmin = 0;
+ }
+ x = 0;
+ y = yscrmin;
+ break;
+
+ /*
+ * x - report terminal parameters
+ */
+ case 'x':
+ sendnchars(20, "\033[3;1;1;120;120;1;0x");
+ break;
+
+ /*
+ * y - invoke confidence test
+ */
+ case 'y':
+ break;
+
+ /*
+ * z - line spacing
+ */
+ case 'z':
+ break;
+
+ /*
+ * A - cursor up.
+ */
+ case 'e':
+ case 'A':
+ fixops(operand);
+ y -= operand[0];
+ if(y < yscrmin)
+ y = yscrmin;
+ olines -= operand[0];
+ if(olines < 0)
+ olines = 0;
+ break;
+
+ /*
+ * B - cursor down
+ */
+ case 'B':
+ fixops(operand);
+ y += operand[0];
+ if(y > yscrmax)
+ y=yscrmax;
+ break;
+
+ /*
+ * C - cursor right
+ */
+ case 'a':
+ case 'C':
+ fixops(operand);
+ x += operand[0];
+ /*
+ * VT-100-UG says not to go past the
+ * right margin.
+ */
+ if(x > xmax)
+ x = xmax;
+ break;
+
+ /*
+ * D - cursor left
+ */
+ case 'D':
+ fixops(operand);
+ x -= operand[0];
+ if(x < 0)
+ x = 0;
+ break;
+
+ /*
+ * G - cursor to column
+ */
+ case '\'':
+ case 'G':
+ fixops(operand);
+ x = operand[0] - 1;
+ if(x > xmax)
+ x = xmax;
+ break;
+
+ /*
+ * H and f - cursor motion. operand[0] is row and
+ * operand[1] is column, origin 1.
+ */
+ case 'H':
+ case 'f':
+ fixops(operand+1);
+ x = operand[1] - 1;
+ if(x > xmax)
+ x = xmax;
+
+ /* fallthrough */
+
+ /*
+ * d - cursor to line n (xterm)
+ */
+ case 'd':
+ fixops(operand);
+ y = operand[0] - 1;
+ if(originrelative){+ y += yscrmin;
+ if(y > yscrmax)
+ y = yscrmax;
+ }else{+ if(y > ymax)
+ y = ymax;
+ }
+ break;
+
+ /*
+ * J - clear some or all of the display.
+ */
+ case 'J':
+ switch (operand[0]) {+ /*
+ * operand 2: whole screen.
+ */
+ case 2:
+ clear(0, 0, xmax+1, ymax+1);
+ break;
+ /*
+ * operand 1: start of screen to active position, inclusive.
+ */
+ case 1:
+ clear(0, 0, xmax+1, y);
+ clear(0, y, x+1, y+1);
+ break;
+ /*
+ * Default: active position to end of screen, inclusive.
+ */
+ default:
+ clear(x, y, xmax+1, y+1);
+ clear(0, y+1, xmax+1, ymax+1);
+ break;
+ }
+ break;
+
+ /*
+ * K - clear some or all of the line.
+ */
+ case 'K':
+ switch (operand[0]) {+ /*
+ * operand 2: whole line.
+ */
+ case 2:
+ clear(0, y, xmax+1, y+1);
+ break;
+ /*
+ * operand 1: start of line to active position, inclusive.
+ */
+ case 1:
+ clear(0, y, x+1, y+1);
+ break;
+ /*
+ * Default: active position to end of line, inclusive.
+ */
+ default:
+ clear(x, y, xmax+1, y+1);
+ break;
+ }
+ break;
+
+ /*
+ * P - delete character(s) from right of cursor (xterm)
+ */
+ case 'P':
+ fixops(operand);
+ i = x + operand[0];
+ shift(x, y, i, xmax+1 - i);
+ clear(xmax-operand[0], y, xmax+1, y+1);
+ break;
+
+ /*
+ * @ - insert blank(s) to right of cursor (xterm)
+ */
+ case '@':
+ fixops(operand);
+ i = x + operand[0];
+ shift(i, y, x, xmax+1 - i);
+ clear(x, y, i, y+1);
+ break;
+
+
+ /*
+ * X - erase character(s) at cursor and to the right (xterm)
+ */
+ case 'X':
+ fixops(operand);
+ i = x + operand[0];
+ clear(x, y, i, y+1);
+ break;
+
+ /*
+ * L - insert a line at cursor position (VT102 and later)
+ */
+ case 'L':
+ fixops(operand);
+ for(i = 0; i < operand[0]; ++i)
+ scroll(y, yscrmax, y+1, y);
+ break;
+
+ /*
+ * M - delete a line at cursor position (VT102 and later)
+ */
+ case 'M':
+ fixops(operand);
+ for(i = 0; i < operand[0]; ++i)
+ scroll(y+1, yscrmax+1, y, yscrmax);
+ break;
+
+ /*
+ * S,T - scroll up/down (xterm)
+ */
+ case 'T':
+ fixops(operand);
+ for(i = 0; i < operand[0]; ++i)
+ scroll(yscrmin, yscrmax, yscrmin+1, yscrmin);
+ break;
+
+ case 'S':
+ fixops(operand);
+ for(i = 0; i < operand[0]; ++i)
+ scroll(yscrmin+1, yscrmax+1, yscrmin, yscrmin);
+ break;
+
+ case '=': /* ? not supported through VT220 */
+ number(buf, nil);
+ switch(buf[0]) {+ case 'h':
+ case 'l':
+ break;
+ }
+ break;
+ case '>': /* Set/reset key modifier options (XTMODKEYS), xterm. */
+ number(buf, nil);
+ if(buf[0] != 'm')
+ number(buf, nil);
+ break;
+ }
+
+ break;
+
+ /*
+ * Collapse multiple '\033' to one.
+ */
+ case '\033':
+ peekc = '\033';
+ break;
+
+ /* OSC escape */
+ case ']':
+ osc();
+ break;
+ }
+ break;
+
+ default: /* ordinary char */
+Default:
+ if(isgraphics && buf[0] < nelem(gmap) && gmap[buf[0]])
+ buf[0] = gmap[buf[0]];
+
+ /* line wrap */
+ if (x > xmax){+ if(wraparound){+ newline();
+ x = 0;
+ }else{+ continue;
+ }
+ }
+ n = 1;
+ c = 0;
+ while (!cs->raw && host_avail() && x+n<=xmax && n<BUFS
+ && (c = get_next_char())>=' ' && c<'\177') {+ buf[n++] = c;
+ c = 0;
+ }
+ buf[n] = 0;
+ drawstring(buf, n);
+ x += n;
+ peekc = c;
+ break;
+ }
+ }
+}
+
+static void
+setattr(int argc, int *argv)
+{+ int i;
+
+ for(i=0; i<argc; i++) {+ switch(argv[i]) {+ case 0:
+ attr = defattr;
+ break;
+ case 1:
+ attr |= THighIntensity;
+ break;
+ case 4:
+ attr |= TUnderline;
+ break;
+ case 5:
+ attr |= TBlink;
+ break;
+ case 7:
+ attr |= TReverse;
+ break;
+ case 8:
+ attr |= TInvisible;
+ break;
+ case 22:
+ attr &= ~THighIntensity;
+ break;
+ case 24:
+ attr &= ~TUnderline;
+ break;
+ case 25:
+ attr &= ~TBlink;
+ break;
+ case 27:
+ attr &= ~TReverse;
+ break;
+ case 28:
+ attr &= ~TInvisible;
+ break;
+ case 30: /* black */
+ case 31: /* red */
+ case 32: /* green */
+ case 33: /* brown */
+ case 34: /* blue */
+ case 35: /* purple */
+ case 36: /* cyan */
+ case 37: /* white */
+ attr = (attr & ~0xF000) | 0x1000 | (argv[i]-30)<<13;
+ break;
+ case 39: /* default */
+ attr &= ~0xF000;
+ break;
+ case 40: /* black */
+ case 41: /* red */
+ case 42: /* green */
+ case 43: /* brown */
+ case 44: /* blue */
+ case 45: /* purple */
+ case 46: /* cyan */
+ case 47: /* white */
+ attr = (attr & ~0x0F00) | 0x0100 | (argv[i]-40)<<9;
+ break;
+ case 49: /* default */
+ attr &= ~0x0F00;
+ break;
+ }
+ }
+}
+
+static int
+hexnib(char c)
+{+ if(c >= 'a')
+ return c - 'a' + 10;
+ if(c >= 'A')
+ return c - 'A' + 10;
+ return c - '0';
+}
+
+// handle ESC], Operating System Command
+static void
+osc(void)
+{+ Rune ch, buf[BUFS+1];
+ int fd, osc, got, i;
+ char *o, *s;
+ osc = number(&ch, &got);
+
+ if(got) {+ switch(osc) {+ case 0:
+ case 1:
+ case 2: /* set title */
+ i = 0;
+
+ while((ch = get_next_char()) != '\a') {+ if(i < nelem(buf) - 1) {+ buf[i++] = ch;
+ }
+ }
+ buf[i] = 0;
+ if((fd = open("/dev/label", OWRITE)) >= 0) {+ fprint(fd, "%S", buf);
+ close(fd);
+ }
+ break;
+
+ case 7: /* set pwd */
+ i = 0;
+
+ while((ch = get_next_char()) != '\033'){+ if(i < sizeof(osc7cwd)-UTFmax-1)
+ i += runetochar(osc7cwd+i, &ch);
+ }
+ get_next_char();
+ osc7cwd[i] = 0;
+
+ /* file://hostname/path → /n/hostname/path */
+ if(strncmp(osc7cwd, "file://", 7) == 0){+ osc7cwd[0] = '/';
+ osc7cwd[1] = 'n';
+ o = osc7cwd+2;
+ s = osc7cwd+6;
+ while(*s){+ if(*s == '%' && s[1] != 0 && s[2] != 0){+ *o++ = hexnib(s[1])<<4 | hexnib(s[2]);
+ s += 3;
+ }else
+ *o++ = *s++;
+ }
+ *o = 0;
+ }
+ break;
+ }
+ }
+}