shithub: misc

Info  •  Files  •  Log

import

--- /dev/null

+++ b/INDEX

@@ -1,0 +1,10 @@

+calc		learning yacc

+cpick		color picker: take snapshot of screen, then scroll to this window's position for colors

+hcol		display a hex color

+lr		obsolete walk(1)-like

+mev		visualize mouse grabbing

+rfx		mouse accuracy game

+solt		first attempts at plan9 programming

+spd		typing accuracy game (try with /lib/theo!)

+tev		print keyboard/mouse events

+wstat		use syscall(1) instead

--- /dev/null

+++ b/calc.c

@@ -1,0 +1,402 @@

+

+#line	2	"/usr/qwx/p/misc/calc.y"

+#include <u.h>

+#include <libc.h>

+#include <bio.h>

+#include <ctype.h>

+

+int yylex(void);

+int yyparse(void);

+void yyerror(char*);

+

+Biobuf *bf;

+

+#line	14	"/usr/qwx/p/misc/calc.y"

+typedef union {

+	int i;

+} YYSTYPE;

+extern	int	yyerrflag;

+#ifndef	YYMAXDEPTH

+#define	YYMAXDEPTH	150

+#endif

+YYSTYPE	yylval;

+YYSTYPE	yyval;

+#define	NUM	57346

+#define YYEOFCODE 1

+#define YYERRCODE 2

+

+#line	36	"/usr/qwx/p/misc/calc.y"

+

+

+void

+yyerror(char *s)

+{

+	fprint(2, "%s\n", s);

+}

+

+int

+getnum(int c)

+{

+	char s[64], *p;

+

+	for(p=s, *p++=c; isdigit(c=Bgetc(bf));)

+		if(p < s+sizeof(s)-1)

+			*p++ = c;

+	*p = 0;

+	Bungetc(bf);

+	return strtol(s, nil, 10);

+}

+

+int

+yylex(void)

+{

+	int n, c;

+

+	do

+		c = Bgetc(bf);

+	while(c != '\n' && isspace(c));

+	if(isdigit(c)){

+		yylval.i = getnum(c);

+		return NUM;

+	}else if(c == 'd'){

+		n = getnum(Bgetc(bf));

+		yylval.i = nrand(n != 0 ? n : 1);

+		return NUM;

+	}else

+		return c;

+}

+

+void

+main(int argc, char **argv)

+{

+	ARGBEGIN{

+	}ARGEND

+	if((bf = Bfdopen(0, OREAD)) == nil)

+		sysfatal("Bfdopen: %r");

+	yyparse();

+}

+short	yyexca[] =

+{-1, 1,

+	1, -1,

+	-2, 0,

+};

+#define	YYNPROD	10

+#define	YYPRIVATE 57344

+#define	YYLAST	31

+short	yyact[] =

+{

+   6,   7,   8,   9,  10,   2,   1,  17,   0,   0,

+  11,   0,  12,  13,  14,  15,  16,   6,   7,   8,

+   9,  10,   5,   3,   8,   9,  10,   0,   0,   0,

+   4

+};

+short	yypact[] =

+{

+-1000,  19,  12,-1000,  19,-1000,  19,  19,  19,  19,

+  19,  -5,  17,  17,-1000,-1000,-1000,-1000

+};

+short	yypgo[] =

+{

+   0,   5,   6

+};

+short	yyr1[] =

+{

+   0,   2,   2,   1,   1,   1,   1,   1,   1,   1

+};

+short	yyr2[] =

+{

+   0,   0,   3,   1,   3,   3,   3,   3,   3,   3

+};

+short	yychk[] =

+{

+-1000,  -2,  -1,   4,  11,  10,   5,   6,   7,   8,

+   9,  -1,  -1,  -1,  -1,  -1,  -1,  12

+};

+short	yydef[] =

+{

+   1,  -2,   0,   3,   0,   2,   0,   0,   0,   0,

+   0,   0,   5,   6,   7,   8,   9,   4

+};

+short	yytok1[] =

+{

+   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,

+  10,   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,   9,   0,   0,

+  11,  12,   7,   5,   0,   6,   0,   8

+};

+short	yytok2[] =

+{

+   2,   3,   4

+};

+long	yytok3[] =

+{

+   0

+};

+

+#line	1	"/sys/lib/yaccpar"

+#define YYFLAG 		-1000

+#define	yyclearin	yychar = -1

+#define	yyerrok		yyerrflag = 0

+

+#ifdef	yydebug

+#include	"y.debug"

+#else

+#define	yydebug		0

+char*	yytoknames[1];		/* for debugging */

+char*	yystates[1];		/* for debugging */

+#endif

+

+/*	parser for yacc output	*/

+

+int	yynerrs = 0;		/* number of errors */

+int	yyerrflag = 0;		/* error recovery flag */

+

+extern	int	fprint(int, char*, ...);

+extern	int	sprint(char*, char*, ...);

+

+char*

+yytokname(int yyc)

+{

+	static char x[16];

+

+	if(yyc > 0 && yyc <= sizeof(yytoknames)/sizeof(yytoknames[0]))

+	if(yytoknames[yyc-1])

+		return yytoknames[yyc-1];

+	sprint(x, "<%d>", yyc);

+	return x;

+}

+

+char*

+yystatname(int yys)

+{

+	static char x[16];

+

+	if(yys >= 0 && yys < sizeof(yystates)/sizeof(yystates[0]))

+	if(yystates[yys])

+		return yystates[yys];

+	sprint(x, "<%d>\n", yys);

+	return x;

+}

+

+long

+yylex1(void)

+{

+	long yychar;

+	long *t3p;

+	int c;

+

+	yychar = yylex();

+	if(yychar <= 0) {

+		c = yytok1[0];

+		goto out;

+	}

+	if(yychar < sizeof(yytok1)/sizeof(yytok1[0])) {

+		c = yytok1[yychar];

+		goto out;

+	}

+	if(yychar >= YYPRIVATE)

+		if(yychar < YYPRIVATE+sizeof(yytok2)/sizeof(yytok2[0])) {

+			c = yytok2[yychar-YYPRIVATE];

+			goto out;

+		}

+	for(t3p=yytok3;; t3p+=2) {

+		c = t3p[0];

+		if(c == yychar) {

+			c = t3p[1];

+			goto out;

+		}

+		if(c == 0)

+			break;

+	}

+	c = 0;

+

+out:

+	if(c == 0)

+		c = yytok2[1];	/* unknown char */

+	if(yydebug >= 3)

+		fprint(2, "lex %.4lux %s\n", yychar, yytokname(c));

+	return c;

+}

+

+int

+yyparse(void)

