wince (from <Someone>)
Added support for
Palm-size PC (Windows CE 2.11) and Smartphone 2002.
It works fine under emulation, but it still needs to be tested
on real device. There are also some minor tweaks here and there.
Removed files:
sys/wince/recover.vcp
sys/wince/wince.vcp
New files:
sys/wince/winhcksp.rc
sys/wince/defaults.nh
sys/wince/hpc.vcp
sys/wince/palmpc.vcp
sys/wince/pocketpc.vcp
sys/wince/smartphn.vcp
<Someone>
This commit is contained in:
nethack.allison
@@ -69,120 +69,259 @@ time_t __cdecl time(time_t * timeptr)
|
||||
/* __io.h__ */
|
||||
/* Hack io.h function with stdio.h functions */
|
||||
/* ASSUMPTION : int can hold FILE* */
|
||||
static char _nh_cwd[255];
|
||||
static TCHAR _nh_cwd[MAX_PATH];
|
||||
const int MAGIC_OFFSET=5;
|
||||
#define FILE_TABLE_SIZE 256
|
||||
static HANDLE _nh_file_table[FILE_TABLE_SIZE];
|
||||
static int file_pointer = -1;
|
||||
|
||||
static HANDLE get_file_handle(int i)
|
||||
{
|
||||
i -= MAGIC_OFFSET;
|
||||
if( i>=0 && i<FILE_TABLE_SIZE )
|
||||
return _nh_file_table[i];
|
||||
else
|
||||
return INVALID_HANDLE_VALUE;
|
||||
}
|
||||
|
||||
static int alloc_file_handle(HANDLE h)
|
||||
{
|
||||
int i;
|
||||
if( file_pointer==-1 ) {
|
||||
file_pointer=0;
|
||||
for(i=0; i<FILE_TABLE_SIZE; i++ )
|
||||
_nh_file_table[i] = INVALID_HANDLE_VALUE;
|
||||
}
|
||||
|
||||
i = (file_pointer+1)%FILE_TABLE_SIZE;
|
||||
while(_nh_file_table[i]!=INVALID_HANDLE_VALUE ) {
|
||||
if( i==file_pointer ) {
|
||||
MessageBox(NULL, _T("Ran out of file handles."), _T("Fatal Error"), MB_OK);
|
||||
abort();
|
||||
}
|
||||
i = (i+1) % FILE_TABLE_SIZE;
|
||||
}
|
||||
|
||||
file_pointer = i;
|
||||
_nh_file_table[file_pointer] = h;
|
||||
return file_pointer+MAGIC_OFFSET;
|
||||
}
|
||||
|
||||
int __cdecl close(int f) {
|
||||
FILE* p = (FILE*)f;
|
||||
return fclose(p);
|
||||
int retval;
|
||||
f -= MAGIC_OFFSET;
|
||||
if( f<0 || f>=FILE_TABLE_SIZE ) return -1;
|
||||
retval = (CloseHandle(_nh_file_table[f])? 0 : -1);
|
||||
_nh_file_table[f] = INVALID_HANDLE_VALUE;
|
||||
return retval;
|
||||
}
|
||||
|
||||
int __cdecl creat(const char *fname , int mode)
|
||||
{
|
||||
FILE* f;
|
||||
f = fopen(fname, "w+");
|
||||
if( !f ) return -1;
|
||||
else return (int)f;
|
||||
HANDLE f;
|
||||
TCHAR wbuf[MAX_PATH+1];
|
||||
ZeroMemory(wbuf, sizeof(wbuf));
|
||||
NH_A2W(fname, wbuf, MAX_PATH);
|
||||
|
||||
f = CreateFile(
|
||||
wbuf,
|
||||
GENERIC_READ | GENERIC_WRITE,
|
||||
0,
|
||||
NULL,
|
||||
CREATE_ALWAYS,
|
||||
FILE_ATTRIBUTE_NORMAL,
|
||||
NULL);
|
||||
|
||||
if( f==INVALID_HANDLE_VALUE ) return -1;
|
||||
else return alloc_file_handle(f);
|
||||
}
|
||||
|
||||
int __cdecl eof(int f)
|
||||
{
|
||||
FILE* p = (FILE*)f;
|
||||
return feof(p);
|
||||
DWORD fpos, fsize;
|
||||
HANDLE p = get_file_handle(f);
|
||||
|
||||
if( f==-1 ) return -1;
|
||||
|
||||
fpos = SetFilePointer(p, 0, NULL, FILE_CURRENT);
|
||||
fsize = SetFilePointer(p, 0, NULL, FILE_END);
|
||||
if( fpos==0xFFFFFFFF || fsize==0xFFFFFFFF ) return -1;
|
||||
if( fpos==fsize ) return 1;
|
||||
else {
|
||||
SetFilePointer(p, fpos, NULL, FILE_BEGIN);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
long __cdecl lseek( int handle, long offset, int origin )
|
||||
long __cdecl lseek( int f, long offset, int origin )
|
||||
{
|
||||
FILE* p = (FILE*)handle;
|
||||
if( !fseek(p, offset, origin) ) return ftell(p);
|
||||
else return -1;
|
||||
HANDLE p = get_file_handle(f);
|
||||
DWORD fpos;
|
||||
switch(origin) {
|
||||
case SEEK_SET:
|
||||
fpos = SetFilePointer(p, offset, NULL, FILE_BEGIN);
|
||||
break;
|
||||
case SEEK_CUR:
|
||||
fpos = SetFilePointer(p, offset, NULL, FILE_CURRENT);
|
||||
break;
|
||||
case SEEK_END:
|
||||
fpos = SetFilePointer(p, offset, NULL, FILE_END);
|
||||
break;
|
||||
default:
|
||||
fpos = 0xFFFFFFFF;
|
||||
break;
|
||||
}
|
||||
if( fpos==0xFFFFFFFF ) return -1;
|
||||
else return (long)fpos;
|
||||
}
|
||||
|
||||
int __cdecl open( const char *filename, int oflag, ... )
|
||||
{
|
||||
va_list ap;
|
||||
int pmode;
|
||||
char mode[16];
|
||||
char fname[255];
|
||||
FILE* f;
|
||||
TCHAR fname[MAX_PATH+1];
|
||||
TCHAR path[MAX_PATH+1];
|
||||
HANDLE f;
|
||||
DWORD fileaccess;
|
||||
DWORD filecreate;
|
||||
|
||||
va_start(ap, oflag);
|
||||
pmode = va_arg(ap, int);
|
||||
va_end(ap);
|
||||
/* O_TEXT is not supported */
|
||||
|
||||
ZeroMemory(mode, sizeof(mode));
|
||||
if( (oflag & (O_WRONLY|O_APPEND)) == (O_WRONLY|O_APPEND) ) strcat(mode, "a");
|
||||
else if( (oflag & (O_RDWR | O_APPEND)) == (O_RDWR | O_APPEND) ) strcat(mode, "a+");
|
||||
else if( (oflag & (O_RDWR | O_TRUNC)) == (O_RDWR | O_TRUNC) ) strcat(mode, "w+");
|
||||
else if( (oflag & (O_RDWR | O_CREAT)) == (O_RDWR | O_CREAT) ) strcat(mode, "a+");
|
||||
else if( (oflag & O_RDWR) == O_RDWR ) strcat(mode, "r+");
|
||||
else if( (oflag & O_WRONLY) == O_WRONLY ) strcat(mode, "w");
|
||||
else if( (oflag & O_RDONLY) == O_RDONLY ) strcat(mode, "r");
|
||||
/*
|
||||
* decode the access flags
|
||||
*/
|
||||
switch( oflag & (_O_RDONLY | _O_WRONLY | _O_RDWR) ) {
|
||||
|
||||
if( oflag & O_BINARY ) strcat(mode, "b");
|
||||
if( oflag & O_TEXT ) strcat(mode, "t");
|
||||
case _O_RDONLY: /* read access */
|
||||
fileaccess = GENERIC_READ;
|
||||
break;
|
||||
case _O_WRONLY: /* write access */
|
||||
fileaccess = GENERIC_READ | GENERIC_WRITE;
|
||||
break;
|
||||
case _O_RDWR: /* read and write access */
|
||||
fileaccess = GENERIC_READ | GENERIC_WRITE;
|
||||
break;
|
||||
default: /* error, bad oflag */
|
||||
return -1;
|
||||
}
|
||||
|
||||
fname[0]='\x0';
|
||||
/*
|
||||
* decode open/create method flags
|
||||
*/
|
||||
switch ( oflag & (_O_CREAT | _O_EXCL | _O_TRUNC) ) {
|
||||
case 0:
|
||||
case _O_EXCL: // ignore EXCL w/o CREAT
|
||||
filecreate = OPEN_EXISTING;
|
||||
break;
|
||||
|
||||
case _O_CREAT:
|
||||
filecreate = OPEN_ALWAYS;
|
||||
break;
|
||||
|
||||
case _O_CREAT | _O_EXCL:
|
||||
case _O_CREAT | _O_TRUNC | _O_EXCL:
|
||||
filecreate = CREATE_NEW;
|
||||
break;
|
||||
|
||||
case _O_TRUNC:
|
||||
case _O_TRUNC | _O_EXCL: // ignore EXCL w/o CREAT
|
||||
filecreate = TRUNCATE_EXISTING;
|
||||
break;
|
||||
|
||||
case _O_CREAT | _O_TRUNC:
|
||||
filecreate = CREATE_ALWAYS;
|
||||
break;
|
||||
|
||||
default:
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* assemple the file name */
|
||||
ZeroMemory(fname, sizeof(fname));
|
||||
ZeroMemory(path, sizeof(path));
|
||||
NH_A2W(filename, fname, MAX_PATH);
|
||||
if( *filename!='\\' && *filename!='/' ) {
|
||||
strncat(fname, _nh_cwd, sizeof(fname));
|
||||
strncat(fname, "\\", sizeof(fname) - strlen(fname));
|
||||
_tcscpy(path, _nh_cwd);
|
||||
_tcsncat(path, _T("\\"), MAX_PATH - _tcslen(path));
|
||||
}
|
||||
strncat(fname, filename, sizeof(fname) - strlen(fname));
|
||||
_tcsncat(path, fname, MAX_PATH - _tcslen(path));
|
||||
|
||||
f = fopen(fname, mode);
|
||||
if( !f ) return -1;
|
||||
else {
|
||||
if( !(oflag & O_APPEND) ) fseek(f, SEEK_SET, 0);
|
||||
return (int)f;
|
||||
}
|
||||
/*
|
||||
* try to open/create the file
|
||||
*/
|
||||
if ( (f = CreateFile( path,
|
||||
fileaccess,
|
||||
0,
|
||||
NULL,
|
||||
filecreate,
|
||||
FILE_ATTRIBUTE_NORMAL,
|
||||
NULL ))
|
||||
== INVALID_HANDLE_VALUE )
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
|
||||
if( !(oflag & O_APPEND) ) SetFilePointer(f, 0, NULL, FILE_BEGIN);
|
||||
return alloc_file_handle(f);
|
||||
}
|
||||
|
||||
int __cdecl read( int handle, void *buffer, unsigned int count )
|
||||
int __cdecl read( int f, void *buffer, unsigned int count )
|
||||
{
|
||||
FILE* p = (FILE*)handle;
|
||||
return fread(buffer, 1, count, p);
|
||||
HANDLE p = get_file_handle(f);
|
||||
DWORD bytes_read;
|
||||
if( !ReadFile(p, buffer, count, &bytes_read, NULL) )
|
||||
return -1;
|
||||
else
|
||||
return (int)bytes_read;
|
||||
}
|
||||
|
||||
int __cdecl unlink(const char * filename)
|
||||
{
|
||||
TCHAR wbuf[NHSTR_BUFSIZE];
|
||||
char fname[255];
|
||||
|
||||
fname[0]='\x0';
|
||||
TCHAR wbuf[MAX_PATH+1];
|
||||
TCHAR fname[MAX_PATH+1];
|
||||
|
||||
ZeroMemory(wbuf, sizeof(wbuf));
|
||||
ZeroMemory(fname, sizeof(fname));
|
||||
NH_A2W(filename, wbuf, MAX_PATH);
|
||||
if( *filename!='\\' && *filename!='/' ) {
|
||||
strncat(fname, _nh_cwd, sizeof(fname));
|
||||
strncat(fname, "\\", sizeof(fname) - strlen(fname));
|
||||
_tcscpy(fname, _nh_cwd);
|
||||
_tcsncat(fname, _T("\\"), MAX_PATH - _tcslen(fname));
|
||||
}
|
||||
strncat(fname, filename, sizeof(fname) - strlen(fname));
|
||||
_tcsncat(fname, wbuf, MAX_PATH - _tcslen(fname));
|
||||
|
||||
return !DeleteFileW(NH_A2W(fname, wbuf, NHSTR_BUFSIZE));
|
||||
return !DeleteFileW(fname);
|
||||
}
|
||||
|
||||
int __cdecl write( int handle, const void *buffer, unsigned int count )
|
||||
int __cdecl write( int f, const void *buffer, unsigned int count )
|
||||
{
|
||||
FILE* p = (FILE*)handle;
|
||||
return fwrite(buffer, 1, count, p);
|
||||
HANDLE p = get_file_handle(f);
|
||||
DWORD bytes_written;
|
||||
if( !WriteFile(p, buffer, count, &bytes_written, NULL) )
|
||||
return -1;
|
||||
else
|
||||
return (int)bytes_written;
|
||||
}
|
||||
|
||||
int __cdecl rename( const char *oldname, const char *newname )
|
||||
{
|
||||
WCHAR f1[255];
|
||||
WCHAR f2[255];
|
||||
MultiByteToWideChar(CP_ACP, 0, oldname, -1, f1, 255);
|
||||
MultiByteToWideChar(CP_ACP, 0, newname, -1, f2, 255);
|
||||
WCHAR f1[MAX_PATH+1];
|
||||
WCHAR f2[MAX_PATH+1];
|
||||
ZeroMemory(f1, sizeof(f1));
|
||||
ZeroMemory(f2, sizeof(f2));
|
||||
MultiByteToWideChar(CP_ACP, 0, oldname, -1, f1, MAX_PATH);
|
||||
MultiByteToWideChar(CP_ACP, 0, newname, -1, f2, MAX_PATH);
|
||||
return !MoveFile(f1, f2);
|
||||
}
|
||||
|
||||
int chdir( const char *dirname )
|
||||
{
|
||||
ZeroMemory(_nh_cwd, sizeof(_nh_cwd));
|
||||
strncpy(_nh_cwd, dirname, sizeof(_nh_cwd)-1);
|
||||
NH_A2W(dirname, _nh_cwd, MAX_PATH);
|
||||
return 0;
|
||||
}
|
||||
|
||||
char *getcwd( char *buffer, int maxlen )
|
||||
{
|
||||
if( maxlen<(int)strlen(_nh_cwd) ) return NULL;
|
||||
else return strcpy(buffer, _nh_cwd);
|
||||
if( maxlen<(int)_tcslen(_nh_cwd) ) return NULL;
|
||||
else return NH_W2A(_nh_cwd, buffer, maxlen);
|
||||
}
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
@@ -226,7 +365,7 @@ int isatty(int f)
|
||||
}
|
||||
|
||||
|
||||
#ifdef WIN_CE_2xx
|
||||
#if defined(WIN_CE_PS2xx) || defined(WIN32_PLATFORM_HPCPRO)
|
||||
int __cdecl isupper(int c)
|
||||
{
|
||||
char str[2];
|
||||
@@ -243,6 +382,13 @@ int __cdecl isdigit(int c)
|
||||
return ('0' <= c && c <= '9');
|
||||
}
|
||||
|
||||
int __cdecl isxdigit(int c)
|
||||
{
|
||||
return (('0' <= c && c <= '9') ||
|
||||
('a' <= c && c <= 'f') ||
|
||||
('A' <= c && c <= 'F'));
|
||||
}
|
||||
|
||||
int __cdecl isspace(int c)
|
||||
{
|
||||
char str[2];
|
||||
@@ -286,4 +432,377 @@ int __cdecl _stricmp(const char* a, const char* b)
|
||||
return strncmpi(a, b, 65535u);
|
||||
}
|
||||
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if defined(WIN_CE_PS2xx)
|
||||
/* stdio.h functions are missing from PAlm Size PC SDK 1.2 (SH3 and MIPS) */
|
||||
|
||||
#pragma warning(disable:4273)
|
||||
|
||||
FILE * __cdecl fopen(const char* filename, const char *mode)
|
||||
{
|
||||
int modeflag;
|
||||
int whileflag;
|
||||
int filedes;
|
||||
|
||||
/* First mode character must be 'r', 'w', or 'a'. */
|
||||
switch (*mode) {
|
||||
case 'r':
|
||||
modeflag = _O_RDONLY;
|
||||
break;
|
||||
case 'w':
|
||||
modeflag = _O_WRONLY | _O_CREAT | _O_TRUNC;
|
||||
break;
|
||||
case 'a':
|
||||
modeflag = _O_WRONLY | _O_CREAT | _O_APPEND;
|
||||
break;
|
||||
default:
|
||||
return NULL;
|
||||
}
|
||||
|
||||
whileflag=1;
|
||||
while(*++mode && whileflag)
|
||||
switch(*mode) {
|
||||
|
||||
case '+':
|
||||
if (modeflag & _O_RDWR)
|
||||
whileflag=0;
|
||||
else {
|
||||
modeflag |= _O_RDWR;
|
||||
modeflag &= ~(_O_RDONLY | _O_WRONLY);
|
||||
}
|
||||
break;
|
||||
|
||||
case 'b':
|
||||
if (modeflag & (_O_TEXT | _O_BINARY))
|
||||
whileflag=0;
|
||||
else
|
||||
modeflag |= _O_BINARY;
|
||||
break;
|
||||
|
||||
case 't': /* not supported */
|
||||
whileflag=0;
|
||||
break;
|
||||
|
||||
default:
|
||||
whileflag=0;
|
||||
break;
|
||||
}
|
||||
|
||||
if ((filedes = open(filename, modeflag))==-1) return NULL;
|
||||
|
||||
return (FILE*)filedes;
|
||||
}
|
||||
|
||||
int __cdecl fscanf(FILE *f , const char *format, ...)
|
||||
{
|
||||
/* Format spec: %[*] [width] [l] type ] */
|
||||
int ch;
|
||||
int sch;
|
||||
int matched = 0;
|
||||
int width = 65535;
|
||||
int modifier = -1;
|
||||
int skip_flag = 0;
|
||||
int n_read = 0;
|
||||
char buf[BUFSZ];
|
||||
TCHAR wbuf[BUFSZ];
|
||||
char* p;
|
||||
va_list args;
|
||||
|
||||
#define RETURN_SCANF(i) { va_end(args); return i; }
|
||||
#define NEXT_CHAR(f) (n_read++, fgetc(f))
|
||||
|
||||
va_start(args, format);
|
||||
|
||||
ch = *format++;
|
||||
sch = NEXT_CHAR(f);
|
||||
while( ch && sch!=EOF ) {
|
||||
if( isspace(ch) ) {
|
||||
while( ch && isspace(ch) ) ch = *format++;
|
||||
while( sch!=EOF && isspace(sch) ) sch = NEXT_CHAR(f);
|
||||
format--;
|
||||
goto next_spec;
|
||||
}
|
||||
|
||||
/* read % */
|
||||
if( ch!='%' ) {
|
||||
if( sch!=ch ) RETURN_SCANF(matched);
|
||||
sch = NEXT_CHAR(f);
|
||||
goto next_spec;
|
||||
} else {
|
||||
/* process '%%' */
|
||||
ch = *format++;
|
||||
if( ch=='%' ) {
|
||||
if( sch!='%' ) RETURN_SCANF(matched);
|
||||
sch = NEXT_CHAR(f);
|
||||
goto next_spec;
|
||||
}
|
||||
|
||||
if( ch=='*' ) {
|
||||
/* read skip flag - '*' */
|
||||
skip_flag=1;
|
||||
ch = *format++;
|
||||
}
|
||||
|
||||
/* get width */
|
||||
if( isdigit(ch) ) {
|
||||
width = 0;
|
||||
while(ch && isdigit(ch)) {
|
||||
width = width*10 + (ch-'0');
|
||||
ch = *format++;
|
||||
}
|
||||
}
|
||||
|
||||
/* get modifier */
|
||||
if( ch=='l' ) {
|
||||
modifier = 'l';
|
||||
ch = *format++;
|
||||
}
|
||||
|
||||
/* get type */
|
||||
switch(ch) {
|
||||
case 'c':
|
||||
if( !skip_flag ) {
|
||||
*(va_arg(args, char*))=sch;
|
||||
matched++;
|
||||
}
|
||||
sch = NEXT_CHAR(f);
|
||||
goto next_spec;
|
||||
case 'd':
|
||||
p = buf;
|
||||
/* skip space */
|
||||
while(sch!=EOF && isspace(sch)) sch=NEXT_CHAR(f);
|
||||
while(sch!=EOF && isdigit(sch) && --width>=0) { *p++ = sch; sch=NEXT_CHAR(f); }
|
||||
*p = '\x0';
|
||||
if( !skip_flag ) {
|
||||
matched++;
|
||||
if( modifier=='l' ) {
|
||||
*(va_arg(args, long*))=wcstol(NH_A2W(buf, wbuf, BUFSZ), NULL, 10);
|
||||
} else {
|
||||
*(va_arg(args, int*))=wcstol(NH_A2W(buf, wbuf, BUFSZ), NULL, 10);
|
||||
}
|
||||
}
|
||||
goto next_spec;
|
||||
case 'x':
|
||||
p = buf;
|
||||
while(sch!=EOF && isspace(sch)) sch=NEXT_CHAR(f);
|
||||
while(sch!=EOF && isxdigit(sch) && --width>=0) { *p++ = sch; sch=NEXT_CHAR(f); }
|
||||
*p = '\x0';
|
||||
if( !skip_flag ) {
|
||||
matched++;
|
||||
if( modifier=='l' ) {
|
||||
*(va_arg(args, long*))=wcstol(NH_A2W(buf, wbuf, BUFSZ), NULL, 16);
|
||||
} else {
|
||||
*(va_arg(args, int*))=wcstol(NH_A2W(buf, wbuf, BUFSZ), NULL, 16);
|
||||
}
|
||||
}
|
||||
goto next_spec;
|
||||
case 'n':
|
||||
*(va_arg(args, int*)) = n_read;
|
||||
matched++;
|
||||
goto next_spec;
|
||||
case 's':
|
||||
if( skip_flag ) {
|
||||
while(sch!=EOF && !isspace(sch) && --width>=0) { sch=NEXT_CHAR(f); }
|
||||
} else {
|
||||
p = va_arg(args, char*);
|
||||
while(sch!=EOF && !isspace(sch) && --width>=0) { *p++ = sch; sch=NEXT_CHAR(f); }
|
||||
*p = '\x0';
|
||||
matched++;
|
||||
}
|
||||
goto next_spec;
|
||||
case '[': {
|
||||
char pattern[256];
|
||||
int start, end;
|
||||
int negate;
|
||||
|
||||
ZeroMemory(pattern, sizeof(pattern));
|
||||
p = pattern;
|
||||
|
||||
/* try to parse '^' modifier */
|
||||
ch = *format++;
|
||||
if( ch=='^' ) { negate=1; ch=*format++; }
|
||||
else { negate=0; }
|
||||
if( ch==0 ) RETURN_SCANF(EOF);
|
||||
|
||||
for( ; ch && ch!=']'; ch = *format++ ) {
|
||||
/* try to parse range: a-z */
|
||||
if( format[0]=='-' &&
|
||||
format[1] && format[1]!=']' ) {
|
||||
start = ch;
|
||||
format++;
|
||||
end = *format++;
|
||||
while(start<=end) {
|
||||
if(!strchr(pattern, (char)start))
|
||||
*p++ = (char)start;
|
||||
start++;
|
||||
}
|
||||
} else {
|
||||
if(!strchr(pattern, (char)ch)) *p++ = (char)ch;
|
||||
}
|
||||
}
|
||||
|
||||
if( skip_flag ) {
|
||||
while(sch!=EOF && strchr(pattern, sch) && --width>=0) { sch=NEXT_CHAR(f); }
|
||||
} else {
|
||||
p = va_arg(args, char*);
|
||||
if( negate )
|
||||
while(sch!=EOF && !strchr(pattern, sch) && --width>=0) { *p++ = sch; sch=NEXT_CHAR(f); }
|
||||
else
|
||||
while(sch!=EOF && strchr(pattern, sch) && --width>=0) { *p++ = sch; sch=NEXT_CHAR(f); }
|
||||
*p = '\x0';
|
||||
matched++;
|
||||
}
|
||||
} goto next_spec;
|
||||
default:
|
||||
RETURN_SCANF(EOF);
|
||||
}
|
||||
}
|
||||
|
||||
next_spec:
|
||||
width = 65535;
|
||||
modifier = -1;
|
||||
skip_flag = 0;
|
||||
ch = *format++;
|
||||
}
|
||||
fseek(f, -1, SEEK_CUR);
|
||||
RETURN_SCANF(matched);
|
||||
|
||||
#undef RETURN_SCANF
|
||||
#undef NEXT_CHAR
|
||||
}
|
||||
|
||||
int __cdecl fprintf(FILE *f , const char *format, ...)
|
||||
{
|
||||
int retval;
|
||||
va_list args;
|
||||
|
||||
if( !f || !format ) return 0;
|
||||
|
||||
va_start(args, format);
|
||||
retval = vfprintf(f, format, args);
|
||||
va_end(args);
|
||||
|
||||
return retval;
|
||||
}
|
||||
|
||||
int __cdecl vfprintf(FILE* f, const char *format, va_list args)
|
||||
{
|
||||
char buf[4096];
|
||||
int retval;
|
||||
|
||||
if( !f || !format ) return 0;
|
||||
|
||||
retval = vsprintf(buf, format, args);
|
||||
|
||||
write((int)f, buf, strlen(buf));
|
||||
|
||||
return retval;
|
||||
}
|
||||
|
||||
int __cdecl fgetc(FILE * f)
|
||||
{
|
||||
char c;
|
||||
int fh = (int)f;
|
||||
|
||||
if( !f ) return EOF;
|
||||
if( read(fh, &c, 1)==1 ) return c;
|
||||
else return EOF;
|
||||
}
|
||||
|
||||
char * __cdecl fgets(char *s, int size, FILE *f)
|
||||
{
|
||||
/* not the best performance but it will do for now...*/
|
||||
char c;
|
||||
if( !f || !s || size==0 ) return NULL;
|
||||
while( --size>0 ) {
|
||||
if( (c = fgetc(f))==EOF ) return NULL;
|
||||
|
||||
*s++ = c;
|
||||
if( c=='\n' ) break;
|
||||
}
|
||||
*s = '\x0';
|
||||
return s;
|
||||
}
|
||||
|
||||
int __cdecl printf(const char *format, ...)
|
||||
{
|
||||
int retval;
|
||||
va_list args;
|
||||
|
||||
if( !format ) return 0;
|
||||
|
||||
va_start(args, format);
|
||||
retval = vprintf(format, args);
|
||||
va_end(args);
|
||||
|
||||
return retval;
|
||||
}
|
||||
|
||||
int __cdecl vprintf(const char *format, va_list args)
|
||||
{
|
||||
char buf[4096];
|
||||
int retval;
|
||||
|
||||
retval = vsprintf(buf, format, args);
|
||||
puts(buf);
|
||||
return retval;
|
||||
}
|
||||
|
||||
// int __cdecl putchar(int);
|
||||
int __cdecl puts(const char * s)
|
||||
{
|
||||
TCHAR wbuf[4096];
|
||||
NH_A2W(s, wbuf, 4096);
|
||||
MessageBox(NULL, wbuf, _T("stdout"), MB_OK);
|
||||
return 0;
|
||||
}
|
||||
|
||||
FILE* __cdecl _getstdfilex(int desc)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int __cdecl fclose(FILE * f)
|
||||
{
|
||||
if(!f) return EOF;
|
||||
return close((int)f)==-1? EOF : 0;
|
||||
}
|
||||
|
||||
size_t __cdecl fread(void *p, size_t size, size_t count, FILE *f)
|
||||
{
|
||||
int read_bytes;
|
||||
if(!f || !p || size==0 || count==0) return 0;
|
||||
read_bytes = read((int)f, p, size*count);
|
||||
return read_bytes>0? (read_bytes/size) : 0;
|
||||
}
|
||||
|
||||
size_t __cdecl fwrite(const void *p, size_t size, size_t count, FILE * f)
|
||||
{
|
||||
int write_bytes;
|
||||
if(!f || !p || size==0 || count==0) return 0;
|
||||
write_bytes = write((int)f, p, size*count);
|
||||
return write_bytes>0? write_bytes/size : 0;
|
||||
}
|
||||
|
||||
int __cdecl fflush(FILE *f)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
int __cdecl feof(FILE *f)
|
||||
{
|
||||
return (f && eof((int)f)==0)? 0 : 1;
|
||||
}
|
||||
|
||||
int __cdecl fseek(FILE *f, long offset, int from)
|
||||
{
|
||||
return (f && lseek((int)f, offset, from)>=0)? 0 : 1;
|
||||
}
|
||||
|
||||
long __cdecl ftell(FILE * f)
|
||||
{
|
||||
return f? lseek((int)f, 0, SEEK_CUR) : -1;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
Reference in New Issue
Block a user