shithub: npe

Download patch

ref: fd731d3c833d9241fdff618b6c949453fb5c0f31
author: Sigrid Solveig Haflínudóttir <[email protected]>
date: Mon Mar 15 07:38:36 EDT 2021 

dump it to git so I do not lose anything


--- /dev/null
+++ b/README.md
@@ -1,0 +1,14 @@
+# npe
+
+"Native Porting Environment" for 9front, pronounced "nope".
+
+*WIP*
+
+The project tries to provide a minimalistic (and mostly
+non-conformant) POSIX environment with several additional libraries
+(cut-down version of SDL2 from scratch for now) to ease up porting of
+software to 9front.  The goal is to be able to build and run
+non-native GUI software with very minimal changes, if any.
+
+Unlike APE, NPE is fully native and is not trying to hide any of the
+native Plan 9 APIs.
--- /dev/null
+++ b/SDL2/SDL.h
@@ -1,0 +1,431 @@
+#ifndef _SDL_h_
+#define _SDL_h_
+
+#include "plan9.h"
+#include <keyboard.h>
+
+typedef int SDL_AudioDeviceID;
+typedef struct SDL_AudioSpec SDL_AudioSpec;
+typedef struct SDL_Window SDL_Window;
+typedef struct SDL_Renderer SDL_Renderer;
+typedef struct SDL_Texture SDL_Texture;
+typedef struct SDL_Surface SDL_Surface;
+typedef struct SDL_Rect SDL_Rect;
+typedef int SDL_Keycode;
+typedef int SDL_Scancode;
+typedef int SDL_Keymod;
+typedef struct SDL_Event SDL_Event;
+typedef u8int Uint8;
+typedef u16int Uint16;
+typedef u32int Uint32;
+typedef int SDL_BlendMode;
+typedef struct SDL_Thread SDL_Thread;
+typedef int (*SDL_ThreadFunction)(void *);
+typedef struct SDL_Cursor SDL_Cursor;
+typedef struct SDL_PixelFormat SDL_PixelFormat;
+typedef struct SDL_Point SDL_Point;
+typedef int SDL_RendererFlip;
+typedef struct SDL_DisplayMode SDL_DisplayMode;
+
+#pragma incomplete SDL_Cursor
+#pragma incomplete SDL_PixelFormat
+#pragma incomplete SDL_Renderer
+#pragma incomplete SDL_Texture
+#pragma incomplete SDL_Thread
+#pragma incomplete SDL_Window
+
+typedef enum {SDL_FALSE, SDL_TRUE} SDL_bool;
+#define SDLCALL
+
+void SDL_StopTextInput(void);
+SDL_bool SDL_HasSSE(void);
+SDL_bool SDL_HasSSE2(void);
+int SDL_Init(int);
+int SDL_EventState(Uint32, int);
+SDL_Keymod SDL_GetModState(void);
+char *SDL_GetAudioDeviceName(int, SDL_bool);
+int SDL_GetNumAudioDevices(int iscapture);
+int SDL_ShowCursor(int toggle);
+void SDL_LockAudioDevice(SDL_AudioDeviceID);
+void SDL_UnlockAudioDevice(SDL_AudioDeviceID);
+void SDL_PauseAudioDevice(SDL_AudioDeviceID, SDL_bool);
+void SDL_CloseAudioDevice(SDL_AudioDeviceID);
+SDL_AudioDeviceID SDL_OpenAudioDevice(char *, int, SDL_AudioSpec *, SDL_AudioSpec *, u32int);
+u64int SDL_GetPerformanceFrequency(void);
+u64int SDL_GetPerformanceCounter(void);
+char *SDL_GetError(void);
+SDL_Thread *SDL_CreateThread(SDL_ThreadFunction, char *, void *);
+void SDL_DetachThread(SDL_Thread *);
+char *SDL_GetClipboardText(void);
+int SDL_SetClipboardText(char *);
+void SDL_SetThreadPriority(int);
+SDL_bool SDL_HasClipboardText(void);
+int SDL_PollEvent(SDL_Event *event);
+void SDL_RestoreWindow(SDL_Window *window);
+void SDL_RaiseWindow(SDL_Window *window);
+int SDL_UpdateTexture(SDL_Texture *texture, SDL_Rect *rect, void *pixels, int pitch);
+int SDL_RenderClear(SDL_Renderer *renderer);
+int SDL_GetWindowDisplayIndex(SDL_Window *window);
+void SDL_FreeSurface(SDL_Surface *surface);
+Uint32 SDL_GetGlobalMouseState(int *x, int *y);
+void SDL_Quit(void);
+void SDL_free(void *);
+SDL_Cursor *SDL_GetDefaultCursor(void);
+void SDL_SetCursor(SDL_Cursor *cursor);
+void SDL_FreeCursor(SDL_Cursor *cursor);
+SDL_Surface *SDL_CreateRGBSurface(Uint32 flags, int width, int height, int depth, Uint32 rm, Uint32 gm, Uint32 bm, Uint32 am);
+SDL_Surface *SDL_CreateRGBSurfaceFrom(Uint32 *pixels, int w, int h, int bpp, int pitch, Uint32 rm, Uint32 gm, Uint32 bm, Uint32 am);
+Uint32 SDL_MapRGB(SDL_PixelFormat *format, Uint8 r, Uint8 g, Uint8 b);
+int SDL_SetColorKey(SDL_Surface *surface, int flag, Uint32 key);
+int SDL_SetSurfaceRLE(SDL_Surface *surface, int flag);
+int SDL_LockSurface(SDL_Surface *surface);
+int SDL_UnlockSurface(SDL_Surface *surface);
+int SDL_SetSurfaceBlendMode(SDL_Surface *surface, SDL_BlendMode blendMode);
+SDL_Cursor *SDL_CreateColorCursor(SDL_Surface *surface, int hot_x, int hot_y);
+int SDL_PushEvent(SDL_Event *event);
+void SDL_WarpMouseInWindow(SDL_Window *window, int x, int y);
+void SDL_RenderGetScale(SDL_Renderer *renderer, float *scaleX, float *scaleY);
+void SDL_GetWindowSize(SDL_Window *window, int *w, int *h);
+void SDL_GetWindowPosition(SDL_Window *window, int *x, int *y);
+Uint32 SDL_GetMouseState(int *x, int *y);
+SDL_bool SDL_IsTextInputActive(void);
+void SDL_StartTextInput(void);
+void SDL_Delay(Uint32 ms);
+int SDL_RenderCopy(SDL_Renderer *renderer, SDL_Texture *texture, SDL_Rect *srcrect, SDL_Rect *dstrect);
+void SDL_RenderPresent(SDL_Renderer *renderer);
+Uint32 SDL_GetWindowFlags(SDL_Window *window);
+int SDL_RenderSetLogicalSize(SDL_Renderer *renderer, int w, int h);
+void SDL_SetWindowSize(SDL_Window *window, int w, int h);
+int SDL_ShowSimpleMessageBox(Uint32 flags, char *title, char *message, SDL_Window *window);
+int SDL_SetWindowFullscreen(SDL_Window *window, Uint32 flags);
+void SDL_SetWindowGrab(SDL_Window *window, SDL_bool grabbed);
+void SDL_SetWindowPosition(SDL_Window *window, int x, int y);
+void SDL_DestroyTexture(SDL_Texture *texture);
+void SDL_DestroyRenderer(SDL_Renderer *renderer);
+void SDL_DestroyWindow(SDL_Window *window);
+int SDL_GetDesktopDisplayMode(int displayIndex, SDL_DisplayMode *mode);
+void SDL_SetWindowTitle(SDL_Window *window, char *title);
+int SDL_SetTextureBlendMode(SDL_Texture *texture, SDL_BlendMode blendMode);
+SDL_bool SDL_SetHint(char *name, char *value);
+SDL_Window *SDL_CreateWindow(char *title, int x, int y, int w, int h, Uint32 flags);
+SDL_Renderer *SDL_CreateRenderer(SDL_Window *window, int index, Uint32 flags);
+int SDL_SetRenderDrawBlendMode(SDL_Renderer *renderer, SDL_BlendMode blendMode);
+char *SDL_GetCurrentVideoDriver(void);
+SDL_Texture *SDL_CreateTexture(SDL_Renderer *renderer, Uint32 format, int access, int w, int h);
+void SDL_EnableScreenSaver(void);
+Uint32 SDL_GetTicks(void);
+int SDL_GetRendererOutputSize(SDL_Renderer *renderer, int *w, int *h);
+int SDL_SaveBMP(SDL_Surface *s, const char *file);
+
+enum {
+	AUDIO_S16,
+	AUDIO_F32,
+
+	SDL_AUDIO_ALLOW_ANY_CHANGE = ~0,
+
+	SDL_THREAD_PRIORITY_HIGH = 1,
+
+	SDL_QUERY = -1,
+	SDL_DISABLE,
+	SDL_ENABLE,
+
+	SDL_MESSAGEBOX_ERROR = 0,
+
+	SDL_WINDOW_MINIMIZED = 1<<0,
+	SDL_WINDOW_FULLSCREEN_DESKTOP = 1<<1,
+	SDL_WINDOW_INPUT_FOCUS = 1<<2,
+	SDL_WINDOW_ALLOW_HIGHDPI = 1<<3,
+	SDL_WINDOW_SHOWN = 1<<4,
+
+	SDL_WINDOWPOS_CENTERED = -1,
+	SDL_WINDOWPOS_UNDEFINED = -2,
+
+	SDL_INIT_AUDIO = 1<<0,
+	SDL_INIT_VIDEO = 1<<1,
+	SDL_INIT_JOYSTICK = 1<<2,
+
+	SDL_BLENDMODE_NONE = 0,
+
+	SDL_FLIP_NONE = 0,
+	SDL_FLIP_HORIZONTAL,
+	SDL_FLIP_VERTICAL,
+
+	SDL_PIXELFORMAT_ARGB8888 = 0x30128888,
+
+	/* shit no one cares about */
+	SDL_TEXTUREACCESS_STREAMING = 0,
+	SDL_TEXTUREACCESS_STATIC = 0,
+	SDL_RENDERER_ACCELERATED = 0,
+	SDL_RENDERER_PRESENTVSYNC = 0,
+};
+
+enum {
+	/* these HAVE to be in this order for notes to work in ft2-clone */
+	SDL_SCANCODE_A = 0x04,
+	SDL_SCANCODE_B,
+	SDL_SCANCODE_C,
+	SDL_SCANCODE_D,
+	SDL_SCANCODE_E,
+	SDL_SCANCODE_F,
+	SDL_SCANCODE_G,
+	SDL_SCANCODE_H,
+	SDL_SCANCODE_I,
+	SDL_SCANCODE_J,
+	SDL_SCANCODE_K,
+	SDL_SCANCODE_L,
+	SDL_SCANCODE_M,
+	SDL_SCANCODE_N,
+	SDL_SCANCODE_O,
+	SDL_SCANCODE_P,
+	SDL_SCANCODE_Q,
+	SDL_SCANCODE_R,
+	SDL_SCANCODE_S,
+	SDL_SCANCODE_T,
+	SDL_SCANCODE_U,
+	SDL_SCANCODE_V,
+	SDL_SCANCODE_W,
+	SDL_SCANCODE_X,
+	SDL_SCANCODE_Y,
+	SDL_SCANCODE_Z,
+	SDL_SCANCODE_1,
+	SDL_SCANCODE_2,
+	SDL_SCANCODE_3,
+	SDL_SCANCODE_4,
+	SDL_SCANCODE_5,
+	SDL_SCANCODE_6,
+	SDL_SCANCODE_7,
+	SDL_SCANCODE_8,
+	SDL_SCANCODE_9,
+	SDL_SCANCODE_0,
+	SDL_SCANCODE_ENTER,
+	SDL_SCANCODE_ESCAPE,
+	SDL_SCANCODE_BACKSPACE,
+	SDL_SCANCODE_TAB,
+	SDL_SCANCODE_SPACE,
+	SDL_SCANCODE_MINUS,
+	SDL_SCANCODE_EQUALS,
+	SDL_SCANCODE_LEFTBRACKET,
+	SDL_SCANCODE_RIGHTBRACKET,
+	SDL_SCANCODE_BACKSLASH,
+	SDL_SCANCODE_NONUSHASH,
+	SDL_SCANCODE_SEMICOLON,
+	SDL_SCANCODE_APOSTROPHE,
+	SDL_SCANCODE_GRAVE,
+	SDL_SCANCODE_SLASH,
+	SDL_SCANCODE_CAPSLOCK,
+
+	SDL_SCANCODE_RIGHT = 0x4f,
+	SDL_SCANCODE_LEFT,
+	SDL_SCANCODE_DOWN,
+	SDL_SCANCODE_UP,
+	SDL_SCANCODE_NUMLOCKCLEAR,
+	SDL_SCANCODE_KP_DIVIDE,
+	SDL_SCANCODE_KP_MULTIPLY,
+	SDL_SCANCODE_KP_MINUS,
+	SDL_SCANCODE_KP_PLUS,
+	SDL_SCANCODE_KP_ENTER,
+	SDL_SCANCODE_KP_1,
+	SDL_SCANCODE_KP_2,
+	SDL_SCANCODE_KP_3,
+	SDL_SCANCODE_KP_4,
+	SDL_SCANCODE_KP_5,
+	SDL_SCANCODE_KP_6,
+	SDL_SCANCODE_KP_7,
+	SDL_SCANCODE_KP_8,
+	SDL_SCANCODE_KP_9,
+	SDL_SCANCODE_KP_0,
+	SDL_SCANCODE_KP_PERIOD,
+	SDL_SCANCODE_NONUSBACKSLASH,
+
+	SDL_SCANCODE_MUTE = 0x7f,
+	SDL_SCANCODE_VOLUMEUP,
+	SDL_SCANCODE_VOLUMEDOWN,
+
+	SDL_SCANCODE_AUDIOMUTE = 0x106,
+
+	SDLK_a = 'a',
+	SDLK_b,
+	SDLK_c,
+	SDLK_d,
+	SDLK_e,
+	SDLK_f,
+	SDLK_g,
+	SDLK_h,
+	SDLK_i,
+	SDLK_j,
+	SDLK_k,
+	SDLK_l,
+	SDLK_m,
+	SDLK_n,
+	SDLK_o,
+	SDLK_p,
+	SDLK_q,
+	SDLK_r,
+	SDLK_s,
+	SDLK_t,
+	SDLK_u,
+	SDLK_v,
+	SDLK_w,
+	SDLK_x,
+	SDLK_y,
+	SDLK_z,
+	SDLK_0 = '0',
+	SDLK_1,
+	SDLK_2,
+	SDLK_3,
+	SDLK_4,
+	SDLK_5,
+	SDLK_6,
+	SDLK_7,
+	SDLK_8,
+	SDLK_9,
+	SDLK_DELETE = Kdel,
+	SDLK_RETURN = '\n',
+	SDLK_ESCAPE = Kesc,
+	SDLK_LESS = '<',
+	SDLK_SPACE = ' ',
+	SDLK_TAB = '\t',
+	SDLK_LEFT = Kleft,
+	SDLK_RIGHT = Kright,
+	SDLK_DOWN = Kdown,
+	SDLK_UP = Kup,
+	SDLK_F1 = KF|1,
+	SDLK_F2,
+	SDLK_F3,
+	SDLK_F4,
+	SDLK_F5,
+	SDLK_F6,
+	SDLK_F7,
+	SDLK_F8,
+	SDLK_F9,
+	SDLK_F10,
+	SDLK_F11,
+	SDLK_F12,
+	SDLK_INSERT = Kins,
+	SDLK_PAGEUP = Kpgup,
+	SDLK_PAGEDOWN = Kpgdown,
+	SDLK_HOME = Khome,
+	SDLK_END = Kend,
+	SDLK_BACKSPACE = Kbs,
+	SDLK_MINUS = '-',
+	SDLK_PLUS = '+',
+	SDLK_EQUALS = '=',
+	SDLK_UNDERSCORE = '_',
+
+	SDLK_LALT = Kalt,
+	SDLK_RALT = Kaltgr, /* FIXME what about keyboards without it? */
+	/* FIXME no distinction */
+	SDLK_LSHIFT = Kshift,
+	SDLK_RSHIFT = SDLK_LSHIFT,
+	SDLK_LCTRL = Kctl,
+	SDLK_RCTRL = '>', /* FIXME this is a hack */
+
+	/* FIXME not bound to anything */
+	SDLK_UNKNOWN = -99999,
+	SDLK_CAPSLOCK,
+	SDLK_KP_ENTER,
+
+	/* FIXME no distinction */
+	KMOD_LSHIFT = 1<<0,
+	KMOD_RSHIFT = KMOD_LSHIFT,
+	KMOD_LCTRL = 1<<1,
+	KMOD_RCTRL = KMOD_LCTRL,
+	KMOD_LALT = 1<<2,
+	KMOD_RALT = KMOD_LALT,
+	KMOD_LGUI = 1<<3,
+	KMOD_RGUI = KMOD_LGUI,
+
+	SDL_KEYDOWN = 0,
+	SDL_KEYUP,
+	SDL_MOUSEBUTTONDOWN,
+	SDL_MOUSEBUTTONUP,
+	SDL_MOUSEWHEEL,
+	SDL_MOUSEMOTION,
+	SDL_QUIT,
+	SDL_DROPFILE,
+	SDL_TEXTINPUT,
+	SDL_WINDOWEVENT,
+	SDL_WINDOWEVENT_HIDDEN,
+	SDL_WINDOWEVENT_SHOWN,
+	SDL_WINDOWEVENT_MINIMIZED,
+	SDL_WINDOWEVENT_FOCUS_LOST,
+	SDL_WINDOWEVENT_EXPOSED,
+
+	SDL_BUTTON_LEFT = 0,
+	SDL_BUTTON_MIDDLE = 1,
+	SDL_BUTTON_RIGHT = 2,
+
+	SDL_BUTTON_LMASK = 1<<SDL_BUTTON_LEFT,
+	SDL_BUTTON_MMASK = 1<<SDL_BUTTON_MIDDLE,
+	SDL_BUTTON_RMASK = 1<<SDL_BUTTON_RIGHT,
+};
+
+struct SDL_AudioSpec {
+	void (*callback)(void *, Uint8 *, int);
+	void *userdata;
+	int freq;
+	int format;
+	int channels;
+	int samples;
+};
+
+struct SDL_Point {
+	int x, y;
+};
+
+struct SDL_Rect {
+	int x, y, w, h;
+};
+
+struct SDL_Surface {
+	SDL_PixelFormat *format;
+	SDL_Rect clip_rect;
+	Uint32 flags;
+	Uint32 key;
+	int keyset;
+	int w, h;
+	int pitch;
+	uchar pixels[];
+};
+
+struct SDL_Event {
+	int type;
+	union {
+		struct {
+			int event;
+		}window;
+		struct {
+			struct {
+				SDL_Scancode scancode;
+				SDL_Keycode sym;
+			}keysym;
+			int repeat;
+		}key;
+		struct {
+			int x, y;
+			int button;
+		}button;
+		struct {
+			int x, y;
+		}motion;
+		struct {
+			char text[UTFmax+1];
+		}text;
+		struct {
+			int x, y;
+		}wheel;
+		struct {
+			char *file;
+		}drop;
+	};
+};
+
+struct SDL_DisplayMode
+{
+	int format;
+	int w;
+	int h;
+	int refresh_rate;
+};
+
+#endif
--- /dev/null
+++ b/alloca.h
@@ -1,0 +1,1 @@
+#include "plan9.h"
--- /dev/null
+++ b/assert.h
@@ -1,0 +1,1 @@
+#include "plan9.h"
--- /dev/null
+++ b/ctype.h
@@ -1,0 +1,7 @@
+#ifndef _ctype_h_
+#define _ctype_h_
+
+#include "plan9.h"
+#include </sys/include/ctype.h>
+
+#endif
--- /dev/null
+++ b/dirent.c
@@ -1,0 +1,59 @@
+#include <dirent.h>
+
+struct DIR {
+	Dir *d;
+	struct dirent de;
+	int fd;
+	long n; /* number of entries in d */
+	long i; /* current entry to return from readdir */
+};
+
+struct dirent *
+readdir(DIR *d)
+{
+	if(d->i >= d->n){
+		free(d->d);
+		if((d->n = dirread(d->fd, &d->d)) <= 0)
+			return nil;
+		d->i = 0;
+	}
+
+	d->de.d_type = (d->d[d->i].qid.type & QTDIR) ? DT_DIR : DT_FILE;
+	d->de.d_name = d->d[d->i].name;
+	d->i++;
+
+	return &d->de;
+}
+
+DIR *
+opendir(char *name)
+{
+	Dir *dir;
+	DIR *d;
+	int fd;
+
+	dir = nil;
+	d = nil;
+	if((fd = open(name, OREAD|OCEXEC)) >= 0 &&
+	    (dir = dirfstat(fd)) != nil &&
+	    (dir->qid.type & QTDIR) != 0 &&
+	    (d = calloc(1, sizeof(*d))) != nil){
+		d->fd = fd;
+	}
+
+	free(dir);
+	if(d == nil)
+		close(fd);
+
+	return d;
+}
+
+int
+closedir(DIR *d)
+{
+	free(d->d);
+	close(d->fd);
+	free(d);
+
+	return 0;
+}
--- /dev/null
+++ b/dirent.h
@@ -1,0 +1,25 @@
+#ifndef _dirent_h_
+#define _dirent_h_
+
+#include "plan9.h"
+
+enum {
+	DT_LNK = -1,
+	DT_UNKNOWN = 0,
+	DT_FILE,
+	DT_DIR,
+};
+
+struct dirent {
+	int d_type;
+	char *d_name;
+};
+
+typedef struct DIR DIR;
+#pragma incomplete DIR
+
+DIR *opendir(char *name);
+int closedir(DIR *dirp);
+struct dirent *readdir(DIR *dirp);
+
+#endif
--- /dev/null
+++ b/iconv.c
@@ -1,0 +1,125 @@
+#include <iconv.h>
+
+enum {
+	Itranslit = 1<<0, /* no transliteration is performed :( */
+	Iignore = 1<<1, /* this option is ignored (pun TOTALLY intended) if Itranslit is set */
+
+	Tcs = 0,
+	Us,
+};
+
+struct iconv_s {
+	char to[16];
+	char from[16];
+	int fd;
+};
+
+static int
+cp2tcs(char *cp, char *tcs, int sz)
+{
+	int opt, n, i;
+	char *s;
+
+	opt = 0;
+	n = 0;
+	for(s = cp; (s = strstr(s, "//")) != nil;){
+		if(n == 0)
+			n = (int)(s - cp);
+		s += 2;
+		if(strncmp(s, "TRANSLIT", 8) == 0 && (s[8] == 0 || s[8] == '/'))
+			opt |= Itranslit;
+		else if(strncmp(s, "IGNORE", 6) == 0 && (s[6] == 0 || s[6] == '/'))
+			opt |= Iignore;
+	}
+	if(n < 1)
+		n = strlen(cp);
+
+	if(cp[0] >= '0' && cp[0] <= '9'){ /* ibm */
+		n = snprint(tcs, sz, "ibm%.*s", n, cp);
+	}else if(strncmp(cp, "ISO", 3) == 0){
+		if(cp[3] == '-' || cp[3] == '_'){
+			n--;
+			cp++;
+		}
+		n = snprint(tcs, sz, "%.*s", n-3, cp+3);
+	}else if(strncmp(cp, "CP12", 4) == 0){
+		n = snprint(tcs, sz, "windows-12%.*s", n-4, cp+4);
+	}else{ /* last chance, convert to lowercase. FIXME not all are supported, no checks are made */
+		n = snprint(tcs, sz, "%.*s", n, cp);
+		for(i = 0; i < n; i++)
+			tcs[i] = tolower(tcs[i]);
+	}
+
+	return n >= sz ? -1 : opt;
+}
+
+iconv_t
+iconv_open(char *to, char *from)
+{
+	int opt, pid, p[2];
+	iconv_t ic;
+
+	p[0] = p[1] = -1;
+	if((ic = calloc(1, sizeof(*ic))) == nil)
+		goto err;
+	if(cp2tcs(from, ic->from, sizeof(ic->from)) < 0)
+		goto err;
+	if((opt = cp2tcs(to, ic->to, sizeof(ic->to))) < 0)
+		goto err;
+	if(pipe(p) < 0)
+		goto err;
+	if((pid = rfork(RFPROC|RFFDG|RFNOTEG|RFCENVG|RFNOWAIT)) == 0){
+		dup(p[Tcs], 0);
+		dup(p[Tcs], 1);
+		close(p[0]);
+		close(p[1]);
+		close(2); /* comment it out if you need debugging */
+		execl("/bin/tcs", "tcs", "-f", ic->from, "-t", ic->to, (opt == Iignore) ? "-c" : nil, nil);
+		sysfatal("execl: %r");
+	}else if(pid < 0){
+		goto err;
+	}
+	close(p[Tcs]);
+	ic->fd = p[Us];
+
+	setmalloctag(ic, getcallerpc(&to));
+
+	return ic;
+err:
+	close(p[0]);
+	close(p[1]);
+	if(ic != nil)
+		free(ic);
+	return (iconv_t)-1;
+}
+
+void
+iconv_close(iconv_t ic)
+{
+	close(ic->fd);
+	free(ic);
+}
+
+size_t
+iconv(iconv_t ic, char **inbuf, size_t *inbytesleft, char **outbuf, size_t *outbytesleft)
+{
+	int n;
+
+	if(inbuf == nil || *inbuf == nil){ /* flush */
+		write(ic->fd, "", 0);
+	}else{
+		if((n = write(ic->fd, *inbuf, *inbytesleft)) < 0)
+			return -1;
+		*inbuf += n;
+		*inbytesleft -= n;
+		return 0;
+	}
+	if(outbuf == nil || *outbuf == nil) /* nothing to do */
+		return 0;
+	if((n = read(ic->fd, *outbuf, *outbytesleft)) < 0)
+		return -1;
+	*outbuf += n;
+	*outbytesleft -= n;
+
+	return n;
+}
--- /dev/null
+++ b/iconv.h
@@ -1,0 +1,14 @@
+#ifndef _iconv_h_
+#define _iconv_h_
+
+#include "plan9.h"
+#include <stdint.h>
+
+typedef struct iconv_s *iconv_t;
+#pragma incomplete struct iconv_s
+
+iconv_t iconv_open(char *to, char *from);
+void iconv_close(iconv_t);
+size_t iconv(iconv_t cd, char **inbuf, size_t *inbytesleft, char **outbuf, size_t *outbytesleft);
+
+#endif
--- /dev/null
+++ b/limits.h
@@ -1,0 +1,18 @@
+#ifndef _limits_h_
+#define _limits_h_
+
+#define INT16_MAX 0x7fff
+#define INT16_MIN ((int16_t)0x8000)
+#define INT64_MIN ((int64_t)0x8000000000000000ULL)
+#define INT32_MAX 0x7fffffff
+#define INT_MAX INT32_MAX
+#define INT32_MIN (-INT32_MAX-1)
+#define INT_MIN INT32_MIN
+#define SHRT_MAX 0x7fff
+#define SHRT_MIN (-SHRT_MAX-1)
+#define SIZE_MAX 0xffffffffU
+#define UINT32_MAX 0xffffffffU
+#define UINT_MAX UINT32_MAX
+#define UINT64_MAX 0xffffffffffffffffULL
+
+#endif
--- /dev/null
+++ b/malloc.h
@@ -1,0 +1,1 @@
+#include "plan9.h"
--- /dev/null
+++ b/math.c
@@ -1,0 +1,71 @@
+#include <math.h>
+
+/* some of these were taken from musl */
+
+#define ln2o1 1.4426950408889634073599
+#define dbleps 2.2204460492503131e-16
+#define huge 1.79769313486231e+308
+
+static double toint = 1.0/dbleps;
+
+double
+round(double x)
+{
+	union {double f; u64int i;} u = {x};
+	int e = u.i >> 52 & 0x7ff;
+	double y;
+
+	if(e >= 0x3ff+52)
+		return x;
+	if(u.i >> 63)
+		x = -x;
+	if(e < 0x3ff-1)
+		return 0*u.f;
+	y = x + toint - toint - x;
+	if(y > 0.5)
+		y = y + x - 1;
+	else if(y <= -0.5)
+		y = y + x + 1;
+	else
+		y = y + x;
+	if(u.i >> 63)
+		y = -y;
+
+	return y;
+}
+
+double
+log2(double x)
+{
+	if(x == 0)
+		return -huge;
+	if(x < 0 || isNaN(x))
+		return NaN();
+
+	return log(x)*ln2o1;
+}
+
+double
+trunc(double x)
+{
+	union {double f; u64int i;} u = {x};
+	int e = (int)(u.i >> 52 & 0x7ff) - 0x3ff + 12;
+	u64int m;
+
+	if(e >= 52 + 12)
+		return x;
+	if(e < 12)
+		e = 1;
+	m = -1ULL >> e;
+	if((u.i & m) == 0)
+		return x;
+	u.i &= ~m;
+
+	return u.f;
+}
+
+double
+exp2(double x)
+{
+	return exp(x/ln2o1);
+}
--- /dev/null
+++ b/math.h
@@ -1,0 +1,18 @@
+#ifndef _math_h_
+#define _math_h_
+
+#include "plan9.h"
+
+#define sinf sin
+#define cosf cos
+#define fabsf fabs
+#define fmodf fmod
+#define ceilf ceil
+#define floorf floor
+
+double round(double);
+double log2(double);
+double trunc(double);
+double exp2(double);
+
+#endif
--- /dev/null
+++ b/plan9.c
@@ -1,0 +1,86 @@
+#include "plan9.h"
+#include <thread.h>
+#include <tos.h>
+#include <pool.h>
+
+int mainstacksize = 32*1024;
+
+int
+rm_r(char *dir)
+{
+	int pid;
+
+	if((pid = rfork(RFPROC|RFFDG|RFNOTEG|RFCENVG|RFNOWAIT)) == 0){
+		execl("/bin/rm", "rm", "-r", dir, nil);
+		sysfatal("execl: %r");
+	}
+
+	return pid < 0 ? -1 : 0;
+}
+
+/*
+ * nsec() is wallclock and can be adjusted by timesync
+ * so need to use cycles() instead, but fall back to
+ * nsec() in case we can't
+ */
+uvlong
+nanosec(void)
+{
+	static uvlong fasthz, xstart;
+	uvlong x, div;
+
+	if(fasthz == ~0ULL)
+		return nsec() - xstart;
+
+	if(fasthz == 0){
+		if(_tos->cyclefreq){
+			cycles(&xstart);
+			fasthz = _tos->cyclefreq;
+		} else {
+			xstart = nsec();
+			fasthz = ~0ULL;
+			fprint(2, "cyclefreq not available, falling back to nsec()\n");
+			fprint(2, "you might want to disable aux/timesync\n");
+			return 0;
+		}
+	}
+	cycles(&x);
+	x -= xstart;
+
+	/* this is ugly */
+	for(div = NSEC; x < 0x1999999999999999ULL && div > 1 ; div /= 10ULL, x *= 10ULL);
+
+	return x / (fasthz / div);
+}
+
+void
+nsleep(uvlong ns)
+{
+	uvlong start, end;
+
+	start = nanosec();
+	end = start + ns;
+	ns = start;
+	do{
+		if(end - ns > 750000000ULL)
+			sleep(70);
+		else if (end - ns > 25000000ULL)
+			sleep(20);
+		else if (end - ns > 10000000ULL)
+			sleep(1);
+		else
+			break;
+		ns = nanosec();
+	}while(ns < end);
+}
+
+void
+threadmain(int argc, char **argv)
+{
+	int __main(int argc, char *argv[]);
+
+	setfcr(getfcr() & ~(FPINVAL|FPOVFL));
+	//mainmem->flags |= POOL_PARANOIA | POOL_ANTAGONISM;
+
+	threadexitsall(__main(argc, argv) == 0 ? nil : "error");
+}
--- /dev/null
+++ b/plan9.h
@@ -1,0 +1,18 @@
+#ifndef __plan9_h__
+#define __plan9_h__
+
+#include <u.h>
+#include <libc.h>
+#include </sys/include/stdio.h>
+
+#define PATH_MAX 256
+
+#define __attribute__(a)
+#define main __main
+#define NSEC 1000000000ULL
+
+int rm_r(char *dir);
+uvlong nanosec(void);
+void nsleep(uvlong ns);
+
+#endif
--- /dev/null
+++ b/sdl2.c
@@ -1,0 +1,1335 @@
+#include "plan9.h"
+#include <stdint.h>
+#include <tos.h>
+#include <draw.h>
+#include <memdraw.h>
+#include <mouse.h>
+#include <cursor.h>
+#include <thread.h>
+#include <SDL2/SDL.h>
+#include <pool.h>
+
+typedef struct Audiodev Audiodev;
+
+enum {
+	Aout = 2,
+	Arec,
+
+	/* FIXME missing plumber→dropfile and enter()→text */
+	Ckey = 0,
+	Ckeytype,
+	Cmouse,
+	Cresize,
+	Numchan,
+
+	Rdown = 0,
+	Rup,
+	Rrepeat,
+
+	Audiobufsz = 16384,
+};
+
+struct SDL_Window {
+	int dummy;
+};
+
+struct SDL_Renderer {
+	int dummy;
+};
+
+struct SDL_Texture {
+	Memimage;
+};
+
+struct SDL_PixelFormat {
+	int format;
+};
+
+struct SDL_Cursor {
+	Image *i;
+	Image *m;
+	Point hot;
+};
+
+struct SDL_Thread {
+	SDL_ThreadFunction f;
+	char *name;
+	void *userdata;
+};
+
+static SDL_PixelFormat argb8888 = {
+	.format = SDL_PIXELFORMAT_ARGB8888,
+};
+
+struct Audiodev {
+	QLock;
+	int paused;
+	int fd;
+	int pid;
+	int mode;
+	Uint8 buf[Audiobufsz];
+	void *userdata;
+	void (*cb)(void *, Uint8 *, int);
+};
+
+/* FIXME extra USB audio devices? */
+static Audiodev au[4] = {
+	[0] = {.fd = -1, .mode = -1},
+	[1] = {.fd = -1, .mode = -1},
+	[Aout] = {.fd = -1, .pid = -1, .mode = OWRITE},
+	[Arec] = {.fd = -1, .pid = -1, .mode = OREAD},
+};
+
+static SDL_Window onewin;
+static SDL_Renderer oneren;
+static int kmod;
+static Mouse mouse, oldmouse;
+static Rune rune;
+static Mousectl *mctl;
+static Keyboardctl kctl;
+static Memimage *back;
+static u8int *backcopy;
+static Image *front;
+static int logiw, logih;
+static int physw, physh;
+static int forceredraw = 1;
+static SDL_Cursor *oldcursor, *cursor;
+static int mouseredraw = 0;
+static int showcursor = SDL_ENABLE;
+static int textinput;
+
+static Cursor nocursor = {
+	{0, 0},
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	},
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	},
+};
+
+static Alt salt[Numchan+1] = {
+	[Ckey] = { nil, &rune, CHANRCV },
+	[Ckeytype] = { nil, nil, CHANNOP },
+	[Cmouse] = { nil, &mouse, CHANRCV },
+	[Cresize] = { nil, nil, CHANRCV },
+	[Numchan] = { nil, nil, CHANNOBLK },
+};
+
+static void
+kbdproc(void *)
+{
+	char buf[128], buf2[128], *s;
+	int kfd, n, kbin, t;
+	Rune r, o;
+
+	threadsetname("kbdproc");
+	if((kfd = open("/dev/kbd", OREAD|OCEXEC)) < 0)
+		sysfatal("/dev/kbd: %r");
+	kbin = open("/dev/kbin", OWRITE|OCEXEC);
+
+	buf2[0] = 0;
+	buf2[1] = 0;
+	buf[0] = 0;
+	kmod = 0;
+	o = 0;
+	for(;;){
+		if(buf[0] != 0){
+			n = strlen(buf)+1;
+			memmove(buf, buf+n, sizeof(buf)-n);
+		}
+		if(buf[0] == 0){
+			n = read(kfd, buf, sizeof(buf)-1);
+			if(n <= 0)
+				break;
+			buf[n-1] = 0;
+			buf[n] = 0;
+		}
+
+		switch(buf[0]){
+		case 'c':
+			if(chartorune(&r, buf+1) > 0 && r != Runeerror){
+				t = Rrepeat;
+				if(!textinput)
+					r = tolowerrune(r);
+				if(textinput || o != r){
+					send(salt[Ckey].c, &r);
+					send(salt[Ckeytype].c, &t);
+				}
+				o = 0;
+			}
+		default:
+			continue;
+
+		case 'k':
+			s = buf+1;
+			while(*s){
+				s += chartorune(&r, s);
+				if(utfrune(buf2+1, r) == nil){
+					if(r == Kalt){
+						/* magic trick: write Alt scancode to disable the "compose" mode */
+						/* FIXME: does this work in both native AND drawterm? */
+						write(kbin, "\x46", 1);
+						kmod |= KMOD_LALT;
+					}else if (r == Kshift)
+						kmod |= KMOD_LSHIFT;
+					else if(r == Kctl)
+						kmod |= KMOD_LCTRL;
+					else{
+						t = Rdown;
+						send(salt[Ckey].c, &r);
+						send(salt[Ckeytype].c, &t);
+						o = r;
+					}
+				}
+			}
+			break;
+
+		case 'K':
+			s = buf2+1;
+			while(*s){
+				s += chartorune(&r, s);
+				if(utfrune(buf+1, r) == nil){
+					if(r == Kalt)
+						kmod &= ~KMOD_LALT;
+					else if(r == Kshift)
+						kmod &= ~KMOD_LSHIFT;
+					else if(r == Kctl)
+						kmod &= ~KMOD_LCTRL;
+					else{
+						t = Rup;
+						send(salt[Ckey].c, &r);
+						send(salt[Ckeytype].c, &t);
+					}
+				}
+			}
+			break;
+		}
+		strcpy(buf2, buf);
+	}
+
+	threadexits(nil);
+}
+
+int
+SDL_Init(int mask)
+{
+	/* FIXME actually use the mask? */
+	USED(mask);
+
+	if(memimageinit() < 0)
+		goto err;
+	if(initdraw(nil, nil, "ft2-clone") < 0)
+		goto err;
+	if((mctl = initmouse(nil, screen)) == nil)
+		goto err;
+
+	salt[Ckey].c = chancreate(sizeof(Rune), 20);
+	salt[Ckeytype].c = chancreate(sizeof(int), 20);
+	salt[Cmouse].c = mctl->c;
+	salt[Cresize].c = mctl->resizec;
+	kctl.c = salt[Ckey].c; /* for enter() */
+
+	if(salt[Ckey].c == nil || salt[Ckeytype].c == nil || proccreate(kbdproc, nil, 4096) < 0)
+		goto err;
+
+	return 0;
+err:
+	werrstr("SDL_Init: %r");
+	return -1;
+}
+
+int
+SDL_EventState(Uint32, int)
+{
+	return 0;
+}
+
+SDL_Keymod
+SDL_GetModState(void)
+{
+	return kmod;
+}
+
+int
+SDL_ShowCursor(int toggle)
+{
+	if(toggle == SDL_QUERY)
+		return showcursor;
+
+	showcursor = toggle == SDL_ENABLE;
+	setcursor(mctl, (cursor == nil && showcursor) ? nil : &nocursor);
+
+	return showcursor;
+}
+
+int
+SDL_GetNumAudioDevices(int iscapture)
+{
+	/* FIXME look for extra USB devices? */
+	USED(iscapture);
+	return 1;
+}
+
+char *
+SDL_GetAudioDeviceName(int index, int iscapture)
+{
+	/* FIXME look for extra USB devices? */
+	USED(index); USED(iscapture);
+	return "/dev/audio";
+}
+
+void
+SDL_LockAudioDevice(SDL_AudioDeviceID id)
+{
+	qlock(&au[id]);
+}
+
+void
+SDL_UnlockAudioDevice(SDL_AudioDeviceID id)
+{
+	qunlock(&au[id]);
+}
+
+static void
+audiothread(void *p)
+{
+	Audiodev *d;
+
+	d = p;
+	threadsetname("audio %s", d == &au[Aout] ? "out" : "in");
+
+	for(;;){
+		qlock(d);
+		if(d->paused)
+			memset(d->buf, 0, sizeof(d->buf));
+		else
+			d->cb(d->userdata, d->buf, sizeof(d->buf));
+		qunlock(d);
+
+		if(write(d->fd, d->buf, sizeof(d->buf)) != sizeof(d->buf))
+			break;
+	}
+
+	threadexits(nil);
+}
+
+void
+SDL_PauseAudioDevice(SDL_AudioDeviceID id, SDL_bool pause)
+{
+	Audiodev *a;
+
+	a = &au[id];
+	if(a->paused && !pause){
+		if(a->pid < 0)
+			a->pid = proccreate(audiothread, a, mainstacksize);
+		a->paused = 0;
+	}else if(!a->paused && pause){
+		a->paused = 1;
+	}
+}
+
+SDL_AudioDeviceID
+SDL_OpenAudioDevice(char *dev, int rec, SDL_AudioSpec *want, SDL_AudioSpec *have, u32int change)
+{
+	Audiodev *a;
+	SDL_AudioDeviceID id;
+
+	/* FIXME look for extra USB devices? */
+	USED(dev);
+
+	if(change != SDL_AUDIO_ALLOW_ANY_CHANGE){ /* FIXME sampling in mono */
+		werrstr("SDL_OpenAudioDevice: changes not implemented");
+		return 0;
+	}
+
+	have->freq = 44100;
+	have->format = AUDIO_S16;
+	have->channels = 2;
+	have->samples = want->samples;
+
+	id = rec ? Arec : Aout;
+	a = &au[id];
+
+	if(a->fd < 0 && (a->fd = open("/dev/audio", a->mode|OCEXEC)) < 0){
+		werrstr("SDL_OpenAudioDevice: %r");
+		return 0;
+	}
+
+	a->userdata = want->userdata;
+	a->cb = want->callback;
+	a->paused = 1;
+
+	return id;
+}
+
+void
+SDL_CloseAudioDevice(SDL_AudioDeviceID id)
+{
+	Audiodev *a;
+
+	a = &au[id];
+	qlock(a);
+	close(a->fd);
+	a->fd = -1;
+	a->pid = -1;
+	a->userdata = nil;
+	a->cb = nil;
+	qunlock(a);
+}
+
+u64int
+SDL_GetPerformanceFrequency(void)
+{
+	return _tos->cyclefreq;
+}
+
+u64int
+SDL_GetPerformanceCounter(void)
+{
+	u64int x;
+
+	cycles(&x);
+
+	return x;
+}
+
+char *
+SDL_GetError(void)
+{
+	static char err[256];
+
+	snprint(err, sizeof(err), "%r");
+
+	return err;
+}
+
+static void
+sdlthread(void *p)
+{
+	SDL_Thread t;
+
+	t = *(SDL_Thread*)p;
+	if(t.name != nil)
+		threadsetname(t.name);
+	free(p);
+
+	threadexits(t.f(t.userdata) == 0 ? nil : "error");
+}
+
+SDL_Thread *
+SDL_CreateThread(SDL_ThreadFunction f, char *name, void *userdata)
+{
+	SDL_Thread *t;
+
+	if((t = calloc(1, sizeof(*t))) == nil)
+		return nil;
+
+	t->f = f;
+	t->name = name;
+	t->userdata = userdata;
+
+	if(proccreate(sdlthread, t, mainstacksize) < 0){
+		free(t);
+		t = nil;
+	}
+
+	return t;
+}
+
+void
+SDL_DetachThread(SDL_Thread *)
+{
+}
+
+static void *
+readfile(char *path, int *got)
+{
+	void *data, *data2;
+	int f, n, r, sz;
+
+	if((f = open(path, OREAD|OCEXEC)) < 0)
+		return nil;
+
+	sz = 32768;
+	data = nil;
+	for(n = 0;; n += r){
+		if(sz-n < 65536){
+			sz *= 2;
+			if((data2 = realloc(data, sz)) == nil)
+				goto err;
+			data = data2;
+		}
+		if((r = read(f, (char*)data+n, sz-n-1)) < 0)
+			goto err;
+		if(r == 0)
+			break;
+	}
+
+	if(got != nil)
+		*got = n;
+	((char*)data)[n] = 0;
+
+	return data;
+err:
+	free(data);
+	close(f);
+	return nil;
+}
+
+char *
+SDL_GetClipboardText(void)
+{
+	return readfile("/dev/snarf", nil);
+}
+
+int
+SDL_SetClipboardText(char *s)
+{
+	int f, n;
+
+	n = -1;
+	if((f = open("/dev/snarf", OWRITE|OTRUNC|OCEXEC)) >= 0){
+		n = strlen(s);
+		n = write(f, s, n) == n ? 0 : -1;
+		close(f);
+	}
+
+	if(n != 0)
+		werrstr("SDL_SetClipboardText: %r");
+
+	return n;
+}
+
+SDL_Texture *
+SDL_CreateTexture(SDL_Renderer *, Uint32 format, int, int w, int h)
+{
+	SDL_Texture *t;
+
+	if(format != SDL_PIXELFORMAT_ARGB8888){
+		werrstr("SDL_CreateTexture: only SDL_PIXELFORMAT_ARGB8888 is supported");
+		goto err;
+	}
+	if((t = (SDL_Texture*)allocmemimage(Rect(0, 0, w, h), XRGB32)) == nil) /* FIXME ARGB32? */
+		goto err;
+	memfillcolor(t, DTransparent);
+
+	return t;
+err:
+	werrstr("SDL_CreateTexture: %r");
+	return nil;
+}
+
+int
+SDL_UpdateTexture(SDL_Texture *t, SDL_Rect *re, void *pixels, int pitch)
+{
+	Rectangle r;
+
+	r = re ? Rect(re->x, re->y, re->x+re->w, re->y+re->h) : t->r;
+	/* FIXME non-ARGB8888 */
+	/* FIXME pitch */ USED(pitch);
+	if(loadmemimage(t, r, pixels, Dx(r)*Dy(r)*4) < 0){
+		werrstr("SDL_UpdateTexture: %r");
+		return -1;
+	}
+
+	return 0;
+}
+
+int
+SDL_RenderClear(SDL_Renderer *)
+{
+	if(back != nil)
+		memfillcolor(back, DBlack);
+
+	return 0;
+}
+
+int
+SDL_GetWindowDisplayIndex(SDL_Window *)
+{
+	return 0;
+}
+
+void
+SDL_Quit(void)
+{
+	threadexitsall(nil);
+}
+
+void
+SDL_free(void *p)
+{
+	free(p);
+}
+
+SDL_Surface *
+SDL_CreateRGBSurface(Uint32, int w, int h, int bpp, Uint32 rm, Uint32 gm, Uint32 bm, Uint32 am)
+{
+	SDL_Surface *s;
+	int n;
+
+	USED(rm, gm, bm, am); /* FIXME masks */
+
+	n = w*h*bpp/8;
+	if((s = calloc(1, sizeof(*s)+n)) == nil){
+		werrstr("SDL_CreateRGBSurface: memory");
+		return nil;
+	}
+	s->format = &argb8888;
+	s->w = w;
+	s->h = h;
+	s->pitch = w*bpp/8;
+	s->clip_rect.x = 0;
+	s->clip_rect.y = 0;
+	s->clip_rect.w = w;
+	s->clip_rect.h = h;
+
+	return s;
+}
+
+SDL_Surface *
+SDL_CreateRGBSurfaceFrom(Uint32 *pixels, int w, int h, int bpp, int pitch, Uint32 rm, Uint32 gm, Uint32 bm, Uint32 am)
+{
+	SDL_Surface *s;
+	int n;
+
+	USED(pitch); /* FIXME pitch */
+
+	if((s = SDL_CreateRGBSurface(0, w, h, bpp, rm, gm, bm, am)) == nil)
+		return nil;
+
+	n = w*h*bpp/8;
+	memmove(s->pixels, pixels, n);
+
+	return s;
+}
+
+void
+SDL_FreeSurface(SDL_Surface *surface)
+{
+	memset(surface, 0, sizeof(surface));
+	free(surface);
+}
+
+Uint32
+SDL_MapRGB(SDL_PixelFormat *, Uint8 r, Uint8 g, Uint8 b)
+{
+	return r<<24 | g<<16 | b<<8 | 0xff;
+}
+
+int
+SDL_SetColorKey(SDL_Surface *s, int flag, Uint32 key)
+{
+	s->keyset = flag;
+	s->key = key;
+	return 0;
+}
+
+SDL_Cursor *
+SDL_CreateColorCursor(SDL_Surface *s, int hot_x, int hot_y)
+{
+	SDL_Cursor *c;
+	Rectangle r;
+	uchar *m;
+	int n;
+
+	m = nil;
+	if((c = calloc(1, sizeof(*c))) == nil){
+		werrstr("memory");
+		goto err;
+	}
+
+	r = Rect(0, 0, s->w, s->h);
+	if(s->keyset){
+		if((c->m = allocimage(display, r, GREY8, 0, DTransparent)) == nil)
+			goto err;
+		if((m = malloc(s->w * s->h)) == nil)
+			goto err;
+		for(n = 0; n < s->w * s->h; n++){
+			m[n] = ((u32int*)s->pixels)[n] == s->key ? 0x00 : 0xff;
+			if(m[n] == 0)
+				((u32int*)s->pixels)[n] = 0;
+		}
+		if(loadimage(c->m, r, m, n) < 1)
+			goto err;
+		free(m);
+		m = nil;
+	}
+	if((c->i = allocimage(display, r, s->keyset ? XRGB32 : ARGB32, 0, DTransparent)) == nil)
+		goto err;
+	n = s->w * s->h * 4; /* FIXME non-ARGB8888 */
+	if(loadimage(c->i, r, s->pixels, n) < 1)
+		goto err;
+
+	c->hot = Pt(hot_x, hot_y);
+
+	return c;
+err:
+	werrstr("SDL_CreateColorCursor: %r");
+	if(c != nil){
+		freeimage(c->i);
+		freeimage(c->m);
+	}
+	free(c);
+	free(m);
+	return nil;
+}
+
+SDL_Cursor *
+SDL_GetDefaultCursor(void)
+{
+	return nil;
+}
+
+void
+SDL_SetCursor(SDL_Cursor *c)
+{
+	if(cursor != c){
+		cursor = c;
+		mouseredraw = 1;
+		setcursor(mctl, (cursor == nil && showcursor) ? nil : &nocursor);
+	}
+}
+
+void
+SDL_FreeCursor(SDL_Cursor *c)
+{
+	freeimage(c->i);
+	free(c);
+	if(cursor == c){
+		oldcursor = nil;
+		cursor = nil;
+	}
+}
+
+static int
+rune2scancode(Rune r)
+{
+	if(r >= 'a' && r <= 'z')
+		return r - 'a' + SDL_SCANCODE_A;
+	if(r >= '1' && r <= '9')
+		return r - '1' + SDL_SCANCODE_1;
+	if(r == '0')  return SDL_SCANCODE_0;
+	if(r == '\n') return SDL_SCANCODE_ENTER;
+	if(r == Kesc) return SDL_SCANCODE_ESCAPE;
+	if(r == Kbs)  return SDL_SCANCODE_BACKSPACE;
+	if(r == '\t') return SDL_SCANCODE_TAB;
+	if(r == ' ')  return SDL_SCANCODE_SPACE;
+	if(r == '-')  return SDL_SCANCODE_MINUS;
+	if(r == '=')  return SDL_SCANCODE_EQUALS;
+	if(r == '[')  return SDL_SCANCODE_LEFTBRACKET;
+	if(r == ']')  return SDL_SCANCODE_RIGHTBRACKET;
+	if(r == '\\') return SDL_SCANCODE_BACKSLASH;
+	if(r == ';')  return SDL_SCANCODE_SEMICOLON;
+	if(r == '\'') return SDL_SCANCODE_APOSTROPHE;
+	if(r == '/')  return SDL_SCANCODE_SLASH;
+
+	if(r == Kright) return SDL_SCANCODE_RIGHT;
+	if(r == Kleft) return SDL_SCANCODE_LEFT;
+	if(r == Kdown) return SDL_SCANCODE_DOWN;
+	if(r == Kup) return SDL_SCANCODE_UP;
+
+/* FIXME
+	SDL_SCANCODE_NUMLOCKCLEAR,
+	SDL_SCANCODE_KP_DIVIDE,
+	SDL_SCANCODE_KP_MULTIPLY,
+	SDL_SCANCODE_KP_MINUS,
+	SDL_SCANCODE_KP_PLUS,
+	SDL_SCANCODE_KP_ENTER,
+	SDL_SCANCODE_KP_1,
+	SDL_SCANCODE_KP_2,
+	SDL_SCANCODE_KP_3,
+	SDL_SCANCODE_KP_4,
+	SDL_SCANCODE_KP_5,
+	SDL_SCANCODE_KP_6,
+	SDL_SCANCODE_KP_7,
+	SDL_SCANCODE_KP_8,
+	SDL_SCANCODE_KP_9,
+	SDL_SCANCODE_KP_0,
+	SDL_SCANCODE_KP_PERIOD,
+	SDL_SCANCODE_NONUSBACKSLASH,
+	SDL_SCANCODE_NONUSHASH,
+*/
+	/* FIXME there are some missing */
+
+	if(r == L'`' || r == L'´') /* FIXME this is most likely wrong */
+		return SDL_SCANCODE_GRAVE;
+
+	return r;
+}
+
+int
+SDL_PollEvent(SDL_Event *e)
+{
+	int t, down;
+
+	if(e == nil) /* FIXME need to buffer the event so it won't get lost */
+		return 0;
+
+	switch(alt(salt)){
+	case Ckey:
+		recv(salt[Ckeytype].c, &t);
+		if(textinput && rune >= 0x20 && rune <= 0x7f){
+			if(t != Rrepeat)
+				break;
+			e->type = SDL_TEXTINPUT;
+			e->text.text[runetochar(e->text.text, &rune)] = 0;
+		}else if(textinput && t != Rrepeat){
+			break;
+		}else{
+			e->type = (t == Rup) ? SDL_KEYUP : SDL_KEYDOWN;
+			e->key.repeat = !textinput && t == Rrepeat;
+			e->key.keysym.scancode = rune2scancode(rune);
+			e->key.keysym.sym = rune;
+		}
+		return 1;
+
+	case Cmouse:
+		e->motion.x = mouse.xy.x - screen->r.min.x;
+		e->motion.y = mouse.xy.y - screen->r.min.y;
+		if(!eqpt(mouse.xy, oldmouse.xy)){
+			mouseredraw = 1;
+			if(mouse.buttons == oldmouse.buttons){
+				e->type = SDL_MOUSEMOTION;
+				return 1;
+			}
+		}
+		if(mouse.buttons == oldmouse.buttons)
+			break;
+		/* FIXME there is a lot of hope for both buttons to never change at the same time */
+		if((down = (mouse.buttons & 1)) != (oldmouse.buttons & 1)){ /* left */
+			e->type = down ? SDL_MOUSEBUTTONDOWN : SDL_MOUSEBUTTONUP;
+			e->button.button = SDL_BUTTON_LEFT;
+			oldmouse.buttons = (oldmouse.buttons & ~1) | (mouse.buttons & 1);
+			return 1;
+		}
+		if((down = (mouse.buttons & 4)) != (oldmouse.buttons & 4)){ /* right */
+			e->type = down ? SDL_MOUSEBUTTONDOWN : SDL_MOUSEBUTTONUP;
+			e->button.button = SDL_BUTTON_RIGHT;
+			oldmouse.buttons = (oldmouse.buttons & ~4) | (mouse.buttons & 4);
+			return 1;
+		}
+		if(mouse.buttons & (8|16)){
+			e->type = SDL_MOUSEWHEEL;
+			e->wheel.x = 0;
+			e->wheel.y = (mouse.buttons & 8) ? -1 : 1;
+			return 1;
+		}
+		break;
+
+	case Cresize:
+		forceredraw = 1;
+		if(getwindow(display, Refnone) < 0){
+			fprint(2, "%r\n");
+			/* FIXME do something here? */
+			//threadexitsall(nil);
+		}
+		e->type = SDL_WINDOWEVENT;
+		e->window.event = SDL_WINDOWEVENT_EXPOSED;
+		return 1;
+	}
+
+	return 0;
+}
+
+int
+SDL_PushEvent(SDL_Event *event)
+{
+	/* FIXME does it matter? */
+	USED(event);
+	return -1;
+}
+
+void
+SDL_WarpMouseInWindow(SDL_Window *, int x, int y)
+{
+	moveto(mctl, Pt(screen->r.min.x+x, screen->r.min.y+y));
+}
+
+Uint32
+SDL_GetGlobalMouseState(int *x, int *y)
+{
+	Uint32 b;
+
+	if(x != nil)
+		*x = mouse.xy.x;
+	if(y != nil)
+		*y = mouse.xy.y;
+
+	b = 0;
+	if(mouse.buttons & 1)
+		b |= SDL_BUTTON_LMASK;
+	if(mouse.buttons & 4)
+		b |= SDL_BUTTON_RMASK;
+	/* FIXME no middle button use AT ALL? */
+
+	return b;
+}
+
+Uint32
+SDL_GetMouseState(int *x, int *y)
+{
+	Uint32 b;
+
+	b = SDL_GetGlobalMouseState(nil, nil);
+	if(x != nil)
+		*x = (mouse.xy.x - screen->r.min.x) * logiw / physw;
+	if(y != nil)
+		*y = (mouse.xy.y - screen->r.min.y) * logih / physh;
+
+	return b;
+}
+
+void
+SDL_RenderGetScale(SDL_Renderer *, float *scaleX, float *scaleY)
+{
+	*scaleX = 1.0;
+	*scaleY = 1.0;
+}
+
+void
+SDL_GetWindowSize(SDL_Window *, int *w, int *h)
+{
+	/* no matter what rio decides */
+	*w = physw;
+	*h = physh;
+}
+
+void
+SDL_GetWindowPosition(SDL_Window *, int *x, int *y)
+{
+	*x = screen->r.min.x;
+	*y = screen->r.min.y;
+}
+
+SDL_bool
+SDL_IsTextInputActive(void)
+{
+	return textinput;
+}
+
+void
+SDL_StartTextInput(void)
+{
+	textinput = SDL_TRUE;
+}
+
+void
+SDL_StopTextInput(void)
+{
+	textinput = SDL_FALSE;
+}
+
+void
+SDL_Delay(Uint32 ms)
+{
+	nsleep((uvlong)ms*1000000ULL);
+}
+
+static void *
+resize(u32int *src, int iw, int ih, u32int *dst, int ow, int oh)
+{
+	int i, j, m, n;
+	u32int *d;
+
+	if(iw == ow && ih == oh)
+		return src;
+
+	d = dst;
+	n = ow/iw;
+	for(; ih > 0 && oh > 0; ih--){
+		for(i = j = 0; i < iw; i++, src++)
+			for(m = 0; m < n && j < ow; m++, j++)
+				*dst++ = *src;
+		oh--;
+		for(m = 1; m < n && oh > 0; m++){
+			memmove(dst, dst-j, j*4);
+			dst += j;
+			oh--;
+		}
+	}
+
+	return d;
+}
+
+int
+SDL_RenderCopy(SDL_Renderer *, SDL_Texture *t, SDL_Rect *sre, SDL_Rect *dre)
+{
+	Rectangle sr, dr;
+
+	if(sre != nil){
+		sr.min = Pt(sre->x, sre->y);
+		sr.max = addpt(sr.min, Pt(sre->w, sre->h));
+	}else
+		sr = t->r;
+
+	if(dre != nil){
+		dr.min = Pt(dre->x, dre->y);
+		dr.max = addpt(dr.min, Pt(dre->w, dre->h));
+	}else /* stretch */
+		dr = Rect(0, 0, logiw, logih);
+
+	if(back == nil || Dx(back->r) != logiw || Dy(back->r) != logih){
+		freememimage(back);
+		back = allocmemimage(Rect(0, 0, logiw, logih), XRGB32);
+		if(back == nil){
+			werrstr("SDL_RenderCopy: %r");
+			return -1;
+		}
+		free(backcopy);
+		backcopy = malloc(logiw*logih*4);
+	}
+
+	if(dre == nil)
+		resize((u32int*)byteaddr(t, ZP), Dx(sr), Dy(sr), (u32int*)byteaddr(back, ZP), logiw, logih);
+	else
+		memimagedraw(back, dr, t, sr.min, nil, ZP, S);
+
+	return 0;
+}
+
+void
+SDL_RenderPresent(SDL_Renderer *)
+{
+	Rectangle r, clipr;
+	static u32int *b;
+	uchar *rb;
+
+	if(!forceredraw && (forceredraw = memcmp(backcopy, byteaddr(back, ZP), logiw*logih*4)) == 0 && !mouseredraw)
+		return;
+
+	r = Rect(0, 0, physw, physh);
+	if(front != nil && (Dx(front->r) != physw || Dy(front->r) != physh)){
+		freeimage(front);
+		front = nil;
+		free(b);
+		b = nil;
+	}
+	if(b == nil && (b = realloc(b, physw*physh*4)) == nil){
+		fprint(2, "SDL_RenderPresent: %r\n");
+		return;
+	}
+	if(forceredraw || front == nil){
+		rb = resize((u32int*)byteaddr(back, ZP), Dx(back->r), Dy(back->r), b, physw, physh);
+		if(front == nil && (front = allocimage(display, r, XRGB32, 0, DNofill)) == nil){
+			fprint(2, "SDL_RenderPresent: %r\n");
+			return;
+		}
+		if(loadimage(front, r, rb, Dx(r)*Dy(r)*4) < 0){
+			fprint(2, "SDL_RenderPresent: %r\n");
+			return;
+		}
+	}
+
+	if(cursor != nil && showcursor){
+		r.min = subpt(mouse.xy, cursor->hot);
+		r.max = addpt(r.min, cursor->i->r.max);
+		if(!forceredraw && oldcursor != nil){
+			clipr.min = subpt(oldmouse.xy, oldcursor->hot);
+			clipr.max = addpt(clipr.min, oldcursor->i->r.max);
+			combinerect(&clipr, r);
+			replclipr(screen, 0, clipr);
+		}
+	}
+	draw(screen, screen->r, front, nil, ZP);
+	if(cursor != nil && showcursor)
+		draw(screen, r, cursor->i, cursor->m, ZP);
+	mouseredraw = 0;
+	oldmouse.xy = mouse.xy;
+	oldcursor = cursor;
+
+	flushimage(display, 1);
+
+	if(forceredraw)
+		memmove(backcopy, byteaddr(back, ZP), logiw*logih*4);
+	else
+		replclipr(screen, 0, screen->r);
+	forceredraw = 0;
+}
+
+Uint32
+SDL_GetWindowFlags(SDL_Window *)
+{
+	/* FIXME is this correct? */
+	return SDL_WINDOW_INPUT_FOCUS;
+}
+
+int
+SDL_RenderSetLogicalSize(SDL_Renderer *, int w, int h)
+{
+	if(logiw != w || logih != h){
+		logiw = w;
+		logih = h;
+		forceredraw = 1;
+	}
+
+	return 0;
+}
+
+int
+SDL_GetRendererOutputSize(SDL_Renderer *, int *w, int *h)
+{
+	if(w != nil)
+		*w = logiw;
+	if(h != nil)
+		*h = logih;
+
+	return 0;
+}
+
+void
+SDL_SetWindowSize(SDL_Window *, int w, int h)
+{
+	int f, n;
+
+	if(physw != w || physh != h){
+		physw = w;
+		physh = h;
+		if((f = open("/dev/wctl", OWRITE|OCEXEC)) >= 0){
+			n = fprint(f, "resize -dx %d -dy %d", w+Borderwidth*2, h+Borderwidth*2);
+			close(f);
+			if(n > 0){
+				getwindow(display, Refnone);
+				forceredraw = 1;
+			}
+		}
+	}
+}
+
+int
+SDL_ShowSimpleMessageBox(Uint32, char *title, char *message, SDL_Window *)
+{
+	/* FIXME display a GUI window? */
+	fprint(2, "%s: %s\n", title, message);
+	return 0;
+}
+
+int
+SDL_SetWindowFullscreen(SDL_Window *, Uint32)
+{
+	/* FIXME again, ft2 does NOT check the error code, figure something out */
+	werrstr("SDL_SetWindowFullscreen: not implemented");
+	return -1;
+}
+
+void
+SDL_SetWindowGrab(SDL_Window *, SDL_bool grabbed)
+{
+	/* FIXME not sure if it's worth anything */
+	USED(grabbed);
+}
+
+void
+SDL_SetWindowPosition(SDL_Window *, int x, int y)
+{
+	int f, n;
+
+	if((f = open("/dev/wctl", OWRITE|OCEXEC)) >= 0){
+		n = fprint(f, "move -minx %d -miny %d", x, y);
+		close(f);
+		if(n > 0){
+			getwindow(display, Refnone);
+			forceredraw = 1;
+		}
+	}
+}
+
+int
+SDL_GetDesktopDisplayMode(int displayIndex, SDL_DisplayMode *mode)
+{
+	if(displayIndex != 0)
+		return -1;
+
+	mode->w = physw;
+	mode->h = physh;
+	mode->format = SDL_PIXELFORMAT_ARGB8888;
+	mode->refresh_rate = 0;
+
+	return 0;
+}
+
+void
+SDL_SetWindowTitle(SDL_Window *, char *title)
+{
+	int f;
+
+	if((f = open("/dev/label", OWRITE|OTRUNC|OCEXEC)) >= 0 || (f = open("/mnt/term/dev/label", OWRITE|OTRUNC|OCEXEC)) >= 0){
+		write(f, title, strlen(title));
+		close(f);
+	}
+}
+
+void
+SDL_DestroyTexture(SDL_Texture *t)
+{
+	freememimage(t);
+}
+
+int
+SDL_SetTextureBlendMode(SDL_Texture *, SDL_BlendMode blendMode)
+{
+	if(blendMode != SDL_BLENDMODE_NONE){
+		werrstr("SDL_SetTextureBlendMode: only SDL_BLENDMODE_NONE is supported");
+		return -1;
+	}
+
+	return 0;
+}
+
+SDL_bool
+SDL_SetHint(char *name, char *value)
+{
+	/* FIXME anyone cares about name="SDL_RENDER_SCALE_QUALITY" value="(best|nearest)"? */
+	USED(name);
+	USED(value);
+
+	return SDL_FALSE;
+}
+
+SDL_Window *
+SDL_CreateWindow(char *title, int x, int y, int w, int h, Uint32)
+{
+	SDL_SetWindowTitle(&onewin, title);
+	SDL_SetWindowSize(&onewin, w, h);
+
+	if(x != SDL_WINDOWPOS_UNDEFINED && y != SDL_WINDOWPOS_UNDEFINED){ /* FIXME either of these can be undefined */
+		if(x == SDL_WINDOWPOS_CENTERED)
+			x = display->image->r.min.x + (Dx(display->image->r) - w)/2;
+		if(y == SDL_WINDOWPOS_CENTERED)
+			y = display->image->r.min.y + (Dx(display->image->r) - w)/2;
+		SDL_SetWindowPosition(&onewin, x, y);
+	}
+
+	return &onewin;
+}
+
+SDL_Renderer *
+SDL_CreateRenderer(SDL_Window *, int, Uint32)
+{
+	SDL_RenderSetLogicalSize(nil, physw, physh);
+	return &oneren;
+}
+
+int
+SDL_SetRenderDrawBlendMode(SDL_Renderer *, SDL_BlendMode blendMode)
+{
+	if(blendMode != SDL_BLENDMODE_NONE){
+		werrstr("SDL_SetRenderDrawBlendMode: only SDL_BLENDMODE_NONE is supported");
+		return -1;
+	}
+
+	return 0;
+}
+
+char *
+SDL_GetCurrentVideoDriver(void)
+{
+	return "/dev/draw";
+}
+
+Uint32
+SDL_GetTicks(void)
+{
+	return nanosec()/1000000ULL;
+}
+
+SDL_bool
+SDL_HasClipboardText(void)
+{
+	/* most def */
+	return SDL_TRUE;
+}
+
+void
+SDL_SetThreadPriority(int)
+{
+	/* nothing to do here */
+}
+
+void
+SDL_RestoreWindow(SDL_Window *)
+{
+	/* nothing to do here */
+}
+
+void
+SDL_RaiseWindow(SDL_Window *)
+{
+	/* nothing to do here */
+}
+
+int
+SDL_SetSurfaceRLE(SDL_Surface *, int)
+{
+	/* nothing to do here */
+	return 0;
+}
+
+int
+SDL_SetSurfaceBlendMode(SDL_Surface *, SDL_BlendMode blendMode)
+{
+	if(blendMode != SDL_BLENDMODE_NONE){
+		werrstr("SDL_SetSurfaceBlendMode: only SDL_BLENDMODE_NONE is supported");
+		return -1;
+	}
+
+	return 0;
+}
+
+int
+SDL_LockSurface(SDL_Surface *)
+{
+	/* nothing to do here */
+	return 0;
+}
+
+int
+SDL_UnlockSurface(SDL_Surface *)
+{
+	/* nothing to do here */
+	return 0;
+}
+
+void
+SDL_DestroyRenderer(SDL_Renderer *)
+{
+	/* nothing to do here */
+}
+
+void
+SDL_DestroyWindow(SDL_Window *)
+{
+}
+
+SDL_bool
+SDL_HasSSE(void)
+{
+	/* it's not like we have builtins anyway */
+	return SDL_FALSE;
+}
+
+SDL_bool
+SDL_HasSSE2(void)
+{
+	/* it's not like we have builtins anyway */
+	return SDL_FALSE;
+}
+
+void
+SDL_EnableScreenSaver(void)
+{
+}
+
+int
+SDL_SaveBMP(SDL_Surface *s, const char *file)
+{
+	/* FIXME implement this */
+	USED(s, file);
+
+	return -1;
+}
--- /dev/null
+++ b/signal.h
@@ -1,0 +1,25 @@
+#ifndef _signal_h_
+#define _signal_h_
+
+#include "plan9.h"
+
+enum {
+	SA_RESETHAND = 1<<0, /* not used */
+
+	/* all are treated as SIGSEGV */
+	SIGILL = 4,
+	SIGABRT = 6,
+	SIGFPE = 8,
+	SIGSEGV = 11,
+};
+
+typedef void (*sa_handler)(int);
+
+struct sigaction {
+	sa_handler sa_handler;
+	int sa_flags;
+};
+
+void sigaction(int, struct sigaction *, struct sigaction *);
+
+#endif
--- /dev/null
+++ b/stdarg.h
@@ -1,0 +1,1 @@
+#include "plan9.h"
--- /dev/null
+++ b/stdbool.h
@@ -1,0 +1,6 @@
+#ifndef _stdbool_h_
+#define _stdbool_h_
+
+typedef enum { false, true } bool;
+
+#endif
--- /dev/null
+++ b/stddef.h
@@ -1,0 +1,1 @@
+#include "plan9.h"
--- /dev/null
+++ b/stdint.h
@@ -1,0 +1,21 @@
+#ifndef _stdint_h_
+#define _stdint_h_
+
+#include "plan9.h"
+#include <limits.h>
+
+typedef s8int int8_t;
+typedef u8int uint8_t;
+typedef s16int int16_t;
+typedef u16int uint16_t;
+typedef s32int int32_t;
+typedef u32int uint32_t;
+typedef s64int int64_t;
+typedef u64int uint64_t;
+typedef long ssize_t;
+typedef ulong size_t;
+typedef intptr ptrdiff_t;
+typedef intptr intptr_t;
+typedef uintptr uintptr_t;
+
+#endif
--- /dev/null
+++ b/stdio.h
@@ -1,0 +1,1 @@
+#include "plan9.h"
--- /dev/null
+++ b/stdlib.h
@@ -1,0 +1,8 @@
+#ifndef _stdlib_h_
+#define _stdlib_h_
+
+#include "plan9.h"
+
+#define exit(x) exits(x == 0 ? nil : "error")
+
+#endif
--- /dev/null
+++ b/string.h
@@ -1,0 +1,1 @@
+#include "plan9.h"
--- /dev/null
+++ b/strings.h
@@ -1,0 +1,7 @@
+#ifndef _strings_h_
+#define _strings_h_
+
+#define strcasecmp cistrcmp
+#define strncasecmp cistrncmp
+
+#endif
--- /dev/null
+++ b/sys/stat.h
@@ -1,0 +1,1 @@
+#include "plan9.h"
--- /dev/null
+++ b/sys/time.h
@@ -1,0 +1,1 @@
+#include "plan9.h"
--- /dev/null
+++ b/sys/types.h
@@ -1,0 +1,1 @@
+#include "plan9.h"
--- /dev/null
+++ b/time.h
@@ -1,0 +1,1 @@
+#include "plan9.h"
--- /dev/null
+++ b/unistd.c
@@ -1,0 +1,65 @@
+#include <unistd.h>
+
+#undef getenv
+#undef stat
+
+char *
+getenv9(char *s)
+{
+	static char t[1024];
+
+	snprint(t, sizeof(t), "%s", s = getenv(strcmp(s, "HOME") == 0 ? "home" : s));
+	free(s);
+
+	return t;
+}
+
+int
+stat9(char *filename, struct stat9 *buf)
+{
+	Dir *d;
+
+	if((d = dirstat(filename)) == nil)
+		return -1;
+
+	buf->st_size = d->length;
+	buf->st_mode = d->mode;
+	free(d);
+
+	return 0;
+}
+
+int
+mkdir(char *path, int perm)
+{
+	int f;
+
+	if(access(path, AEXIST) == 0){
+		werrstr("%s: already exists", path);
+		return -1;
+	}
+	if((f = create(path, OREAD, DMDIR|perm)) < 0){
+		werrstr("%s: can't create: %r", path);
+		return -1;
+	}
+	close(f);
+
+	return 0;
+}
+
+int
+rename(char *old, char *new)
+{
+	Dir d;
+
+	nulldir(&d);
+	d.name = new;
+
+	return dirwstat(old, &d) > 0 ? 0 : -1;
+}
+
+void
+usleep(unsigned us)
+{
+	nsleep((uvlong)us*1000ULL);
+}
--- /dev/null
+++ b/unistd.h
@@ -1,0 +1,47 @@
+#ifndef _unistd_h_
+#define _unistd_h_
+
+#include "plan9.h"
+
+enum {
+	S_IFMT = 0xff,
+	S_IFDIR = 1<<0,
+
+	F_OK = AEXIST,
+	R_OK = AREAD,
+	W_OK = AWRITE,
+	X_OK = AEXEC,
+
+	S_ISUID = 04000,
+	S_ISGID = 02000,
+	S_IRWXU = 00700,
+	S_IRUSR = 00400,
+	S_IWUSR = 00200,
+	S_IXUSR = 00100,
+	S_IRWXG = 00070,
+	S_IRGRP = 00040,
+	S_IWGRP = 00020,
+	S_IXGRP = 00010,
+	S_IRWXO = 00007,
+	S_IROTH = 00004,
+	S_IWOTH = 00002,
+	S_IXOTH = 00001,
+};
+
+#define getcwd getwd
+#define getenv getenv9
+#define stat stat9
+
+struct stat9 {
+	uvlong st_size;
+	int st_mode;
+};
+
+char *getenv9(char *s);
+int stat9(char *filename, struct stat9 *buf);
+int mkdir(char *path, int perm);
+int access(char *name, int mode);
+int rename(char *old, char *new);
+void usleep(unsigned us);
+
+#endif
--- /dev/null
+++ b/wchar.h
@@ -1,0 +1,1 @@
+#include "plan9.h"