+{

+	struct

+	{

+		YYSTYPE	yyv;

+		int	yys;

+	} yys[YYMAXDEPTH], *yyp, *yypt;

+	short *yyxi;

+	int yyj, yym, yystate, yyn, yyg;

+	long yychar;

+	YYSTYPE save1, save2;

+	int save3, save4;

+

+	save1 = yylval;

+	save2 = yyval;

+	save3 = yynerrs;

+	save4 = yyerrflag;

+

+	yystate = 0;

+	yychar = -1;

+	yynerrs = 0;

+	yyerrflag = 0;

+	yyp = &yys[-1];

+	goto yystack;

+

+ret0:

+	yyn = 0;

+	goto ret;

+

+ret1:

+	yyn = 1;

+	goto ret;

+

+ret:

+	yylval = save1;

+	yyval = save2;

+	yynerrs = save3;

+	yyerrflag = save4;

+	return yyn;

+

+yystack:

+	/* put a state and value onto the stack */

+	if(yydebug >= 4)

+		fprint(2, "char %s in %s", yytokname(yychar), yystatname(yystate));

+

+	yyp++;

+	if(yyp >= &yys[YYMAXDEPTH]) {

+		yyerror("yacc stack overflow");

+		goto ret1;

+	}

+	yyp->yys = yystate;

+	yyp->yyv = yyval;

+

+yynewstate:

+	yyn = yypact[yystate];

+	if(yyn <= YYFLAG)

+		goto yydefault; /* simple state */

+	if(yychar < 0)

+		yychar = yylex1();

+	yyn += yychar;

+	if(yyn < 0 || yyn >= YYLAST)

+		goto yydefault;

+	yyn = yyact[yyn];

+	if(yychk[yyn] == yychar) { /* valid shift */

+		yychar = -1;

+		yyval = yylval;

+		yystate = yyn;

+		if(yyerrflag > 0)

+			yyerrflag--;

+		goto yystack;

+	}

+

+yydefault:

+	/* default state action */

+	yyn = yydef[yystate];

+	if(yyn == -2) {

+		if(yychar < 0)

+			yychar = yylex1();

+

+		/* look through exception table */

+		for(yyxi=yyexca;; yyxi+=2)

+			if(yyxi[0] == -1 && yyxi[1] == yystate)

+				break;

+		for(yyxi += 2;; yyxi += 2) {

+			yyn = yyxi[0];

+			if(yyn < 0 || yyn == yychar)

+				break;

+		}

+		yyn = yyxi[1];

+		if(yyn < 0)

+			goto ret0;

+	}

+	if(yyn == 0) {

+		/* error ... attempt to resume parsing */

+		switch(yyerrflag) {

+		case 0:   /* brand new error */

+			yyerror("syntax error");

+			yynerrs++;

+			if(yydebug >= 1) {

+				fprint(2, "%s", yystatname(yystate));

+				fprint(2, "saw %s\n", yytokname(yychar));

+			}

+

+		case 1:

+		case 2: /* incompletely recovered error ... try again */

+			yyerrflag = 3;

+

+			/* find a state where "error" is a legal shift action */

+			while(yyp >= yys) {

+				yyn = yypact[yyp->yys] + YYERRCODE;

+				if(yyn >= 0 && yyn < YYLAST) {

+					yystate = yyact[yyn];  /* simulate a shift of "error" */

+					if(yychk[yystate] == YYERRCODE)

+						goto yystack;

+				}

+

+				/* the current yyp has no shift onn "error", pop stack */

+				if(yydebug >= 2)

+					fprint(2, "error recovery pops state %d, uncovers %d\n",

+						yyp->yys, (yyp-1)->yys );

+				yyp--;

+			}

+			/* there is no state on the stack with an error shift ... abort */

+			goto ret1;

+

+		case 3:  /* no shift yet; clobber input char */

+			if(yydebug >= 2)

+				fprint(2, "error recovery discards %s\n", yytokname(yychar));

+			if(yychar == YYEOFCODE)

+				goto ret1;

+			yychar = -1;

+			goto yynewstate;   /* try again in the same state */

+		}

+	}

+

+	/* reduction by production yyn */

+	if(yydebug >= 2)

+		fprint(2, "reduce %d in:\n\t%s", yyn, yystatname(yystate));

+

+	yypt = yyp;

+	yyp -= yyr2[yyn];

+	yyval = (yyp+1)->yyv;

+	yym = yyn;

+

+	/* consult goto table to find next state */

+	yyn = yyr1[yyn];

+	yyg = yypgo[yyn];

+	yyj = yyg + yyp->yys + 1;

+

+	if(yyj >= YYLAST || yychk[yystate=yyact[yyj]] != -yyn)

+		yystate = yyact[yyg];

+	switch(yym) {

+		

+case 2:

+#line	26	"/usr/qwx/p/misc/calc.y"

+{ print("%d\n", yypt[-1].yyv.i); } break;

+case 3:

+#line	28	"/usr/qwx/p/misc/calc.y"

+{ yyval.i = yypt[-0].yyv.i; } break;

+case 4:

+#line	29	"/usr/qwx/p/misc/calc.y"

+{ yyval.i = yypt[-1].yyv.i; } break;

+case 5:

+#line	30	"/usr/qwx/p/misc/calc.y"

+{ yyval.i = yypt[-2].yyv.i + yypt[-0].yyv.i; } break;

+case 6:

+#line	31	"/usr/qwx/p/misc/calc.y"

+{ yyval.i = yypt[-2].yyv.i - yypt[-0].yyv.i; } break;

+case 7:

+#line	32	"/usr/qwx/p/misc/calc.y"

+{ yyval.i = yypt[-2].yyv.i * yypt[-0].yyv.i; } break;

+case 8:

+#line	33	"/usr/qwx/p/misc/calc.y"

+{ yyval.i = yypt[-2].yyv.i / yypt[-0].yyv.i; } break;

+case 9:

+#line	34	"/usr/qwx/p/misc/calc.y"

+{ yyval.i = yypt[-2].yyv.i % yypt[-0].yyv.i; } break;

+	}

+	goto yystack;  /* stack new state and value */

+}

--- /dev/null

+++ b/calc.tab.h

@@ -1,0 +1,6 @@

+

+typedef union {

+	int i;

+}	YYSTYPE;

+extern	YYSTYPE	yylval;

+#define	NUM	57346

--- /dev/null

+++ b/calc.y

@@ -1,0 +1,84 @@

+%{

+#include <u.h>

+#include <libc.h>

+#include <bio.h>

+#include <ctype.h>

+

+int yylex(void);

+int yyparse(void);

+void yyerror(char*);

+

+Biobuf *bf;

+%}

+

+%union{

+	int i;

+}

+

+%token<i> NUM

+%type<i> expr

+

+%left '+' '-'

+%left '*' '/' '%'

+

+%%

+

+input:	| input expr '\n' { print("%d\n", $2); }

+

+expr:	NUM { $$ = $1; }

+	| '(' expr ')' { $$ = $2; }

+	| expr '+' expr { $$ = $1 + $3; }

+	| expr '-' expr { $$ = $1 - $3; }

+	| expr '*' expr { $$ = $1 * $3; }

+	| expr '/' expr { $$ = $1 / $3; }

+	| expr '%' expr { $$ = $1 % $3; }

+

+%%

+

+void

+yyerror(char *s)

+{

+	fprint(2, "%s\n", s);

+}

+

+int

+getnum(int c)

+{

+	char s[64], *p;

+

+	for(p=s, *p++=c; isdigit(c=Bgetc(bf));)

+		if(p < s+sizeof(s)-1)

+			*p++ = c;

+	*p = 0;

+	Bungetc(bf);

+	return strtol(s, nil, 10);

+}

+

+int

+yylex(void)

+{

+	int n, c;

+

+	do

+		c = Bgetc(bf);

+	while(c != '\n' && isspace(c));

+	if(isdigit(c)){

+		yylval.i = getnum(c);

+		return NUM;

+	}else if(c == 'd'){

+		n = getnum(Bgetc(bf));

+		yylval.i = nrand(n != 0 ? n : 1);

+		return NUM;

+	}else

+		return c;

+}

+

+void

+main(int argc, char **argv)

+{

+	ARGBEGIN{

+	}ARGEND

+	if((bf = Bfdopen(0, OREAD)) == nil)

+		sysfatal("Bfdopen: %r");

+	yyparse();

+}

--- /dev/null

+++ b/cpick.c

@@ -1,0 +1,109 @@

+#include <u.h>

+#include <libc.h>

+#include <thread.h>

+#include <draw.h>

+#include <keyboard.h>

+#include <mouse.h>

+

+/* there should really be a color picker in paint(1) instead */

+

+Keyboardctl *kc;

+Mousectl *mc;

+Image *pic, *boxc;

+Point pan;

+Rectangle box;

+

+void

+putcol(Point m)

+{

+	char s[32];

+	uchar buf[4];

+	u32int v;

+	Point p;

+

+	p = addpt(screen->r.min, pan);

+	unloadimage(pic, rectsubpt(Rpt(m, Pt(m.x+1, m.y+1)), p), buf, sizeof buf);

+	loadimage(boxc, boxc->r, buf, sizeof buf);

+	draw(screen, rectaddpt(box, p), boxc, nil, ZP);

+	v = buf[0] << 16 | buf[1] << 8 | buf[2];

+	snprint(s, sizeof s, "%#08ux", v);

+	string(screen, addpt(box.min, p), display->black, ZP, font, s);

+	flushimage(display, 1);

+}

+

+void

+redraw(void)

