text: #include <windows.h>
  #include "u.h"
  #include "lib.h"
  #include "dat.h"
  #include "fns.h"
  #include <libsec.h>
  
  typedef struct Oproc Oproc;
  struct Oproc {
  	int tid;
  	HANDLE	*sema;
  };
  
  static int tlsx = TLS_OUT_OF_INDEXES;
  
  char	*argv0;
  
  Proc*
  _getproc(void)
  {
  	if(tlsx == TLS_OUT_OF_INDEXES)
  		return nil;
  	return TlsGetValue(tlsx);
  }
  
  void
  _setproc(Proc *p)
  {
  	if(tlsx == TLS_OUT_OF_INDEXES){
  		tlsx = TlsAlloc();
  		if(tlsx == TLS_OUT_OF_INDEXES)
  			panic("out of indexes");
  	}
  	TlsSetValue(tlsx, p);
  }
  
  void
  oserror(void)
  {
  	oserrstr();
  	nexterror();
  }
  
  void
  osinit(void)
  {
  	Oproc *t;
  	static Proc firstprocCTstore;
  
  	_setproc(&firstprocCTstore);
  	t = (Oproc*)firstprocCTstore.oproc;
  	assert(t != 0);
  
  	t->tid = GetCurrentThreadId();
  	t->sema = CreateSemaphore(0, 0, 1000, 0);
  	if(t->sema == 0) {
  		oserror();
  		panic("could not create semaphore: %r");
  	}
  }
  
  void
  osnewproc(Proc *p)
  {
  	Oproc *op;
  
  	op = (Oproc*)p->oproc;
  	op->sema = CreateSemaphore(0, 0, 1000, 0);
  	if (op->sema == 0) {
  		oserror();
  		panic("could not create semaphore: %r");
  	}
  }
  
  void
  osmsleep(int ms)
  {
  	Sleep((DWORD) ms);
  }
  
  void
  osyield(void)
  {
  	Sleep(0);
  }
  
  static DWORD WINAPI tramp(LPVOID vp);
  
  void
  osproc(Proc *p)
  {
  	DWORD tid;
  
  	if(CreateThread(0, 0, tramp, p, 0, &tid) == 0) {
  		oserror();
  		panic("osproc: %r");
  	}
  
  	Sleep(0);
  }
  
  static DWORD WINAPI
  tramp(LPVOID vp)
  {
  	Proc *p = (Proc *) vp;
  	Oproc *op = (Oproc*) p->oproc;
  
  	_setproc(p);
  	op->tid = GetCurrentThreadId();
  	op->sema = CreateSemaphore(0, 0, 1000, 0);
  	if(op->sema == 0) {
  		oserror();
  		panic("could not create semaphore: %r");
  	}
  
   	(*p->fn)(p->arg);
  	ExitThread(0);
  	return 0;
  }
  
  void
  procsleep(void)
  {
  	Proc *p;
  	Oproc *op;
  
  	p = up;
  	op = (Oproc*)p->oproc;
  	WaitForSingleObject(op->sema, INFINITE);}
  
  void
  procwakeup(Proc *p)
  {
  	Oproc *op;
  
  	op = (Oproc*)p->oproc;
  	ReleaseSemaphore(op->sema, 1, 0);
  }
  
  void
  random20(uchar *p)
  {
  	LARGE_INTEGER ti;
  	int i, j;
  	FILETIME ft;
  	DigestState ds;
  	vlong tsc;
  	
  	GetSystemTimeAsFileTime(&ft);
  	memset(&ds, 0, sizeof ds);
  	sha1((uchar*)&ft, sizeof(ft), 0, &ds);
  	for(i=0; i<50; i++) {
  		for(j=0; j<10; j++) {
  			QueryPerformanceCounter(&ti);
  			sha1((uchar*)&ti, sizeof(ti), 0, &ds);
  			tsc = GetTickCount();
  			sha1((uchar*)&tsc, sizeof(tsc), 0, &ds);
  		}
  		Sleep(10);
  	}
  	sha1(0, 0, p, &ds);
  }
  
  void
  randominit(void)
  {
  }
  
  ulong
  randomread(void *v, ulong n)
  {
  	int i;
  	uchar p[20];
  	
  	for(i=0; i<n; i+=20){
  		random20(p);
  		if(i+20 <= n)
  			memmove((char*)v+i, p, 20);
  		else
  			memmove((char*)v+i, p, n-i);
  	}
  	return n;
  }
  
  long
  seconds(void)
  {
  	return time(0);
  }
  
  ulong
  ticks(void)
  {
  	return GetTickCount();
  }
  
  #if 0
  uvlong
  fastticks(uvlong *v)
  {
  	uvlong n;
  
  	n = GetTickCount() * 1000 * 1000;
  	if(v)
  		*v = n;
  	return n;
  }
  #endif
  
  extern int	main(int, char*[]);
  
  
  int
  wstrutflen(Rune *s)
  {
  	int n;
  	
  	for(n=0; *s; n+=runelen(*s),s++)
  		;
  	return n;
  }
  
  int
  wstrtoutf(char *s, Rune *t, int n)
  {
  	int i;
  	char *s0;
  
  	s0 = s;
  	if(n <= 0)
  		return wstrutflen(t)+1;
  	while(*t) {
  		if(n < UTFmax+1 && n < runelen(*t)+1) {
  			*s = 0;
  			return s-s0+wstrutflen(t)+1;
  		}
  		i = runetochar(s, t);
  		s += i;
  		n -= i;
  		t++;
  	}
  	*s = 0;
  	return s-s0;
  }
  
  int
  win_hasunicode(void)
  {
  	OSVERSIONINFOA osinfo;
  	int r;
  
  	osinfo.dwOSVersionInfoSize = sizeof(osinfo);
  	if(!GetVersionExA(&osinfo))
  		panic("GetVersionEx failed");
  	switch(osinfo.dwPlatformId) {
  	default:
  		panic("unknown PlatformId");
  	case VER_PLATFORM_WIN32s:
  		panic("Win32s not supported");
  	case VER_PLATFORM_WIN32_WINDOWS:
  		r = 0;
  		break;
  	case VER_PLATFORM_WIN32_NT:
  		r = 1;
  		break;
  	}
  
  	return r;
  }
  
  int
  wstrlen(Rune *s)
  {
  	int n;
  
  	for(n=0; *s; s++,n++)
  		;
  	return n;
  }
  static int	args(char *argv[], int n, char *p);
  
  int APIENTRY
  WinMain(HINSTANCE x, HINSTANCE y, LPSTR z, int w)
  {
  	int argc, n;
  	char *arg, *p, **argv;
  	Rune *warg;
  
  	if(0 && win_hasunicode()){
  		warg = GetCommandLineW();
  		n = (wstrlen(warg)+1)*UTFmax;
  		arg = malloc(n);
  		wstrtoutf(arg, warg, n);
  	}else
  		arg = GetCommandLineA();
  
  	/* conservative guess at the number of args */
  	for(argc=4,p=arg; *p; p++)
  		if(*p == ' ' || *p == '\t')
  			argc++;
  	argv = malloc(argc*sizeof(char*));
  	argc = args(argv, argc, arg);
  
  	mymain(argc, argv);
  	ExitThread(0);
  	return 0;
  }
  
  /*
   * Break the command line into arguments
   * The rules for this are not documented but appear to be the following
   * according to the source for the microsoft C library.
   * Words are seperated by space or tab
   * Words containing a space or tab can be quoted using "
   * 2N backslashes + " ==> N backslashes and end quote
   * 2N+1 backslashes + " ==> N backslashes + literal "
   * N backslashes not followed by " ==> N backslashes
   */
  static int
  args(char *argv[], int n, char *p)
  {
  	char *p2;
  	int i, j, quote, nbs;
  
  	for(i=0; *p && i<n-1; i++) {
  		while(*p == ' ' || *p == '\t')
  			p++;
  		quote = 0;
  		argv[i] = p2 = p;
  		for(;*p; p++) {
  			if(!quote && (*p == ' ' || *p == '\t'))
  				break;
  			for(nbs=0; *p == '\\'; p++,nbs++)
  				;
  			if(*p == '"') {
  				for(j=0; j<(nbs>>1); j++)
  					*p2++ = '\\';
  				if(nbs&1)
  					*p2++ = *p;
  				else
  					quote = !quote;
  			} else {
  				for(j=0; j<nbs; j++)
  					*p2++ = '\\';
  				*p2++ = *p;
  			}
  		}
  		/* move p up one to avoid pointing to null at end of p2 */
  		if(*p)
  			p++;
  		*p2 = 0;	
  	}
  	argv[i] = 0;
  
  	return i;
  }
  /*
   * Windows socket error messages
   * There must be a way to get these strings out of the library.
   * This table is derived from the MSDN online help.
   */
  static struct {
  	int e;
  	char *s;
  } tab[] = {
  	{ 10004, "interrupted function call" },
  	{ 10013, "permission denied" },
  	{ 10014, "bad address" },
  	{ 10022, "invalid argument" },
  	{ 10024, "too many open files" },
  	{ 10035, "resource temporarily unavailable" },
  	{ 10036, "operation now in progress" },
  	{ 10037, "operation already in progress" },
  	{ 10038, "socket operation on nonsocket" },
  	{ 10039, "destination address required" },
  	{ 10040, "message too long" },
  	{ 10041, "protocol wrong type for socket" },
  	{ 10042, "bad protocol option" },
  	{ 10043, "protocol not supported" },
  	{ 10044, "socket type not supported" },
  	{ 10045, "operation not supported" },
  	{ 10046, "protocol family not supported" },
  	{ 10047, "address family not supported by protocol family" },
  	{ 10048, "address already in use" },
  	{ 10049, "cannot assign requested address" },
  	{ 10050, "network is down" },
  	{ 10051, "network is unreachable" },
  	{ 10052, "network dropped connection on reset" },
  	{ 10053, "software caused connection abort" },
  	{ 10054, "connection reset by peer" },
  	{ 10055, "no buffer space available" },
  	{ 10056, "socket is already connected" },
  	{ 10057, "socket is not connected" },
  	{ 10058, "cannot send after socket shutdown" },
  	{ 10060, "connection timed out" },
  	{ 10061, "connection refused" },
  	{ 10064, "host is down" },
  	{ 10065, "no route to host" },
  	{ 10067, "too many processes" },
  	{ 10091, "network subsystem is unavailable" },
  	{ 10092, "winsock.dll version out of range" },
  	{ 10093, "wsastartup not called" },
  	{ 10101, "graceful shutdown in progress" },
  	{ 10109, "class type not found" },
  	{ 11001, "host name not found" },
  	{ 11002, "host not found (non-authoritative)" },
  	{ 11003, "nonrecoverable error" },
  	{ 11004, "valid name, but no data record of requested type" },
  };
  
  void
  osrerrstr(char *buf, uint nbuf)
  {
  	char *p, *q;
  	int e, i, r;
  
  	e = GetLastError();
  	r = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM,
  		0, e, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
  		buf, nbuf, 0);
  	if(r == 0){
  		for(i=0; i<nelem(tab); i++)
  			if(tab[i].e == e){
  				strecpy(buf, buf+nbuf, tab[i].s);
  				break;
  			}
  		if(i==nelem(tab))
  			snprint(buf, nbuf, "windows error %d", e);
  	}
  
  	for(p=q=buf; *p; p++) {
  		if(*p == '\r')
  			continue;
  		if(*p == '\n')
  			*q++ = ' ';
  		else
  			*q++ = *p;
  	}
  	*q = '\0';
  }
  
  void
  oserrstr(void)
  {
  	osrerrstr(up->errstr, ERRMAX);
  }
  
  long
  showfilewrite(char *a, int n)
  {
  	Rune *action, *arg, *cmd, *p;
  	static Rune Lopen[] = { 'o', 'p', 'e', 'n', 0 };
  
  	cmd = runesmprint("%.*s", n, a);
  	if(cmd == nil)
  		error("out of memory");
  	if(cmd[runestrlen(cmd)-1] == '\n')
  		cmd[runestrlen(cmd)] = 0;
  	p = runestrchr(cmd, ' ');
  	if(p){
  		action = cmd;
  		*p++ = 0;
  		arg = p;
  	}else{
  		action = Lopen;
  		arg = cmd;
  	}
  	ShellExecute(0, 0, action, arg, 0, SW_SHOWNORMAL);
  	return n;
  }
  