#include "winpdo-sup.h"
#include <windows.h>
#include <errno.h>
#include <malloc.h>
#include <io.h>
#include <windows.h>
#include <fcntl.h>
#include <sys/stat.h>
#ifndef W_OK
#define W_OK 2
#endif
#define NOT_OUR_FD(fd) (fd < 0 || fd > 2)
int
access (const char *fn, int flags)
{
struct stat s;
if (stat (fn, &s))
return -1;
if (s.st_mode & S_IFDIR)
return 0;
if (flags & W_OK)
{
if (s.st_mode & S_IWRITE)
return 0;
return -1;
}
return 0;
}
int
chdir (const char *dir)
{
int res = SetCurrentDirectory (dir);
return res ? 0 : -1;
}
char *
getcwd (char *buf, size_t len)
{
int res;
if (buf == (char *) 0)
if ((buf = malloc(len)) == (char *) 0)
return (char *) 0;
if ((res = GetCurrentDirectoryA (len, buf)) == 0)
{
errno = ENOENT;
return (char *) 0;
}
if (res >= len)
{
errno = ERANGE;
return (char *) 0;
}
return buf;
}
int
ScreenRows ()
{
CONSOLE_SCREEN_BUFFER_INFO p;
GetConsoleScreenBufferInfo (GetStdHandle(STD_OUTPUT_HANDLE), &p);
return (p.srWindow.Bottom - p.srWindow.Top + 1);
}
int
ScreenCols ()
{
CONSOLE_SCREEN_BUFFER_INFO p;
GetConsoleScreenBufferInfo (GetStdHandle(STD_OUTPUT_HANDLE), &p);
return (p.srWindow.Right - p.srWindow.Left + 1);
}
void
ScreenGetCursor (int *row, int *col)
{
CONSOLE_SCREEN_BUFFER_INFO p;
GetConsoleScreenBufferInfo (GetStdHandle(STD_OUTPUT_HANDLE), &p);
*row = p.dwCursorPosition.Y;
*col = p.dwCursorPosition.X;
}
void
ScreenSetCursor (int row, int col)
{
COORD p;
p.X = col;
p.Y = row;
SetConsoleCursorPosition (GetStdHandle(STD_OUTPUT_HANDLE), p);
}
int
ioctl (int fd, int cmd, void *buf)
{
if (NOT_OUR_FD(fd))
{
errno = EBADF;
return -1;
}
switch (cmd)
{
case TIOCGWINSZ:
{
CONSOLE_SCREEN_BUFFER_INFO info;
HANDLE fdHandle = get_std_handle(fd);
GetConsoleScreenBufferInfo (fdHandle, &info);
((struct winsize *) buf)->ws_row = info.dwSize.Y;
((struct winsize *) buf)->ws_col = info.dwSize.X;
return 0;
}
case TIOCSWINSZ:
return 0;
default:
errno = EINVAL;
return -1;
}
return 0;
}
int kbhit ()
{
INPUT_RECORD i;
unsigned long n;
#if 0
printf ("peek %d\n", PeekConsoleInput (GetStdHandle (STD_INPUT_HANDLE, &i, 1, &n));
#else
PeekConsoleInput (GetStdHandle(STD_INPUT_HANDLE), &i, 1, &n);
#endif
return n;
}
int getkey ()
{
INPUT_RECORD i;
unsigned long n;
do
{
ReadConsoleInput (GetStdHandle(STD_INPUT_HANDLE), &i, 1, &n);
if (i.EventType == KEY_EVENT && i.Event.KeyEvent.bKeyDown)
{
if (i.Event.KeyEvent.uChar.AsciiChar == 0)
switch (i.Event.KeyEvent.wVirtualKeyCode) {
case 35:
i.Event.KeyEvent.uChar.AsciiChar = 'E' - 64;
break;
case 36:
i.Event.KeyEvent.uChar.AsciiChar = 'A' - 64;
break;
case 37:
i.Event.KeyEvent.uChar.AsciiChar = 'B' - 64;
break;
case 38:
i.Event.KeyEvent.uChar.AsciiChar = 'P' - 64;
break;
case 39:
i.Event.KeyEvent.uChar.AsciiChar = 'F' - 64;
break;
case 40:
i.Event.KeyEvent.uChar.AsciiChar = 'N' - 64;
break;
case 46:
i.Event.KeyEvent.uChar.AsciiChar = 'D' - 64;
break;
default:
continue;
}
if (i.Event.KeyEvent.uChar.AsciiChar != 0)
break;
}
} while (1);
return i.Event.KeyEvent.uChar.AsciiChar;
}
#include <signal.h>
#include <process.h>
int
kill (int pid, int sig)
{
if (pid != getpid())
return -1;
if (sig == 0)
return 0;
return raise (sig);
}
int
getuid()
{
return getpid();
}
int
getgid()
{
return getpid();
}
#include <string.h>
void
path_to_real_path(in, out)
char *in;
char *out;
{
strcpy(out, in);
}
void dos_path_to_unix_path_keep_rel(in, out)
char *in;
char *out;
{
strcpy(out, in);
}
void dos_path_to_unix_path(in, out)
char *in;
char *out;
{
strcpy(out, in);
}
void unix_path_to_dos_path_keep_rel(in, out)
char *in;
char *out;
{
strcpy(out, in);
}
void unix_path_to_dos_path(in, out)
char *in;
char *out;
{
strcpy(out, in);
}
static HANDLE
get_std_handle (int fd)
{
DWORD chan[] = {STD_INPUT_HANDLE, STD_OUTPUT_HANDLE, STD_ERROR_HANDLE};
return GetStdHandle(chan[fd]);
}
int
tcsendbreak (int fd, int duration)
{
return 0;
}
int
tcdrain (int fd)
{
return 0;
}
int
tcflush (int fd, int queue)
{
int res = 0;
if (NOT_OUR_FD (fd))
{
errno = EBADF;
res = -1;
}
else
{
HANDLE fdHandle = get_std_handle(fd);
if (queue & (TCOFLUSH | TCIOFLUSH))
{
PurgeComm (fdHandle, PURGE_TXABORT | PURGE_TXCLEAR);
}
if (queue & (TCIFLUSH | TCIOFLUSH))
{
COMMTIMEOUTS old;
COMMTIMEOUTS tmp;
char b;
DWORD more = 1;
int max = 1000;
PurgeComm (fdHandle, PURGE_RXABORT | PURGE_RXCLEAR);
GetCommTimeouts (fdHandle, &old);
memset (&tmp, 0, sizeof (tmp));
tmp.ReadTotalTimeoutConstant = 100;
SetCommTimeouts (fdHandle, &tmp);
while (max > 0 && more)
{
ReadFile (fdHandle, &b, 1, &more, 0);
max--;
}
SetCommTimeouts (fdHandle, &old);
}
}
return res;
}
int
tcflow (int fd, int action)
{
return 0;
}
static void
tdump (int fd)
{
}
static void ds (char *when, DCB *s)
{
}
int
tcsetattr (int fd, int actions, const struct termios *t)
{
int newrate;
int newsize;
COMMTIMEOUTS to;
DCB state;
HANDLE fdHandle;
if (NOT_OUR_FD (fd))
{
errno = EBADF;
return -1;
}
switch (t->c_ospeed)
{
case B110:
newrate = CBR_110;
break;
case B300:
newrate = CBR_300;
break;
case B600:
newrate = CBR_600;
break;
case B1200:
newrate = CBR_1200;
break;
case B2400:
newrate = CBR_2400;
break;
case B4800:
newrate = CBR_4800;
break;
case B9600:
newrate = CBR_9600;
break;
case B19200:
newrate = CBR_19200;
break;
case B38400:
newrate = CBR_38400;
break;
default:
errno = EINVAL;
return -1;
}
switch (t->c_cflag & CSIZE)
{
case CS5:
newsize = 5;
break;
case CS6:
newsize = 6;
break;
case CS7:
newsize = 7;
break;
case CS8:
newsize = 8;
break;
}
fdHandle = get_std_handle(fd);
GetCommState (fdHandle, &state);
ds("First in tcsetattr", &state);
state.BaudRate = newrate;
state.ByteSize = newsize;
state.fBinary = 1;
state.fParity = 0;
state.fOutxCtsFlow = 0;
state.fOutxDsrFlow = 0;
state.fDsrSensitivity = 0;
if (t->c_cflag & PARENB) {
state.Parity = (t->c_cflag & PARODD) ? ODDPARITY:EVENPARITY;
} else {
state.Parity = NOPARITY;
}
ds("Before SetCommState", &state);
SetCommState (fdHandle, &state);
#if 0
h->r_binary = (t->c_iflag & IGNCR) ? 0 : 1;
h->w_binary = (t->c_oflag & ONLCR) ? 0 : 1;
h->vtime = t->c_cc[VTIME];
h->vmin = t->c_cc[VMIN];
#endif
memset (&to, 0, sizeof (to));
#if 0
to.ReadTotalTimeoutConstant = h->vtime * 100;
#endif
SetCommTimeouts (fdHandle, &to);
tdump (fd);
return 0;
}
int
tcgetattr (int fd, struct termios *t)
{
int res = 0;
if (NOT_OUR_FD (fd))
{
errno = EBADF;
res = -1;
}
else
{
DCB state;
int thisspeed;
int thissize;
HANDLE fdHandle = get_std_handle(fd);
GetCommState (fdHandle, &state);
ds("In tcgetattr", &state);
switch (state.BaudRate)
{
case CBR_110:
thisspeed = B110;
break;
case CBR_300:
thisspeed = B300;
break;
case CBR_600:
thisspeed = B600;
break;
case CBR_1200:
thisspeed = B1200;
break;
case CBR_2400:
thisspeed = B2400;
break;
case CBR_4800:
thisspeed = B4800;
break;
case CBR_9600:
thisspeed = B9600;
break;
case CBR_19200:
thisspeed = B19200;
break;
case CBR_38400:
thisspeed = B38400;
break;
default:
thisspeed = B9600;
errno = EINVAL;
}
switch (state.ByteSize)
{
case 5:
thissize = CS5;
break;
case 6:
thissize = CS6;
break;
case 7:
thissize = CS7;
break;
default:
case 8:
thissize = CS8;
break;
}
memset (t, 0, sizeof (*t));
t->c_ospeed = t->c_ispeed = thisspeed;
t->c_cflag |= thissize;
#if 0
if (!h->r_binary)
t->c_iflag |= IGNCR;
if (!h->w_binary)
t->c_oflag |= ONLCR;
t->c_cc[VTIME] = h->vtime ;
t->c_cc[VMIN] = h->vmin;
#endif
}
tdump (fd);
return res;
}
void tcgetpgrp ()
{
}
void tcsetpgrp ()
{
}
void setpgid ()
{
}