+{

+	draw(screen, rectaddpt(pic->r, addpt(screen->r.min, pan)), pic, nil, ZP);

+	flushimage(display, 1);

+}

+

+Image *

+iconv(Image *i)

+{

+	Image *ni;

+

+	if(i->chan == XBGR32)

+		return i;

+	if((ni = allocimage(display, i->r, XBGR32, 0, DNofill)) == nil)

+		sysfatal("allocimage: %r");

+	draw(ni, ni->r, i, nil, ZP);

+	freeimage(i);

+	return ni;

+}

+

+void

+threadmain(int, char **)

+{

+	int fd;

+	Mouse m, om;

+	Rune r;

+

+	if(initdraw(nil, nil, "cpick") < 0)

+		sysfatal("initdraw: %r");

+	if((fd = open("/dev/screen", OREAD)) < 0)

+		sysfatal("open: %r");

+	if((pic = readimage(display, fd, 0)) == nil)

+		sysfatal("readimage: %r");

+	close(fd);

+	pic = iconv(pic);

+	box = screen->r;

+	if((boxc = allocimage(display, Rect(0,0,1,1), pic->chan, 1, DNofill)) == nil)

+		sysfatal("allocimage: %r");

+	redraw();

+	if((kc = initkeyboard(nil)) == nil)

+		sysfatal("initkeyboard: %r");

+	if((mc = initmouse(nil, _screen->display->image)) == nil)

+		sysfatal("initmouse: %r");

+	Alt a[] = {

+		{mc->resizec, nil, CHANRCV},

+		{mc->c, &m, CHANRCV},

+		{kc->c, &r, CHANRCV},

+		{nil, nil, CHANEND}

+	};

+	for(;;){

+		switch(alt(a)){

+		case 0:

+			if(getwindow(display, Refnone) < 0)

+				sysfatal("getwindow: %r");

+			redraw();

+			break;

+		case 1:

+			if((m.buttons & 4) == 4){

+				pan.x += m.xy.x - om.xy.x;

+				pan.y += m.xy.y - om.xy.y;

+				redraw();

+			}else

+				putcol(m.xy);

+			om = m;

+			break;

+		case 2:

+			switch(r){

+			case Kdel: case 'q': threadexitsall(nil);

+			}

+			break;

+		default:

+			threadexitsall("alt: %r");

+		}

+	}

+}

--- /dev/null

+++ b/hcol.c

@@ -1,0 +1,94 @@

+#include <u.h>

+#include <libc.h>

+#include <draw.h>

+#include <thread.h>

+#include <keyboard.h>

+#include <mouse.h>

+

+char id[16];

+Point ps;

+Image *col;

+Keyboardctl *kc;

+Mousectl *mc;

+

+void

+plaster(void)

+{

+	draw(screen, screen->r, col, nil, ZP);

+	string(screen, ps, display->black, ZP, font, id);

+	flushimage(display, 1);

+}

+

+Image *

+eallocim(ulong col)

+{

+	Image *i;

+

+	i = allocimage(display, Rect(0,0,1,1), RGB24, 1, col);

+	if(i == nil)

+		sysfatal("allocimage: %r");

+	return i;

+}

+

+void

+setid(u32int n)

+{

+	sprint(id, "%#ux", n);

+}

+

+void

+reset(void)

+{

+	ps = addpt(screen->r.min, stringsize(font, "A"));

+	plaster();

+}

+

+void

+threadmain(int, char **)

+{

+	u32int n;

+	char line[16];

+	Rune r;

+

+	if(initdraw(nil, nil, "hcol") < 0)

+		sysfatal("initdraw: %r");

+	kc = initkeyboard(nil);

+	if(kc == nil)

+		sysfatal("initkeyboard: %r");

+	mc = initmouse(nil, screen);

+	if(mc == nil)

+		sysfatal("initmouse: %r");

+	col = eallocim(DBlack);

+	setid(0);

+	reset();

+

+	Alt a[] = {

+		{mc->c, nil, CHANRCV},

+		{mc->resizec, nil, CHANRCV},

+		{kc->c, &r, CHANRCV},

+		{nil, nil, CHANEND}

+	};

+	for(;;)

+		switch(alt(a)){

+		case 1:

+			if(getwindow(display, Refnone) < 0)

+				sysfatal("getwindow: %r");

+			reset();

+			break;

+		case 2:

+			if(r == Kdel)

+				threadexitsall(nil);

+			memset(line, 0, sizeof line);

+			runetochar(line, &r);

+			if(enter(nil, line, 12, mc, kc, nil) < 0)

+				break;

+			n = strtoul(line, nil, 0);

+			setid(n);

+			freeimage(col);

+			col = eallocim(n<<8);

+			if(col == nil)

+				sysfatal("allocimage: %r");

+			plaster();

+			break;

+		}

+}

--- /dev/null

+++ b/lr.c

@@ -1,0 +1,159 @@

+/* lr - retarded recursive file list */

+#include <u.h>

+#include <libc.h>

+#include <String.h>

+

+extern	void	du(char*, Dir*);

+extern	void	err(char*);

+extern	int	seen(Dir*);

+extern	int	warn(char*);

+

+char	*fmt = "%s\n";

+char	*readbuf;

+int	dflag;

+int	nflag;

+

+void

+usage(void)

+{

+	fprint(2, "usage: %s [-dnQ] [file ...]\n", argv0);

+	exits("usage");

+}

+

+void

+main(int argc, char *argv[])

+{

+	int doqt;

+	char *s;

+

+	doqt = 1;

+	ARGBEGIN{

+	case 'd': dflag++; break;

+	case 'n': nflag++; dflag++; break;

+	case 'Q': doqt = 0; break;

+	default: usage();

+	}ARGEND

+	if(doqt){

+		doquote = needsrcquote;

+		quotefmtinstall();

+		fmt = "%q\n";

+	}

+	if(argc == 0)

+		du(".", dirstat("."));

+	else

+		while(*argv != nil){

+			s = *argv++;

+			du(s, dirstat(s));

+		}

+	exits(nil);

+}

+

+void

+dufile(char *name, Dir *d)

+{

+	String *s;

+

+	s = s_copy(name);

+	s_append(s, "/");

+	s_append(s, d->name);

+	print(fmt, s_to_c(s));

+	s_free(s);

+}

+

+void

+du(char *name, Dir *dir)

+{

+	int fd, i, n;

+	Dir *buf, *d;

+	String *s;

+

+	if(dir == nil){

+		warn(name);

+		return;

+	}

+	if((dir->qid.type & QTDIR) == 0){

+		if(!nflag)

+			print(fmt, name);

+		return;

+	}

+

+	fd = open(name, OREAD);

+	if(fd < 0){

+		warn(name);

+		return;

+	}

+	n = dirreadall(fd, &buf);

+	if(n < 0)

+		warn(name);

+	close(fd);

+	for(i=n, d=buf; i>0; i--, d++){

+		if((d->qid.type & QTDIR) == 0){

+			if(!nflag)

+				dufile(name, d);

+			continue;

+		}

+		if(strcmp(d->name, ".") == 0 || strcmp(d->name, "..") == 0

+		|| seen(d))

+			continue;	/* don't get stuck */

+

+		s = s_copy(name);

+		s_append(s, "/");

+		s_append(s, d->name);

+		du(s_to_c(s), d);

+		s_free(s);

+	}

+	free(buf);

+	if(dflag)

+		print(fmt, name);

+}

+

+#define	NCACHE	256	/* must be power of two */

+

+typedef struct

+{

+	Dir*	cache;

+	int	n;

+	int	max;

+} Cache;

+Cache cache[NCACHE];

+

+int

+seen(Dir *dir)

+{

+	Dir *dp;

+	int i;

+	Cache *c;

+

+	c = &cache[dir->qid.path&(NCACHE-1)];

+	dp = c->cache;

+	for(i=0; i<c->n; i++, dp++)

+		if(dir->qid.path == dp->qid.path &&

+		   dir->type == dp->type &&

+		   dir->dev == dp->dev)

+			return 1;

+	if(c->n == c->max){

+		if (c->max == 0)

+			c->max = 8;

+		else

+			c->max += c->max/2;

+		c->cache = realloc(c->cache, c->max*sizeof(Dir));

+		if(c->cache == nil)

+			err("malloc failure");

+	}

+	c->cache[c->n++] = *dir;

+	return 0;

+}

+

+void

+err(char *s)

+{

+	fprint(2, "du: %s: %r\n", s);

+	exits(s);

+}

+

+int

+warn(char *s)

+{

+	fprint(2, "du: %s: %r\n", s);

+	return 0;

+}

--- /dev/null

+++ b/mev.c

@@ -1,0 +1,167 @@

+#include <u.h>

+#include <libc.h>

+#include <draw.h>

+#include <keyboard.h>

+#include <mouse.h>

+

+int grx = 200 / 4, gry = 200 / 4;

+Image *gc, *uc, *nc;

+int mson, fix;

+Point p0, mp;

+Rectangle grabr, rt;

+

+void

+reset(void)

+{

+	Point p;

+

+	p0 = divpt(addpt(screen->r.min, screen->r.max), 2);

+	p = Pt(grx, gry);

+	grabr = Rpt(subpt(p0, p), addpt(p0, p));

+	rt = Rpt(screen->r.min, addpt(screen->r.min, Pt(8*12, font->height)));

+	draw(screen, screen->r, display->black, nil, ZP);

+	flushimage(display, 1);

+}

+

+void

+mproc(void)

+{

+	int fd, n, nerr;

+	char buf[1+5*12], s[16];

+	Mouse m;

+	Point p;

+	Rectangle r;

+

+	fd = open("/dev/mouse", ORDWR);

+	if(fd < 0)

+		sysfatal("open /dev/mouse: %r");

+	memset(&m, 0, sizeof m);

+	nerr = 0;

+	r = Rect(0,0,1,1);

+	mp = p0;

+	for(;;){

+		n = read(fd, buf, sizeof buf);

+		if(n != 1+4*12){

+			if(n < 0 || ++nerr > 10)

+				break;

+			continue;

+		}

+		nerr = 0;

+		switch(*buf){

+		case 'r':

+			if(getwindow(display, Refnone) < 0)

+				sysfatal("resize failed: %r");

+			reset();

+		case 'm':

+			p.x = strtol(buf+1+0*12, nil, 10);

+			p.y = strtol(buf+1+1*12, nil, 10);

+			if(!mson){

+				draw(screen, rectaddpt(r, p), nc, nil, ZP);

+				flushimage(display, 1);

+				break;

+			}

+			if(fix){

+				fix = 0;

+				goto res;

+			}

+			draw(screen, rt, display->black, nil, ZP);

+			sprint(s, "%d,%d", p.x - mp.x, p.y - mp.y);

+			string(screen, screen->r.min, uc, ZP, font, s);

+			draw(screen, rectaddpt(r, mp), uc, nil, ZP);

+			draw(screen, rectaddpt(r, p), gc, nil, ZP);

+			flushimage(display, 1);

+			if(!ptinrect(p, grabr)){

+		res:

+				fprint(fd, "m%d %d", p0.x, p0.y);

+				p = p0;

+			}

+			mp = p;

+			break;

+		}

+	}

+}

+

+void

+grab(void)

+{

+	static char nocurs[2*4+2*2*16];

+	static int fd = -1;

+

+	mson ^= 1;

+	if(mson){

+		fd = open("/dev/cursor", ORDWR|OCEXEC);

+		if(fd < 0){

+			fprint(2, "grab: %r\n");

+			return;

+		}

+		write(fd, nocurs, sizeof nocurs);

+		fix++;

+	}else if(fd >= 0){

+		close(fd);

+		fd = -1;

+	}

+}

+

+void

+usage(void)

+{

+	fprint(2, "usage: %s [-x dx] [-y dy]\n", argv0);

+	sysfatal("usage");

+}

+

+void

+main(int argc, char **argv)

+{

+	int n, fd, mpid;

+	char buf[256];

+	Rune r;

+

+	ARGBEGIN{

+	case 'x': grx = strtol(EARGF(usage()), nil, 0); break;

+	case 'y': gry = strtol(EARGF(usage()), nil, 0); break;

+	default: usage();

+	}ARGEND

+	if(initdraw(nil, nil, "mev") < 0)

+		sysfatal("initdraw: %r");

+	gc = allocimage(display, Rect(0,0,1,1), RGB24, 1, DGreen);

+	uc = allocimage(display, Rect(0,0,1,1), RGB24, 1, DRed);

+	nc = allocimage(display, Rect(0,0,1,1), RGB24, 1, DBlue);

+	reset();

+	mpid = rfork(RFPROC|RFMEM);

+	switch(mpid){

+	case -1:

+		sysfatal("fork: %r");

+	case 0:

+		mproc();

+		exits(nil);

+	}

+	fd = open("/dev/kbd", OREAD);

+	if(fd < 0)

+		sysfatal("open: %r");

+	for(;;){

+		if(buf[0] != 0){

+			n = strlen(buf)+1;

+			memmove(buf, buf+n, sizeof(buf)-n);

+		}

+		if(buf[0] == 0){

+			n = read(fd, buf, sizeof(buf)-1);

+			if(n <= 0)

+				break;

+			buf[n-1] = 0;

+			buf[n] = 0;

+		}

+		if(buf[0] == 'c'){

+			chartorune(&r, buf+1);

+			if(utfrune(buf, Kdel))

+				break;

+			else if(utfrune(buf, ' '))

+				grab();

+			else if(utfrune(buf, 'b')){

+				draw(screen, screen->r, display->black, nil, ZP);

+				flushimage(display, 1);

+			}

+		}

+	}

+	postnote(PNPROC, mpid, "shutdown");

+	exits(nil);

+}

--- /dev/null

+++ b/mkfile

@@ -1,0 +1,22 @@

+</$objtype/mkfile

+TARG=\

+	calc\

+	cpick\

+	hcol\

+	lr\

+	mev\

+	rfx\

+	spd\

+	tev\

+	wstat\

+

+HFILES=

+YFLAGS=-D

+</sys/src/cmd/mkmany

+BIN=$home/bin/$objtype

+

+%.tab.h %.tab.c:D:	%.y

+	$YACC $YFLAGS -s $stem $prereq

+

+(calc).c:R:	\1.tab.c

+	mv $stem1.tab.c $stem1.c

--- /dev/null

+++ b/rfx.c

@@ -1,0 +1,444 @@

+#include <u.h>

+#include <libc.h>

+#include <draw.h>

+#include <thread.h>

+#include <keyboard.h>

+#include <mouse.h>

+#include <cursor.h>

+

+typedef struct Tg Tg;

+struct Tg{

+	Point;

+	Point v;

+	int r;

+	Tg *p;

+	Tg *n;

+};

+Tg troot;

+Tg *tg;

+

+vlong tics;

+int ntg;

+int hits, misses, misclicks;

+uint bmask = 1;

+int oldb;

+enum{

+	NSEC = 1000000000

+};

+/* recommend these are set well outside the confort range, but not so much so

+ * that every game lasts less than a minute */

+vlong div, div0 = NSEC/20;	/* tic duration (ns) */

+int tddd = 220;	/* tic duration decrease delay (tics) */

+int Δ0 = 100;	/* tic duration delta factor */

+int mtdt = 5;	/* tics/tddd % mtdt: delay to tgmax++ */

+int floatdt = 25;	/* floating text delay (tics) */

+int newdt = 8;		/* target spawn delay (tics) */

+int dmax, rmax = 24;	/* max target radius (px) */

+int tgmax = 3;	/* initial max number of targets onscreen */

+int missmax = 10;	/* max targets let go */

+int nogrow;	/* don't grow and shrink targets */

+int done;

+

+enum{

+	CBACK,

+	CTARG,

+	CMISS,

+	CTXT,

+	CEND

+};

+Image *col[CEND];

+Image *fb;

+Rectangle winxy;	/* spawning area */

+Mousectl *mctl;

+Keyboardctl *kctl;

+Channel *ticc;

+

+#define trr()	(rmax+1 - t->r % (rmax+1))

+#define tr()	(nogrow ? rmax : t->r <= rmax ? t->r : trr())

+

+Image *

+eallocim(Rectangle r, int repl, ulong col)

+{

+	Image *i;

+

+	i = allocimage(display, r, screen->chan, repl, col);

+	if(i == nil)

+		sysfatal("allocimage: %r");

+	return i;

+}

+

+void

+tic(void *)

+{

+	vlong t, dt, δ;

+

+	t = nsec();

+	dt = div/1000000;

+	for(;;){

+		if(dt >= 0){

+			sleep(dt);

+			if(nbsend(ticc, nil) < 0)

+				break;

+		}

+		δ = div;

+		dt = (t + 2*δ - nsec()) / 1000000;

+		t += δ;

+	}

+}

+

+Tg *

+push(void)

+{

+	Tg *t;

+

+	t = mallocz(sizeof *t, 1);

+	if(t == nil)

+		sysfatal("talloc: %r");

+	t->p = tg->p;

+	t->n = tg;

+	tg->p->n = t;

+	tg->p = t;

+	return t;

+}

+

+void

+pop(Tg *t)

+{

+	t->p->n = t->n;

+	t->n->p = t->p;

+	free(t);

+}

+

+void

+nuke(void)

+{

+	while(tg->n != tg)

+		pop(tg->n);

+	ntg = 0;

+}

+

+void

+drw(Tg *t)

+{

+	int r;

+

+	r = tr();

+	fillellipse(fb, *t, r, r, col[CTARG], ZP);

+}

+

+void

+clr(Tg *t)

+{

+	draw(fb, Rpt(*t, t->v), col[CBACK], nil, ZP);

+}

+

+void

+txt(char *s, Tg *t, Image *i)

+{

+	Point o;

+

+	if(t == nil)

+		o = subpt(divpt(winxy.max, 2), divpt(stringsize(font, s), 2));

+	else{

+		o = divpt(stringsize(font, s), 2);

+		t->v = addpt(*t, o);

+		t->x -= o.x;

+		t->y -= o.y;

+		o = *t;

+	}

+	string(fb, o, i, ZP, font, s);

+}

+

+void

+misclk(Point o)

+{

+	Tg *t;

+

+	/* FIXME: often doesn't do anything */

+	fillellipse(fb, o, 1, 1, col[CTARG], ZP);

+	t = push();

+	t->v = addpt(o, Pt(2,2));

+	t->x = o.x - 1;

+	t->y = o.y - 1;

+	t->r = dmax+1;

+	misclicks++;

+}

+

+void

+hit(Tg *t)

+{

+	int r;

+

+	r = tr();

+	fillellipse(fb, *t, r, r, col[CBACK], ZP);

+	pop(t);

+	ntg--;

+	hits++;

+}

+

+void

+miss(Tg *t)

+{

+	int r;

+

+	r = nogrow ? rmax : 1;

+	fillellipse(fb, *t, r, r, col[CBACK], ZP);

+	txt("miss", t, col[CMISS]);

+	misses++;

+	ntg--;

+}

+

+void

+grow(Tg *t)

+{

+	if(nogrow)

+		return;

+	drw(t);

+}

+

+void

+shrink(Tg *t)

+{

+	int r;

+

+	if(nogrow)

+		return;

+	r = trr();

+	fillellipse(fb, *t, r, r, col[CBACK], ZP);

+	r--;

+	fillellipse(fb, *t, r, r, col[CTARG], ZP);

+}

+

+void

+spawn(void)

+{

+	Tg *t;

+

+	t = push();

+	ntg++;

+	t->x = winxy.min.x + nrand(winxy.max.x - winxy.min.x);

+	t->y = winxy.min.y + nrand(winxy.max.y - winxy.min.y);

+	if(nogrow){

+		t->r = rmax;

+		drw(t);

+	}

+}

+

+void

+check(int b, Point m)

+{

+	Point o;

+	Tg *t;

+

+	/* FIXME: implement counters for each button */

+	USED(b);

+	m = subpt(m, screen->r.min);

+	for(t=tg->n; t != tg; t=t->n){

+		if(t->r > dmax)

+			continue;

+		o = subpt(*t, m);

+		if(hypot(o.x, o.y) < tr()){

+			hit(t);

+			return;

+		}

+	}

+	misclk(m);

+}

+

+void

+plaster(void)

+{

+	draw(screen, screen->r, fb, nil, ZP);

+	flushimage(display, 1);

+}

+

+void

+score(void)

+{

+	char s[64];

+

+	sprint(s, "hit %d misses %d misclicks %d", hits, misses, misclicks);

+	txt(s, nil, col[CTXT]);

+	plaster();

+}

+

+void

+adv(void)

+{

+	Tg *t;

+

+	tics++;

+	if(tics % tddd == 0){

+		div -= div0 / Δ0;

+		if(tics / tddd % mtdt == 0)

+			tgmax++;

+	}

+

+	for(t=tg->n; t != tg; t=t->n){

+		t->r++;

+		if(t->r <= rmax)

+			grow(t);

+		else if(t->r > rmax && t->r <= dmax)

+			shrink(t);

+		else if(t->r == dmax+1){

+			miss(t);

+			if(misses >= missmax){

+				done++;

+				score();

+			}

+		}else if(t->r > dmax+floatdt){

+			clr(t);

+			pop(t);

+		}

+	}

+	if(tics % newdt == 0 && ntg < tgmax)

+		spawn();

+}

+

+void

+dreset(void)

+{

+	Tg *t;

+

+	winxy = rectsubpt(insetrect(screen->r, rmax), screen->r.min);

+	if(Dx(winxy) < 3*dmax || Dy(winxy) < 3*dmax)

+		sysfatal("window too small");

+	freeimage(fb);

+	fb = eallocim(Rect(0,0,Dx(screen->r),Dy(screen->r)), 0, DNofill);

+	draw(fb, fb->r, col[CBACK], nil, ZP);

+	for(t=tg->n; t != tg; t=t->n){

+		if(t->r > dmax)

+			continue;

+		drw(t);

+	}

+	if(done)

+		score();

+	plaster();

+}

+

+void

+init(void)

+{

+	div = div0;

+	tics = 0;

+	hits = misses = misclicks = 0;

+	done = 0;

+}

+

+void

+usage(void)

+{

+	print("%s [-g] [-d newdt] [-h div0] [-i Δ0] [-m nmiss] [-o rmax] [-r tddd] [-t 1-5]\n", argv0);

+	threadexitsall("usage");

+}

+

+void

+threadmain(int argc, char *argv[])

+{

+	Rectangle d;

+	Rune r;

+	Mouse m;

+

+	ARGBEGIN{

+	case 'd':

+		newdt = strtol(EARGF(usage()), nil, 0);

+		break;

+	case 'g':

+		nogrow++;

+		break;

+	case 'h':

+		div0 = strtoll(EARGF(usage()), nil, 0);

+		if(div0 <= 0)

+			sysfatal("invalid divisor %lld", div0);

+		div0 = NSEC / div0;

+		break;

+	case 'i':

+		Δ0 = strtol(EARGF(usage()), nil, 0);

+		if(Δ0 <= 0)

+			sysfatal("invalid divisor divisor %d", Δ0);

+		break;

+	case 'm':

+		missmax = strtol(EARGF(usage()), nil, 0);

+		break;

+	case 'o':

+		rmax = strtol(EARGF(usage()), nil, 0);

+		break;

+	case 'r':

+		tddd = strtol(EARGF(usage()), nil, 0);

+		break;

+	case 't':

+		bmask = 31 >> 5 - strtol(EARGF(usage()), nil, 0);

+		break;

+	default:

+		usage();

+	}ARGEND

+	dmax = rmax*2;

+

+	tg = &troot;

+	tg->n = tg->p = tg;

+	if(initdraw(nil, nil, "rfx") < 0)

+		sysfatal("initdraw: %r");

+	d = Rect(0,0,1,1);

+	col[CBACK] = display->black;

+	col[CTARG] = eallocim(d, 1, 0x990000ff);

+	col[CMISS] = eallocim(d, 1, 0x440000ff);

+	col[CTXT] = eallocim(d, 1, 0xbb4400ff);

+	dreset();

+

+	mctl = initmouse(nil, screen);

+	if(mctl == nil)

+		sysfatal("initmouse: %r");

+	kctl = initkeyboard(nil);

+	if(kctl == nil)

+		sysfatal("initkeyboard: %r");

+	ticc = chancreate(sizeof(int), 0);

+	if(ticc == nil)

+		sysfatal("chancreate: %r");

+	srand(time(nil));

+	init();

+	if(proccreate(tic, nil, 8192) < 0)

+		sysfatal("proccreate tproc: %r");

+

+	enum{ATIC, AMOUSE, ARESIZE, AKEY, AEND};

+	Alt a[AEND+1] = {

+		[ATIC] {ticc, nil, CHANRCV},

+		[AMOUSE] {mctl->c, &m, CHANRCV},

+		[ARESIZE] {mctl->resizec, nil, CHANRCV},

+		[AKEY] {kctl->c, &r, CHANRCV},

+		[AEND] {nil, nil, CHANEND}

+	};

+	for(;;){

+		switch(alt(a)){

+		case ATIC:

+			if(done)

+				break;

+			adv();

+			plaster();

+			break;

+		case AMOUSE:

+			if(!done && m.buttons & bmask && m.buttons & ~oldb)

+				check(m.buttons, m.xy);

+			oldb = m.buttons;

+			break;

+		case ARESIZE:

+			if(getwindow(display, Refnone) < 0)

+				sysfatal("getwindow: %r");

+			dreset();

+			break;

+		case AKEY:

+			switch(r){

+			case 'n':

+				nuke();

+				init();

+				draw(fb, fb->r, col[CBACK], nil, ZP);

+				plaster();

+				break;

+			case 'q':

+			case Kdel:

+				nuke();

+				threadexitsall(nil);

+			}

+			break;

+		}

+	}

+}

--- /dev/null

+++ b/solt.c

@@ -1,0 +1,294 @@

+#include <u.h>

+#include <libc.h>

+#include <draw.h>

+#include <thread.h>

+#include <keyboard.h>

+#include <mouse.h>

+#include <cursor.h>

+

+/* FIXME: shitty model, shitty implementation */

+

+enum{

+	NCARDS	= 52,

+	NFLAVOR	= 4,

+	NSTACKS	= 8,

+	NHAND	= NCARDS - ((NSTACKS+1)*(NSTACKS+2))/2 + 1

+};

+

+int c[NCARDS];

+

+typedef struct Card Card;

+struct Card{

+	int	v;

+	char	l[5];

+	Card*	n;

+};

+Card *d[NCARDS];

+Card *s[NSTACKS];

+Card *h[NHAND];

+

+Image *ncol;	/* string color */

+Image *selcol;	/* selection color */

+Point spt;	/* string pos */

+

+Mouse m;

+int resize;

+int kfd, mfd;

+

+

+void *

+emalloc(ulong n)

+{

+	void *b;

+

+	if((b = malloc(n)) == nil)

+		sysfatal("%s: %r", argv0);

+	return b;

+}

+

+void

+shuffle(void)

+{

+	int i, j, n;

+	int t[NCARDS];

+

+	srand(time(nil));

+	for(i = 0; i < NCARDS; i++)

+		t[i] = rand();

+	for(i = 0; i < NCARDS; i++){

+		n = 0;

+		for(j = 0; j < NCARDS; j++)

+			if(t[n] > t[j])

+				n = j;

+		c[i] = n;

+		t[n] = 0x10000;

+	}

+}

+

+char

+mkflavor(int n)

+{

+	switch(n % NFLAVOR){

+	case 0: return 'd';

+	case 1: return 'p';

+	case 2: return 'u';

+	case 3: return 'n';

+	}

+	return ' ';

+}

+

+void

+mkdeck(void)

+{

+	int i, v;

+

+	for(i = 0; i < NCARDS; i++){

+		d[i] = emalloc(sizeof **d);

+		v = c[i];

+		d[i]->v = v;

+		sprint(d[i]->l, "%d%c", 1 + v/NFLAVOR, mkflavor(v));

+		d[i]->n = nil;

+	}

+}

+

+void

+arrange(void)

+{

+	int i, j, n = 0;

+	Card *p;

+

+	for(i = 0; i < NSTACKS; i++)

+		s[i] = d[n++];

+	for(i = 0; i < NSTACKS; i++){

+		p = s[i];

+		for(j = NSTACKS-i-1; j < NSTACKS; j++)

+			p = p->n = d[n++];

+	}

+	for(i = 0; i < NHAND; i++)

+		h[i] = d[n++];

+}

+

+void

+drw(void)

+{

+	int i, n;

+	Card *p;

+	char b[10];

+	Point sxy = spt;

+

+	/* TODO: clear line */

+

+	for(i = 0; i < NSTACKS; i++){

+		p = s[i];

+		n = 0;

+		if(p == nil)

+			sprint(b, "  ()    ");

+		else{

+			while(p->n != nil){

+				n++;

+				p = p->n;

+			}

+			snprint(b, 10, "(%d)%s ", n, p->l);

+		}

+		string(screen, sxy, ncol, ZP, font, b);

+		sxy.x += 8 * font->width;

+	}

+	flushimage(display, 1);

+}

+

+void

+select(Point *p)

+{

+	/* TODO: selecting a card */

+	USED(p);

+}

+

+void

+kth(void *)

+{

+	int k;

+	char buf[256];

+	char *s;

+	Rune r;

+

+	if((kfd = open("/dev/kbd", OREAD)) < 0)

+		sysfatal("%s: open /dev/kbd: %r", argv0);

+	for(;;){

+		if(read(kfd, buf, sizeof(buf)-1) <= 0)

+			sysfatal("%s: read /dev/kbd: %r", argv0);

+		if(buf[0] == 'c' && utfrune(buf, Kdel))

+			threadexitsall(nil);

+		if(buf[0] != 'k' && buf[0] != 'K')

+			continue;

+

+		s = buf + 1;

+		k = 0;

+		while(*s != 0){

+			s += chartorune(&r, s);

+			switch(r){

+			case Kdel:

+				threadexitsall(nil);

+			}

+		}

+	}

+	/* TODO: make other threads exit cleanly? send to threadmain? */

+}

+

+void

+mth(void *)

+{

+	int n, nerr;

+	Mouse m;

+	char buf[1+5*12];

+

+	if((mfd = open("/dev/mouse", OREAD)) < 0)

+		sysfatal("open: %r");

+	memset(&m, 0, sizeof m);

+	nerr = 0;

+

+	for(;;){

+		n = read(mfd, buf, sizeof buf);

+		if(n != 1+4*12){

+			fprint(2, "mproc: bad count %d not 49: %r\n", n);

+			if(n < 0 || ++nerr > 10)

+				break;

+			continue;

+		}

+		nerr = 0;

+

+		switch(buf[0]){

+		case 'r':

+			resize = 1;

+			/* TODO: something */

+			break;

+		case 'm':

+			m.xy.x = atoi(buf+1+0*12);

+			m.xy.y = atoi(buf+1+1*12);

+			m.buttons = atoi(buf+1+2*12);

+			//m.msec = atoi(buf+1+3*12);

+			break;

+		}

+	}

+}

+

+void

+croak(void)

+{

+	Card **p = d;

+

+	close(kfd);

+	close(mfd);

+	while(p != d + NCARDS)

+		free(*p++);

+	freeimage(ncol);

+	freeimage(selcol);

+}

+

+void

+reset(void)

+{

+	draw(screen, screen->r, display->black, nil, ZP);

+	shuffle();

+	mkdeck();

+	arrange();

+	drw();

+}

+

+void

+init(void)

+{

+	/* TODO: why the difference between proc and thread? */

+

+	if(proccreate(kth, nil, mainstacksize) < 0)

+		sysfatal("%s threadcreate kproc: %r", argv0);

+	if(proccreate(mth, nil, mainstacksize) < 0)

+		sysfatal("%s threadcreate mproc: %r", argv0);

+

+	if(initdraw(nil, nil, "solt") < 0)

+		sysfatal("%s initdraw: %r", argv0);

+	ncol = allocimage(display, Rect(0, 0, 1, 1), screen->chan, 1, 0x551100ff);

+	if(ncol == nil)

+		sysfatal("%s allocimage: %r", argv0);

+	selcol = allocimage(display, Rect(0, 0, 1, 1), screen->chan, 1, 0x882200ff);

+	if(selcol == nil)

+		sysfatal("%s allocimage: %r", argv0);

+	print("selcol %p %p %d\n", selcol->display->bufp, selcol->display->buf, selcol->display->bufsize);

+	/* problem: font->width == 0 at this point? */

+	spt = Pt(screen->r.min.x + Dx(screen->r)/2 - 8*NSTACKS*4,

+		screen->r.min.y + Dy(screen->r)/2);

+

+	reset();

+	atexit(croak);

+}

+

+void

+usage(void)

+{

+	print("usage: %s\n", argv0);

+	threadexitsall("usage");

+}

+

+void

+threadmain(int argc, char *argv[])

+{

+	ARGBEGIN{

+	default:

+		usage();

+	}ARGEND

+

+	/* TODO: playing the game */

+	/* TODO: hand, 4 finish spots, 4 off spots */

+	/* TODO: mouse menu (exit, save card, stack card, restart, new, ) */

+	/* TODO: moving shit around */

+	/* TODO: resize handling */

+	/* TODO: exit by communicating by channel */

+	/* TODO: calculate distance between card slots programatically */

+

+	init();

+	/* FIXME: do shit (setup channels) */

+	for(;;){

+		/*if(recv(kchan, nil) < 0)

+			threadexitsall("%s recv: %r");*/

+		sleep(100);

+	}

+}

--- /dev/null

+++ b/spd.c

@@ -1,0 +1,413 @@

+#include <u.h>

+#include <libc.h>

+#include <bio.h>

+#include <draw.h>

+#include <thread.h>

+#include <keyboard.h>

+#include <mouse.h>

+#include <cursor.h>

+

+enum{

+	KMAX = 24 * UTFmax,

+	DICTLEN = 32<<10,

+	TMAX = 32,

+};

+char dict[DICTLEN][KMAX];

+int ndic;

+char *df = "/lib/words";

+typedef struct Txt Txt;

+struct Txt{

+	Point;

+	char s[KMAX];

+	char *m;

+	int d;

+	Image *c;

+	Txt *p;

+	Txt *n;

+};

+Txt t0, *tl, *cur;

+

+vlong tics;

+int nt, words, miss, mistyp;

+enum{

+	NSEC = 1000000000

+};

+vlong div, div0 = NSEC/2;	/* tic duration (ns) */

+int dage = 16;

+int tddd = 64;	/* tic duration decrease delay (tics) */

+int newdt = 3;	/* target spawn delay (tics) */

+int missmax = 10;	/* max targets let go */

+long tm0;

+int done;

+

+enum{

+	CBACK,

+	CTXT,

+	CSTALE,

+	COLD,

+	CCUR,

+	CEND

+};

+Image *fb, *col[CEND];

+Point fs, wc;

+int dy;

+Mousectl *mc;

+Keyboardctl *kc;

+Channel *tc;

+

+Image *

+eallocim(Rectangle r, int repl, ulong col)

+{

+	Image *i;

+

+	i = allocimage(display, r, screen->chan, repl, col);

+	if(i == nil)

+		sysfatal("allocimage: %r");

+	return i;

+}

+

+void

+tic(void *)

+{

+	vlong t, dt, δ;

+

+	t = nsec();

+	dt = div/1000000;

+	for(;;){

+		if(dt >= 0){

+			sleep(dt);

+			if(nbsend(tc, nil) < 0)

+				break;

+		}

+		δ = div;

+		dt = (t + 2*δ - nsec()) / 1000000;

+		t += δ;

+	}

+}

+

+void

+pop(Txt *t)

+{

+	t->p->n = t->n;

+	t->n->p = t->p;

+	nt--;

+	free(t);

+	if(cur == t)

+		cur = nil;

+}

+

+void

+nuke(void)

+{

+	while(tl->n != tl)

+		pop(tl->n);

+}

+

+void

+drw(Txt *t, Image *c)

+{

+	if(c == nil)

+		c = t->c;

+	string(fb, *t, c, ZP, font, t->s);

+}

+

+void

+drwcur(void)

+{

+	char c;

+

+	c = *cur->m;

+	*cur->m = 0;

+	drw(cur, col[CCUR]);

+	*cur->m = c;

+}

+

+void

+spawn(void)

+{

+	Txt *t;

+

+	t = mallocz(sizeof *t, 1);

+	if(t == nil)

+		sysfatal("talloc: %r");

+	t->p = tl->p;

+	t->n = tl;

+	tl->p->n = t;

+	tl->p = t;

+	nt++;

+	sprint(t->s, dict[nrand(ndic)]);

+	t->c = col[CTXT];

+	t->y = nrand(dy);

+	drw(t, nil);

+}

+

+void

+plaster(void)

+{

+	draw(screen, screen->r, fb, nil, ZP);

+	flushimage(display, 1);

+}

+

+void

+score(void)

+{

+	Point o;

+	long t;

+	char s[72];

+

+	/* FIXME */

+	/* this wpm figure is bullshit */

+	t = (time(nil) - tm0) / 60;

+	sprint(s, "words %d misses %d mistypes %d in %lds",

+		words, miss, mistyp, t);

+	o = subpt(wc, divpt(stringsize(font, s), 2));

+	string(fb, o, col[CCUR], ZP, font, s);

+	plaster();

+}

+

+void

+adv(void)

+{

+	Txt *t;

+

+	tics++;

+	if(tics % tddd == 0)

+		div -= div0 / 16;

+

+	for(t=tl->n; t != tl; t=t->n){

+		t->d++;

+		drw(t, col[CBACK]);

+		t->x += fs.x;

+		if(t->d % dage == 0){

+			switch(t->d / dage){

+			case 1: t->c = col[CSTALE]; break;

+			case 2: t->c = col[COLD]; break;

+			case 3:

+				miss++;

+				if(miss >= missmax){

+					done++;

+					score();

+				}

+				pop(t);

+				continue;

+			}

+		}

+		drw(t, nil);

+	}

+	if(cur != nil)

+		drwcur();

+	if(tics % newdt == 0 && nt < TMAX)

+		spawn();

+	if(tl->n == tl){

+		spawn();

+		tics += newdt - tics % newdt;

+	}

+}

+

+int

+check(Rune k)

+{

+	Txt *t;

+

+	if(cur == nil){

+		for(t=tl->n; t != tl; t=t->n)

+			if(utfrune(t->s, k) == t->s){

+				t->m = t->s + runelen(k);

+				cur = t;

+				drwcur();

+				return 1;

+			}

+	}else if(utfrune(cur->m, k) == cur->m){

+		cur->m += runelen(k);

+		if(cur->m >= cur->s + strlen(cur->s)){

+			words++;

+			drw(cur, col[CBACK]);

+			pop(cur);

+			cur = nil;

+		}else

+			drwcur();

+		return 1;

+	}

+	mistyp++;

+	return 0;

+}

+

+void

+dreset(void)

+{

+	Txt *t;

+

+	dy = Dy(screen->r) - fs.y;

+	if(dy < 4 * fs.y || Dx(screen->r) < KMAX * fs.x / 8)

+		sysfatal("window too small");

+	wc = Pt(Dx(screen->r)/2, Dy(screen->r)/2);

+	freeimage(fb);

+	fb = eallocim(Rect(0,0,Dx(screen->r),Dy(screen->r)), 0, DNofill);

+	draw(fb, fb->r, col[CBACK], nil, ZP);

+	for(t=tl->n; t != tl; t=t->n)

+		drw(t, nil);

+	if(done)

+		score();

+	plaster();

+}

+

+void

+init(void)

+{

+	div = div0;

+	tics = 0;

+	words = miss = mistyp = 0;

+	tm0 = time(nil);

+	done = 0;

+	spawn();

+	plaster();

+}

+

+void

+menu(void)

+{

+	enum{NEW, QUIT};

+	static char *item[] = {

+		[NEW] "new",

+		[QUIT] "quit",

+		nil

+	};

+	static Menu m = {

+		item, nil, 0

+	};

+

+	switch(menuhit(3, mc, &m, nil)){

+	case NEW:

+		nuke();

+		init();

+		draw(fb, fb->r, col[CBACK], nil, ZP);

+		plaster();

+		break;

+	case QUIT:

+		nuke();

+		threadexitsall(nil);

+	}

+}

+

+void

+load(char *f)

+{

+	int n;

+	char *s, (*p)[KMAX];

+	Biobuf *bf;

+

+	bf = Bopen(f, OREAD);

+	if(bf == nil)

+		sysfatal("load: %r");

+	p = dict;

+	while(s = Brdline(bf, '\n'), s != nil && (char*)p < dict[nelem(dict)]){

+		n = Blinelen(bf);

+		if(n > sizeof *p)

+			n = sizeof *p;

+		memcpy(*p, s, n-1);

+		ndic++;

+		p++;

+	}

+	Bterm(bf);

+}

+

+void

+usage(void)

+{

+	print("%s [-d n] [-h hz] [-m n] [-o tics] [-r tics] [dict]\n", argv0);

+	threadexitsall("usage");

+}

+

+void

+threadmain(int argc, char *argv[])

+{

+	double d;

+	Rectangle r;

+	Rune k;

+	Mouse m;

+

+	ARGBEGIN{

+	case 'd':

+		newdt = strtol(EARGF(usage()), nil, 0);

+		break;

+	case 'h':

+		d = strtod(EARGF(usage()), nil);

+		if(d <= 0.0)

+			sysfatal("invalid divisor %f", d);

+		div0 = NSEC / d;

+		break;

+	case 'm':

+		missmax = strtol(EARGF(usage()), nil, 0);

+		break;

+	case 'o':

+		dage = strtol(EARGF(usage()), nil, 0);

+		break;

+	case 'r':

+		tddd = strtol(EARGF(usage()), nil, 0);

+		break;

+	default:

+		usage();

+	}ARGEND

+	if(argc > 0)

+		df = *argv;

+	load(df);

+

+	tl = &t0;

+	tl->n = tl->p = tl;

+

+	if(initdraw(nil, nil, "spd") < 0)

+		sysfatal("initdraw: %r");

+	fs = stringsize(font, "A");

+	r = Rect(0,0,1,1);

+	col[CBACK] = display->black;

+	col[CTXT] = eallocim(r, 1, 0xbb4400ff);

+	col[CSTALE] = eallocim(r, 1, 0x990000ff);

+	col[COLD] = eallocim(r, 1, 0x440000ff);

+	col[CCUR] = eallocim(r, 1, 0xdd9300ff);

+	dreset();

+

+	mc = initmouse(nil, screen);

+	if(mc == nil)

+		sysfatal("initmouse: %r");

+	kc = initkeyboard(nil);

+	if(kc == nil)

+		sysfatal("initkeyboard: %r");

+	tc = chancreate(sizeof(int), 0);

+	if(tc == nil)

+		sysfatal("chancreate: %r");

+	srand(time(nil));

+	init();

+	if(proccreate(tic, nil, 8192) < 0)

+		sysfatal("proccreate tproc: %r");

+

+	enum{ATIC, AMOUSE, ARESIZE, AKEY, AEND};

+	Alt a[AEND+1] = {

+		[ATIC] {tc, nil, CHANRCV},

+		[AMOUSE] {mc->c, &m, CHANRCV},

+		[ARESIZE] {mc->resizec, nil, CHANRCV},

+		[AKEY] {kc->c, &k, CHANRCV},

+		[AEND] {nil, nil, CHANEND}

+	};

+	for(;;)

+		switch(alt(a)){

+		case ATIC:

+			if(done)

+				break;

+			adv();

+			plaster();

+			break;

+		case AMOUSE:

+			if(m.buttons & 4)

+				menu();

+			break;

+		case ARESIZE:

+			if(getwindow(display, Refnone) < 0)

+				sysfatal("getwindow: %r");

+			dreset();

+			break;

+		case AKEY:

+			if(check(k))

+				plaster();

+			break;

+		}

+}

--- /dev/null

+++ b/tev.c

@@ -1,0 +1,98 @@

+#include <u.h>

+#include <libc.h>

+#include <draw.h>

+#include <keyboard.h>

+#include <mouse.h>

+

+void

+mproc(void)

+{

+	int fd, n, nerr;

+	char buf[1+5*12];

+	Mouse m;

+

+	fd = open("/dev/mouse", ORDWR);

+	if(fd < 0)

+		sysfatal("open /dev/mouse: %r");

+	memset(&m, 0, sizeof m);

+	nerr = 0;

+	for(;;){

+		n = read(fd, buf, sizeof buf);

+		if(n != 1+4*12){

+			if(n < 0 || ++nerr > 10)

+				break;

+			continue;

+		}

+		nerr = 0;

+		switch(*buf){

+		case 'r':

+			print("[r]\n");

+			/* wet floor */

+		case 'm':

+			m.xy.x = atoi(buf+1+0*12);

+			m.xy.y = atoi(buf+1+1*12);

+			m.buttons = atoi(buf+1+2*12);

+			m.msec = atoi(buf+1+3*12);

+			print("[m] %d,%d %d %lud\n", m.xy.x, m.xy.y, m.buttons, m.msec);

+			break;

+		}

+	}

+}

+

+void

+main(int, char **)

+{

+	int n, fd, mpid;

+	char buf[256], *s;

+	Rune r;

+

+	mpid = fork();

+	switch(mpid){

+	case -1:

+		sysfatal("fork: %r");

+	case 0:

+		mproc();

+		exits(nil);

+	}

+	fd = open("/dev/kbd", OREAD);

+	if(fd < 0)

+		sysfatal("open: %r");

+	for(;;){

+		if(buf[0] != 0){

+			n = strlen(buf)+1;

+			memmove(buf, buf+n, sizeof(buf)-n);

+		}

+		if(buf[0] == 0){

+			print("\n");

+			n = read(fd, buf, sizeof(buf)-1);

+			if(n <= 0)

+				break;

+			buf[n-1] = 0;

+			buf[n] = 0;

+		}

+		s = buf+1;

+		switch(buf[0]){

+		case 'c':

+			chartorune(&r, s);

+			print("[c] %C %#ux ", r, r);

+			if(utfrune(buf, Kdel))

+				goto done;

+			break;

+		case 'k':

+		case 'K':

+			print("[%c] ", buf[0]);

+			while(*s){

+				s += chartorune(&r, s);

+				print("%C %#ux ", r, r);

+				if(r == Kdel)

+					goto done;

+			}

+			break;

+		default:

+			print("unknown message %c\n", *buf);

+		}

+	}

+done:

+	postnote(PNPROC, mpid, "shutdown");

+	exits(nil);

+}

--- /dev/null

+++ b/wstat.c

@@ -1,0 +1,31 @@

+#include <u.h>

+#include <libc.h>

+

+#define usage() (sysfatal("usage: no."))

+

+void

+main(int argc, char **argv)

+{

+	int fd;

+	Dir d;

+

+	nulldir(&d);

+	ARGBEGIN{

+	case 'g': d.gid = EARGF(usage()); break;

+	case 'l': d.length = strtoll(EARGF(usage()), nil, 0); break;

+	case 'm': d.mtime = strtoll(EARGF(usage()), nil, 0); break;

+	case 'n': d.name = EARGF(usage()); break;

+	case 'p': d.mode = strtoll(EARGF(usage()), nil, 0); break;

+	case 'u': d.uid = EARGF(usage()); break;

+	default: usage();

+	}ARGEND

+	if(*argv == nil)

+		usage();

+	fd = open(*argv, OWRITE);

+	if(fd < 0)

+		sysfatal("open: %r");

+	if(dirfwstat(fd, &d) < 0)

+		sysfatal("dirfwstat: %r");

+	close(fd);

+	exits(nil);

+}