Subversion Repositories Kolibri OS

Compare Revisions

Regard whitespace Rev 299 → Rev 300

/programs/games/doom/trunk/d_main.c
633,8 → 633,8
 
char *home;
char *doomwaddir;
doomwaddir = getenv("DOOMWADDIR");
if (!doomwaddir)
// doomwaddir = getenv("DOOMWADDIR");
// if (!doomwaddir)
doomwaddir = ".";
 
// Commercial.
666,8 → 666,8
doom2fwad = malloc(strlen(doomwaddir)+1+10+1);
sprintf(doom2fwad, "%s/doom2f.wad", doomwaddir);
 
home = getenv("HOME");
if (!home)
// home = getenv("HOME");
// if (!home)
home = ".";
sprintf(basedefault, "%s/doomrc.txt", home);
 
861,7 → 861,7
 
// I_BeginSplash();
 
setbuf (stdout, NULL);
// setbuf (stdout, NULL);
modifiedgame = false;
nomonsters = M_CheckParm ("-nomonsters");
1102,15 → 1102,15
// Iff additonal PWAD files are used, print modified banner
if (modifiedgame)
{
// __libclog_printf (
// "===========================================================================\n"
// "ATTENTION: This version of DOOM has been modified. If you would like to\n"
// "get a copy of the original game, call 1-800-IDGAMES or see the readme file.\n"
// " You will not receive technical support for modified games.\n"
// " press enter to continue\n"
// "===========================================================================\n"
// );
getchar ();
printf (
"===========================================================================\n"
"ATTENTION: This version of DOOM has been modified. If you would like to\n"
"get a copy of the original game, call 1-800-IDGAMES or see the readme file.\n"
" You will not receive technical support for modified games.\n"
" press enter to continue\n"
"===========================================================================\n"
);
// getchar ();
}
 
1119,21 → 1119,21
{
case shareware:
case indetermined:
// __libclog_printf (
// "===========================================================================\n"
// " Shareware!\n"
// "===========================================================================\n"
// );
printf (
"===========================================================================\n"
" Shareware!\n"
"===========================================================================\n"
);
break;
case registered:
case retail:
case commercial:
// __libclog_printf (
// "===========================================================================\n"
// " Commercial product - do not distribute!\n"
// " Please report software piracy to the SPA: 1-800-388-PIR8\n"
// "===========================================================================\n"
// );
printf (
"===========================================================================\n"
" Commercial product - do not distribute!\n"
" Please report software piracy to the SPA: 1-800-388-PIR8\n"
"===========================================================================\n"
);
break;
default:
1141,30 → 1141,30
break;
}
 
// __libclog_printf ("M_Init: Init miscellaneous info.\n");
printf ("M_Init: Init miscellaneous info.\n");
M_Init ();
 
// __libclog_printf ("R_Init: Init DOOM refresh daemon - ");
printf ("R_Init: Init DOOM refresh daemon - ");
R_Init ();
 
// __libclog_printf ("\nP_Init: Init Playloop state.\n");
printf ("\nP_Init: Init Playloop state.\n");
P_Init ();
 
// __libclog_printf ("I_Init: Setting up machine state.\n");
printf ("I_Init: Setting up machine state.\n");
I_Init ();
 
// __libclog_printf ("D_CheckNetGame: Checking network game status.\n");
printf ("D_CheckNetGame: Checking network game status.\n");
D_CheckNetGame ();
 
// __libclog_printf ("S_Init: Setting up sound.\n");
printf ("S_Init: Setting up sound.\n");
S_Init (snd_SfxVolume /* *8 */, snd_MusicVolume /* *8*/ );
 
// __libclog_printf ("HU_Init: Setting up heads up display.\n");
printf ("HU_Init: Setting up heads up display.\n");
HU_Init ();
 
// I_EndSplash();
 
// __libclog_printf ("ST_Init: Init status bar.\n");
printf ("ST_Init: Init status bar.\n");
ST_Init ();
 
// check for a driver that wants intermission stats
/programs/games/doom/trunk/d_net.c
139,10 → 139,7
//
// HSendPacket
//
void
HSendPacket
(int node,
int flags )
void HSendPacket (int node,int flags )
{
netbuffer->checksum = NetbufferChecksum () | flags;
 
172,14 → 169,14
else
realretrans = -1;
 
fprintf (debugfile,"send (%i + %i, R %i) [%i] ",
printf ("send (%i + %i, R %i) [%i] ",
ExpandTics(netbuffer->starttic),
netbuffer->numtics, realretrans, doomcom->datalength);
for (i=0 ; i<doomcom->datalength ; i++)
fprintf (debugfile,"%i ",((byte *)netbuffer)[i]);
printf ("%i ",((byte *)netbuffer)[i]);
 
fprintf (debugfile,"\n");
printf ("\n");
}
 
I_NetCmd ();
214,7 → 211,7
if (doomcom->datalength != NetbufferSize ())
{
if (debugfile)
fprintf (debugfile,"bad packet length %i\n",doomcom->datalength);
printf ("bad packet length %i\n",doomcom->datalength);
return false;
}
221,7 → 218,7
if (NetbufferChecksum () != (netbuffer->checksum&NCMD_CHECKSUM) )
{
if (debugfile)
fprintf (debugfile,"bad packet checksum\n");
printf ("bad packet checksum\n");
return false;
}
 
231,7 → 228,7
int i;
if (netbuffer->checksum & NCMD_SETUP)
fprintf (debugfile,"setup packet\n");
printf ("setup packet\n");
else
{
if (netbuffer->checksum & NCMD_RETRANSMIT)
239,14 → 236,14
else
realretrans = -1;
fprintf (debugfile,"get %i = (%i + %i, R %i)[%i] ",
printf ("get %i = (%i + %i, R %i)[%i] ",
doomcom->remotenode,
ExpandTics(netbuffer->starttic),
netbuffer->numtics, realretrans, doomcom->datalength);
 
for (i=0 ; i<doomcom->datalength ; i++)
fprintf (debugfile,"%i ",((byte *)netbuffer)[i]);
fprintf (debugfile,"\n");
printf ("%i ",((byte *)netbuffer)[i]);
printf ("\n");
}
}
return true;
306,7 → 303,7
{
resendto[netnode] = ExpandTics(netbuffer->retransmitfrom);
if (debugfile)
fprintf (debugfile,"retransmit from %i\n", resendto[netnode]);
printf ("retransmit from %i\n", resendto[netnode]);
resendcount[netnode] = RESENDCOUNT;
}
else
319,8 → 316,7
if (realend < nettics[netnode])
{
if (debugfile)
fprintf (debugfile,
"out of order packet (%i + %i)\n" ,
printf ("out of order packet (%i + %i)\n" ,
realstart,netbuffer->numtics);
continue;
}
330,8 → 326,7
{
// stop processing until the other system resends the missed tics
if (debugfile)
fprintf (debugfile,
"missed tics from %i (%i - %i)\n",
printf ("missed tics from %i (%i - %i)\n",
netnode, realstart, nettics[netnode]);
remoteresend[netnode] = true;
continue;
/programs/games/doom/trunk/i_sound.c
552,7 → 552,7
int i;
// FIXME (below).
printf( stderr, "I_ShutdownSound: NOT finishing pending sounds\n");
printf( "I_ShutdownSound: NOT finishing pending sounds\n");
while ( !done )
{
568,7 → 568,7
void I_InitSound()
{ int i;
 
printf( stderr, "I_InitSound: ");
printf("I_InitSound: ");
for (i=1 ; i<NUMSFX ; i++)
{
586,7 → 586,7
}
}
 
printf( stderr, " pre-cached all sound data\n");
printf( " pre-cached all sound data\n");
// Now initialize mixbuffer with zero.
for ( i = 0; i< MIXBUFFERSIZE; i++ )
593,7 → 593,7
mixbuffer[i] = 0;
// Finished initialization.
printf(stderr, "I_InitSound: sound module ready\n");
printf("I_InitSound: sound module ready\n");
}
 
/programs/games/doom/trunk/i_system.c
39,6 → 39,7
 
 
#include "i_system.h"
#include "kolibri.h"
 
int mb_used = 6;
 
81,7 → 82,7
byte* I_ZoneBase (int* size)
{
*size = mb_used*1024*1024;
return (byte *) _aligned_malloc(*size, 128);;
return (byte *) UserAlloc(*size);
}
 
 
169,8 → 170,8
// Message first.
va_start (argptr,error);
printf ("Error: ");
printf (error,argptr);
printf (stderr, "\n");
printf (argptr);
printf ("\n");
va_end (argptr);
 
// Shutdown. Here might be other errors.
179,6 → 180,6
 
D_QuitNetGame ();
I_ShutdownGraphics();
getch();
// getch();
exit(-1);
}
/programs/games/doom/trunk/i_video.c
493,30 → 493,30
UpdateWindow(win);
 
GetClientRect(win, &rect);
fprintf(stderr, "I_InitGraphics: Client area: %ux%u\n",
printf("I_InitGraphics: Client area: %ux%u\n",
rect.right-rect.left, rect.bottom-rect.top);
 
if ( (rect.right-rect.left) != X_width )
{
fprintf(stderr, "I_InitGraphics: Fixing width\n");
printf("I_InitGraphics: Fixing width\n");
width += X_width - (rect.right-rect.left);
MoveWindow(win, 0, 0, width, height, TRUE);
}
if ( (rect.bottom-rect.top) != X_height )
{
fprintf(stderr, "I_InitGraphics: Fixing height\n");
printf("I_InitGraphics: Fixing height\n");
height += X_height - (rect.bottom-rect.top);
MoveWindow(win, 0, 0, width, height, TRUE);
}
 
GetClientRect(win, &rect);
fprintf(stderr, "I_InitGraphics: Client area: %ux%u\n",
printf("I_InitGraphics: Client area: %ux%u\n",
rect.right-rect.left, rect.bottom-rect.top);
dibDC = GetDC(win);
BPP=1;
bits = 8; //GetDeviceCaps(dibDC, BITSPIXEL);
fprintf(stderr, "I_InitGraphics: %i bpp screen\n", bits);
printf("I_InitGraphics: %i bpp screen\n", bits);
 
if ( BPP == 1 )
bminfo = malloc(sizeof(BITMAPINFOHEADER) + 4*256);
606,7 → 606,7
ClipCursor(NULL);
ShowCursor(TRUE);
}
fprintf(stderr, "WM_DESTROY\n");
printf("WM_DESTROY\n");
PostQuitMessage(0);
closed = 1;
break;
613,13 → 613,13
 
case WM_MOVE:
GetWindowRect(win, &rect);
fprintf(stderr, "%u,%u - %u, %u\n",
printf("%u,%u - %u, %u\n",
rect.left,rect.top,rect.right,rect.bottom);
ClipCursor(&rect);
break;
 
case WM_ACTIVATE:
fprintf(stderr, "WM_ACTIVATE %u\n", (unsigned) LOWORD(wparam));
printf("WM_ACTIVATE %u\n", (unsigned) LOWORD(wparam));
if ( LOWORD(wparam) )
{
if ( !windowActive )
628,7 → 628,7
{
ClipCursor(NULL); /* helps with Win95? */
GetWindowRect(win, &rect);
fprintf(stderr, "%u,%u - %u, %u\n",
printf("%u,%u - %u, %u\n",
rect.left,rect.top,rect.right,rect.bottom);
ClipCursor(&rect);
ShowCursor(FALSE);
/programs/games/doom/trunk/kolibc/include/kolibc.h
0,0 → 1,157
 
 
#ifndef kolibc_h
#define kolibc_h
 
#ifdef __cplusplus
extern "C"
{
#endif
 
typedef unsigned char byte;
typedef unsigned short int word;
typedef unsigned int dword;
 
typedef unsigned int fpos_t;
typedef unsigned int size_t;
 
#define NULL (void*)0
 
typedef enum SEEKPOS {SEEK_SET=0,SEEK_CUR,SEEK_END};
 
#define FILE_OPEN_READ 0x01
#define FILE_OPEN_WRITE 0x02
#define FILE_OPEN_APPEND 0x04
#define FILE_OPEN_TEXT 0x08
#define FILE_OPEN_PLUS 0x10
#define EOF -1
 
typedef struct
{
char *buffer;
char *stream;
size_t strpos;
size_t remain;
 
size_t filepos;
size_t buffersize;
size_t filesize;
char* filename;
int mode;
} FILE;
 
extern FILE* fopen(const char* filename, const char *mode);
extern int fclose(FILE* file);
extern int feof(FILE* file);
extern int fflush(FILE* file);
extern int fgetc(FILE* file);
extern int fgetpos(FILE* file,fpos_t* pos);
extern int fsetpos(FILE* file,const fpos_t* pos);
extern int fputc(int c,FILE* file);
extern int fread(void* buffer,size_t size,size_t count,FILE* file);
extern int fwrite(const void* buffer,size_t size,size_t count,FILE* file);
extern long ftell(FILE* file);
extern int fseek(FILE* file,long offset,int origin);
extern void rewind(FILE* file);
extern int fprintf(FILE* file, const char* format, ...);
extern int fscanf(FILE* file,const char* format, ...);
extern int ungetc(int c,FILE* file);
 
extern int sprintf(char *dest, const char *format,...);
extern int printf(const char *format,...);
 
typedef char *va_list;
#define _roundsize(n) ( (sizeof(n) + 3) & ~3 )
#define va_start(ap,v) (ap = (va_list)&v+_roundsize(v))
#define va_arg(ap,t) ( *(t *)((ap += _roundsize(t)) - _roundsize(t)) )
#define va_end(ap) (ap = (va_list)0)
 
/*
** All character classification functions except isascii().
** Integer argument (c) must be in ASCII range (0-127) for
** dependable answers.
*/
 
#define ALNUM 1
#define ALPHA 2
#define CNTRL 4
#define DIGIT 8
#define GRAPH 16
#define LOWER 32
#define PRINT 64
#define PUNCT 128
#define BLANK 256
#define UPPER 512
#define XDIGIT 1024
 
extern short int _is[128];
 
#define isalnum(c)(_is[c] & ALNUM ) /* 'a'-'z', 'A'-'Z', '0'-'9' */
#define isalpha(c)(_is[c] & ALPHA ) /* 'a'-'z', 'A'-'Z' */
#define iscntrl(c)(_is[c] & CNTRL ) /* 0-31, 127 */
#define isdigit(c)(_is[c] & DIGIT ) /* '0'-'9' */
#define isgraph(c)(_is[c] & GRAPH ) /* '!'-'~' */
#define islower(c)(_is[c] & LOWER ) /* 'a'-'z' */
#define isprint(c)(_is[c] & PRINT ) /* ' '-'~' */
#define ispunct(c)(_is[c] & PUNCT ) /* !alnum && !cntrl && !space */
#define isspace(c)(_is[c] & BLANK ) /* HT, LF, VT, FF, CR, ' ' */
#define isupper(c)(_is[c] & UPPER ) /* 'A'-'Z' */
#define isxdigit(c)(_is[c] & XDIGIT) /* '0'-'9', 'a'-'f', 'A'-'F' */
 
 
#define _LOWER 0x80
#define _UPPER 0x40
#define _DIGIT 0x20
#define _XDIGT 0x10
#define _PRINT 0x08
#define _PUNCT 0x04
#define _SPACE 0x02
#define _CNTRL 0x01
 
#define abs(i) (((i)<0)?(-(i)):(i))
 
extern int atoib(char *s,int b);
extern int atoi(char *s);
extern char tolower(char c);
extern char toupper(char c);
extern void itoab(int n,char* s,int b);
extern void itoa(int n,char* s);
 
extern char* strcat(char*,const char*);
extern char* strchr(const char*,int);
extern int strcmp(const char*,const char*);
extern int strcoll(const char*,const char*);
extern char* strcpy(char*,const char*);
extern int strcspn(const char*,const char*);
extern size_t strlen(const char*);
extern char* strncat(char*,const char*,int);
extern int strncmp(const char*,const char*,int);
extern char* strncpy(char*,const char*,int);
extern char* strpbrk(const char*,const char*);
extern char* strrchr(const char*,int);
extern int strspn(const char*,const char*);
extern char* strstr(const char*,const char*);
extern char* strtok(char*,const char*);
extern int strxfrm(char*,const char*,int);
extern char* strdup(const char*);
extern char toupper(char c);
#define isascii(char) ( (unsigned)char < 0x80 )
 
extern void* memchr(const void*,int,int);
extern int memcmp(const void*,const void*,int);
extern void* memcpy(void*,const void*,int);
extern void* memmove(void*,const void*,int);
extern void* memset(void*,int,int);
 
extern void *malloc(size_t size);
extern void* realloc(void* oldmem, size_t bytes);
extern void free(void *mem);
 
 
#ifdef __cplusplus
extern "C"
}
#endif
 
#endif //kolibc_h
/programs/games/doom/trunk/kolibc/include/kolibri.h
0,0 → 1,107
 
#ifdef __cplusplus
extern "C"
{
#endif
 
 
#define FONT0 0x00000000
#define FONT1 0x10000000
 
#define BT_NORMAL 0x00000000
#define BT_NOFRAME 0x20000000
#define BT_HIDE 0x40000000
#define BT_DEL 0x80000000
 
#define EV_REDRAW 1
#define EV_KEY 2
#define EV_BUTTON 3
 
#define REL_SCREEN 0
#define REL_WINDOW 1
 
#define FILE_NOT_FOUND 5
#define FILE_EOF 6
 
 
typedef unsigned int DWORD;
typedef unsigned short int WORD;
 
typedef struct
{ DWORD pci_cmd;
DWORD irq;
DWORD glob_cntrl;
DWORD glob_sta;
DWORD codec_io_base;
DWORD ctrl_io_base;
DWORD codec_mem_base;
DWORD ctrl_mem_base;
DWORD codec_id;
} CTRL_INFO;
 
typedef struct
{ DWORD cmd;
DWORD offset;
DWORD r1;
DWORD count;
DWORD buff;
char r2;
char *name;
} FILEIO;
 
typedef struct
{ DWORD attr;
DWORD flags;
DWORD cr_time;
DWORD cr_date;
DWORD acc_time;
DWORD acc_date;
DWORD mod_time;
DWORD mod_date;
DWORD size;
DWORD size_high;
} FILEINFO;
 
void _stdcall InitHeap(int heap_size);
void* _stdcall UserAlloc(int size);
void _stdcall GetNotify(DWORD *event);
 
//void _stdcall CreateThread(void *fn, char *p_stack);
DWORD _stdcall GetMousePos(DWORD rel_type);
int _stdcall GetService(char *srv_name);
void _stdcall GetDevInfo(DWORD hSrv,CTRL_INFO *pInfo);
int _stdcall GetMasterVol(DWORD hSrv,int* vol);
int _stdcall SetMasterVol(DWORD hSrv, int vol);
DWORD _stdcall CreateBuffer(DWORD hSrv, DWORD format);
int _stdcall DestroyBuffer(DWORD hSrv, DWORD hBuff);
int _stdcall SetBuffer(DWORD hSrv, DWORD hBuff,char* buff,
DWORD offs, int size);
int _stdcall PlayBuffer(DWORD hSrv, DWORD hBuff);
int _stdcall StopBuffer(DWORD hSrv, DWORD hBuff);
 
void _stdcall debug_out_hex(DWORD val);
void debug_out_str(char* str);
 
int _stdcall get_fileinfo(char *name,FILEINFO* pinfo);
int _stdcall read_file (char *name,char*buff,int offset, int count,int *reads);
int _stdcall write_file(char *name,char*buff,int offset,int count,int *writes);
 
//void exit();
int _cdecl get_key(void);
int _cdecl get_button_id();
void delay(int val);
int wait_for_event(int time);
int wait_for_event_infinite();
void BeginDraw(void);
void EndDraw(void);
void _stdcall DrawWindow(int x,int y, int sx, int sy,int workcolor,int style,
int captioncolor,int windowtype,int bordercolor);
void _stdcall debug_out(int ch);
void _stdcall make_button(int x, int y, int xsize, int ysize, int id, int color);
void _stdcall draw_bar(int x, int y, int xsize, int ysize, int color);
void _stdcall write_text(int x,int y,int color,char* text,int len);
 
#ifdef __cplusplus
extern "C"
}
#endif
/programs/games/doom/trunk/kolibc/include/mf.h
0,0 → 1,91
#include "kolibc.h"
 
#define PINUSE_BIT 1
#define CINUSE_BIT 2
#define INUSE_BITS 3
 
 
struct m_seg
{
char* base; /* base address */
dword size; /* allocated size */
struct m_seg* next; /* ptr to next segment */
dword flags; /* mmap and extern flag */
};
 
struct m_chunk
{
dword prev_foot; /* Size of previous chunk (if free). */
dword head; /* Size and inuse bits. */
struct m_chunk* fd; /* double links -- used only if free. */
struct m_chunk* bk;
};
 
typedef struct m_chunk* mchunkptr;
 
struct t_chunk
{
/* The first four fields must be compatible with malloc_chunk */
dword prev_foot;
dword head;
struct t_chunk* fd;
struct t_chunk* bk;
 
struct t_chunk* child[2];
 
struct t_chunk* parent;
dword index;
};
 
typedef struct t_chunk* tchunkptr;
typedef struct t_chunk* tbinptr;
 
struct m_state
{
dword smallmap;
dword treemap;
// DWORD dvsize;
dword topsize;
char* least_addr;
// mchunkptr dv;
mchunkptr top;
dword magic;
struct m_chunk smallbins[32];
tbinptr treebins[32];
};
 
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
 
extern struct m_state ms;
 
void init_malloc(void* p);
void* mf_alloc(size_t);
void mf_free(void*);
 
#ifdef __cplusplus
}
#endif /* __cplusplus */
 
 
dword compute_tree_index(size_t s);
 
void insert_chunk(mchunkptr P, size_t S);
void insert_large_chunk(tchunkptr X, size_t S);
 
void unlink_large_chunk(tchunkptr X);
 
//void replace_dv(mchunkptr P, size_t S);
static void* malloc_small(size_t nb);
static void* malloc_large(size_t nb);
 
#define leftshift_for_tree_index(i) \
((i == 31)? 0 : (31 - (i >> 1) + 8 - 2))
 
#define leftmost_child(t) ((t)->child[0] != 0? (t)->child[0] : (t)->child[1])
#define chunk2mem(p) (void*)((char*)p + 8)
#define mem2chunk(mem) (mchunkptr)((char*)mem - 8)
#define chunk_plus_offset(p, s) ((mchunkptr)(((char*)(p)) + (s)))
 
/programs/games/doom/trunk/kolibc/src/file/fclose.c
0,0 → 1,18
#include "kolibc.h"
 
int write_buffer(FILE *f);
 
int fclose(FILE* file)
{
int err;
if((file->mode & FILE_OPEN_WRITE)||
(file->mode & FILE_OPEN_APPEND)||
(file->mode & FILE_OPEN_PLUS))
err=write_buffer(file);
free(file->buffer);
free(file->filename);
free(file);
return err == 0 ? 0:EOF;
}
/programs/games/doom/trunk/kolibc/src/file/feof.c
0,0 → 1,5
#include "kolibc.h"
int feof(FILE* file)
{
return (file->filepos-file->strpos)>=file->filesize;
}
/programs/games/doom/trunk/kolibc/src/file/fgetc.c
0,0 → 1,22
#include "kolibc.h"
 
extern int fill_buff(FILE* f);
 
int fgetc(FILE* f)
{ char retval;
 
if(!((f->mode & FILE_OPEN_READ)|(f->mode & FILE_OPEN_PLUS)))
return EOF;
 
if(f->remain ==0)
{ f->filepos+=4096;
if(!fill_buff(f))
return EOF;
};
retval= *(f->stream);
f->strpos++;
f->stream++;
f->remain--;
return (int)retval;
}
/programs/games/doom/trunk/kolibc/src/file/fopen.c
0,0 → 1,146
#include "kolibc.h"
#include "kolibri.h"
 
extern struct{int argc; char** argv;} __ARGS;
 
char* getfullpath(const char* relpath){
byte prev_is_slash=0;
int len=0, depth=0, i;
char* buff;
buff = (char*)malloc(strlen(relpath));
strcpy(buff, relpath);
/**********
buff = (char*)malloc(strlen(__ARGS.argv[0]) + strlen(relpath));
if(*relpath == '/') buff[0] = '\0';
else {
len = strrchr(__ARGS.argv[0], '/') - __ARGS.argv[0] + 1;
strncpy(buff, __ARGS.argv[0], len);
prev_is_slash = 1;
buff[len] = 0;
for(i=0; buff[i]; i++)
if(buff[i] == '/' && i < len-1) depth++;
}
for (; *relpath; relpath++){
switch (*relpath){
case '/':
prev_is_slash = 1;
buff[len++] = '/';
break;
case '.':
if(*(relpath+1) == '.' && *(relpath+2) == '/' && prev_is_slash){
if(!depth) return 0;
buff[len-1] = 0;
len = strrchr(buff, '/') + 1 - buff;
buff[len] = 0;
depth--;
relpath += 2;
} else {
depth++;
buff[len++] = '.';
}
break;
default:
if(prev_is_slash){
depth++;
prev_is_slash = 0;
}
buff[len++] = *relpath;
break;
}
}
buff[len]= '\0';
*************/
return buff;
}
 
FILE* fopen(const char* filename, const char *mode)
{
FILEINFO fileinfo;
FILE* res;
char *path;
int err;
int imode;
imode=0;
if (*mode=='r')
{
imode=FILE_OPEN_READ;
mode++;
}else if (*mode=='w')
{
imode=FILE_OPEN_WRITE;
mode++;
}else if (*mode=='a')
{
imode=FILE_OPEN_APPEND;
mode++;
}else
return 0;
if (*mode=='t')
{
imode|=FILE_OPEN_TEXT;
mode++;
}else if (*mode=='b')
mode++;
if (*mode=='+')
{
imode|=FILE_OPEN_PLUS;
mode++;
}
if (*mode!=0)
return 0;
path= getfullpath(filename);
err=get_fileinfo(path, &fileinfo);
if(err)
{
if ((imode & 7)== 0)
{ free(path);
return 0;
};
// err=_msys_create_file(path);
if (err)
{ free(path);
return 0;
}
fileinfo.size=0;
};
res=(FILE*)malloc(sizeof(FILE));
if(!res)
{ free(path);
return 0;
};
res->buffer=malloc(4096);
res->stream=res->buffer;
res->strpos=0;
res->remain=4096;
res->buffersize=4096;
res->filesize=fileinfo.size;
res->filename=path;
res->mode=imode;
if (imode & FILE_OPEN_APPEND)
{ size_t bytes;
res->strpos= res->filesize & 4095;
if (res->strpos) //not align
{
res->filepos=res->filesize & -4096; // align buffer
res->remain=4096-res->strpos;
err=read_file(res->filename,res->buffer,
res->filesize,res->remain,&bytes);
res->stream=res->buffer+res->strpos;
};
}
else
{ size_t bytes;
err=read_file(res->filename,res->buffer,
0,4096,&bytes);
res->filepos=0;
};
return res;
}
/programs/games/doom/trunk/kolibc/src/file/fprintf.c
0,0 → 1,216
#include "kolibc.h"
const char xdigs_lower[16]="0123456789abcdef";
const char xdigs_upper[16]="0123456789ABCDEF";
int fprintf(FILE* file, const char* format, ...)
{
char* arg;
int ispoint;
int beforepoint;
int afterpoint;
int longflag;
int contflag;
int i;
long long number;
char buffer[512];
char* str;
arg= (void*)&format;
arg+=sizeof(const char*);
while (*format!='\0')
{
if (*format!='%')
{
fputc(*format,file);
format++;
continue;
}
ispoint=0;
beforepoint=0;
afterpoint=0;
longflag=0;
contflag=1;
format++;
while (*format && contflag)
{
switch (*format)
{
case '.':
ispoint=1;
format++;
break;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
if (ispoint)
afterpoint=afterpoint*10+(*format)-'0';
else
beforepoint=beforepoint*10+(*format)-'0';
format++;
break;
case 'l':
if (longflag==0)
longflag=1;
else
longflag=2;
format++;
break;
case 'L':
longflag=2;
format++;
break;
case 'f':
case 'd':
case 'x':
case 'X':
case 'c':
case 's':
case '%':
contflag=0;
break;
default:
contflag=0;
}
}
if (contflag)
break;
switch (*format)
{
case '%':
fputc('%',file);
break;
case 'd':
if (longflag==2)
{
number=*((long long *)arg);
arg+=sizeof(long long);
}else
{
number=*((int*)arg);
arg+=sizeof(int);
}
if (number<0)
{
beforepoint--;
fputc('-',file);
number=-number;
}
i=0;
while (number>0)
{
buffer[i]='0'+number%10;
number=number/10;
i++;
}
while (i<beforepoint)
{
fputc(' ',file);
beforepoint--;
}
while (i>0)
{
i--;
fputc(buffer[i],file);
}
break;
case 'c':
fputc(*(char*)arg,file);
arg+=sizeof(char);
break;
case 's':
str=*(char**)arg;
arg+=sizeof(char*);
if (beforepoint==0)
beforepoint--;
while (*str && beforepoint)
{
fputc(*str,file);
beforepoint--;
str++;
}
break;
case 'x':
if (longflag==2)
{
number=*((long long *)arg);
arg+=sizeof(long long);
}else
{
number=*((int*)arg);
arg+=sizeof(int);
}
if (number<0)
{
beforepoint--;
fputc('-',file);
number=-number;
}
i=0;
while (number>0)
{
buffer[i]=xdigs_lower[number & 15];
number=number>>4;
i++;
}
while (i<beforepoint)
{
fputc(' ',file);
beforepoint--;
}
while (i>0)
{
i--;
fputc(buffer[i],file);
}
break;
case 'X':
if (longflag==2)
{
number=*((long long *)arg);
arg+=sizeof(long long);
}else
{
number=*((int*)arg);
arg+=sizeof(int);
}
if (number<0)
{
beforepoint--;
fputc('-',file);
number=-number;
}
i=0;
while (number>0)
{
buffer[i]=xdigs_upper[number & 15];
number=number>>4;
i++;
}
while (i<beforepoint)
{
fputc(' ',file);
beforepoint--;
}
while (i>0)
{
i--;
fputc(buffer[i],file);
}
break;
case 'f':
if (longflag==2)
arg+=10;
else if (longflag==1)
arg+=8;
else
arg+=4;
break;
}
format++;
}
}
/programs/games/doom/trunk/kolibc/src/file/fputc.c
0,0 → 1,38
#include "kolibc.h"
#include "kolibri.h"
 
int write_buffer(FILE *f);
int fill_buff(FILE* f);
 
int fputc(int c,FILE* f)
{
if(!((f->mode & FILE_OPEN_WRITE)|(f->mode & FILE_OPEN_PLUS)))
return EOF;
 
if(!f->remain)
{ if (!write_buffer(f))
return EOF;
f->filepos+=4096;
fill_buff(f);
};
*f->stream = (char)c;
f->stream++;
f->remain--;
f->strpos++;
if((f->filepos+f->strpos) > f->filesize)
f->filesize=f->filepos+f->strpos;
 
return c;
};
 
int write_buffer(FILE *f)
{ size_t bytes;
int err;
 
bytes= f->filepos+4096 > f->filesize ? f->strpos:4096;
err=write_file(f->filename,f->buffer,f->filepos,bytes,&bytes);
if(err)
return 0;
return 1;
};
/programs/games/doom/trunk/kolibc/src/file/fread.c
0,0 → 1,50
#include "kolibc.h"
#include "kolibri.h"
 
int fill_buff(FILE* f);
 
int fread(void* dst,size_t size,size_t count,FILE* f)
{ size_t req;
size_t cnt;
char *p = dst;
if(!((f->mode & FILE_OPEN_READ)|(f->mode & FILE_OPEN_PLUS)))
return 0;
req=count*size;
if (req+f->filepos+f->strpos > f->filesize)
req=f->filesize-f->filepos-f->strpos;
count=0;
while(req)
{
if (f->remain)
{ cnt= req > f->remain ? f->remain : req;
memcpy(p,f->stream,cnt);
p+=cnt;
f->stream+=cnt;
f->strpos+=cnt;
f->remain-=cnt;
count+=cnt;
req-=cnt;
}
else
{
f->filepos+=4096;
if(!fill_buff(f)) //eof or error
break;
}
};
return count/size;
}
 
int fill_buff(FILE* f)
{ int err;
size_t bytes;
err=read_file(f->filename,f->buffer,f->filepos,
4096,&bytes);
if (err) return 0;
if(!bytes) return 0;
f->stream = f->buffer;
f->remain = 4096;
f->strpos=0;
return bytes;
};
/programs/games/doom/trunk/kolibc/src/file/fscanf.c
0,0 → 1,188
#include "kolibc.h"
void skipspaces(FILE* file)
{
int c;
while(1)
{
c=getc(file);
if (c!=' ' && c!='\r' && c!='\n')
{
ungetc(c,file);
return;
}
}
}
int fscanf(FILE* file,const char* format, ...)
{
int res;
char* arg;
int i;
int c;
int contflag;
int longflag;
int sign;
long long number;
long double rnumber;
char* str;
res=0;
arg=(char*)&format;
arg+=sizeof(const char*);
while (*format!='\0')
{
if (*format!='%')
{
c=fgetc(file);
if (c!=*format)
{
fungetc(c,file);
return -1;
}
format++;
continue;
}
contflag=1;
longflag=0;
while (*format && contflag)
{
switch(*format)
{
case '.':
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
format++;
continue;
break;
case 'l':
if (longflag==0)
longflag=1;
else
longflag=2;
format++;
break;
case 'L':
longflag=2;
format++;
break;
case 'f':
case 'd':
case 'c':
case 's':
case '%':
contflag=0;
break;
default:
contflag=0;
}
}
if (contflag)
break;
switch(*format)
{
case '%':
c=fgetc(file);
if (c!='%')
{
ungetc(c,file);
return -1;
}
res--;
break;
case 'd':
number=0;
sign=1;
skipspaces(file);
c=fgetc(file);
if (c=='-')
{
sign=-1;
}else if (c!='+')
ungetc(c,file);
contflag=0;
while(1)
{
c=fgetc(file);
if (c>='0' && c<='9')
{
contflag++;
number=number*10+(c-'0');
}else
break;
}
ungetc(c,file);
if (!contflag)
return res;
if (longflag<=1)
{
*((int*)arg)=number;
arg+=sizeof(int);
}else
{
*((long long*)arg)=number;
arg+=sizeof(long long);
}
break;
case 'c':
c=fgetc(file);
if (c==EOF)
return res;
*((char*)arg)=c;
arg+=sizeof(char);
break;
case 's':
skipspaces(file);
contflag=0;
str=*((char**)arg);
arg+=sizeof(char*);
while(1)
{
c=fgetc(file);
if (c==EOF || c==' ' || c=='\n' || c=='\r')
{
ungetc(c,file);
break;
}
*str=c;
str++;
contflag++;
}
if (!contflag)
return res;
break;
case 'f':
skipspaces(file);
// TODO: read real numbers
rnumber=0;
switch (longflag)
{
case 0:
*((float*)arg)=rnumber;
arg+=sizeof(float);
break;
case 1:
*((double*)arg)=rnumber;
arg+=sizeof(double);
break;
case 2:
*((long double*)arg)=rnumber;
arg+=sizeof(long double);
break;
default:
return res;
}
break;
default:
break;
}
format++;
res++;
}
return res;
}
/programs/games/doom/trunk/kolibc/src/file/fseek.c
0,0 → 1,11
#include "kolibc.h"
int fseek(FILE* file,long offset,int origin)
{
if (origin==SEEK_CUR)
offset+=file->filepos;
else if (origin==SEEK_END)
offset+=file->filesize;
else if (origin!=SEEK_SET)
return EOF;
return fsetpos(file,&offset);
}
/programs/games/doom/trunk/kolibc/src/file/fsetpos.c
0,0 → 1,23
#include "kolibc.h"
#include "kolibri.h"
 
int fsetpos(FILE* f,const fpos_t * pos)
{ int err;
size_t bytes;
if (*pos>=0)
{
bytes= *pos & -4096;
err=read_file(f->filename,f->buffer,bytes,
4096,&bytes);
if (err) return EOF;
if(!bytes) return EOF;
f->filepos= *pos & -4096;
f->strpos = *pos & 4095;
f->remain = 4096-f->strpos;
f->stream = f->buffer+f->strpos;
return 0;
}
else
return EOF;
}
/programs/games/doom/trunk/kolibc/src/file/ftell.c
0,0 → 1,5
#include "kolibc.h"
long ftell(FILE* file)
{
return file->filepos+file->strpos;
}
/programs/games/doom/trunk/kolibc/src/file/fwrite.c
0,0 → 1,38
#include "kolibc.h"
 
int write_buffer(FILE *f);
int fill_buff(FILE* f);
 
int fwrite(const void* src,size_t size,size_t count,FILE* f)
{
size_t req;
size_t cnt;
 
//append mode unsupported
if(!((f->mode & FILE_OPEN_WRITE)|(f->mode & FILE_OPEN_PLUS)))
return EOF;
req=count*size;
count=0;
while(req)
{
if(f->remain)
{ cnt= req > f->remain ? f->remain : req;
memcpy(f->stream,src,cnt);
f->stream+=cnt;
f->strpos+=cnt;
f->remain-=cnt;
count+=cnt;
req-=cnt;
}
else
{
if(!write_buffer(f))
break;
f->filepos+=4096;
fill_buff(f);
};
};
return count/size;
};
/programs/games/doom/trunk/kolibc/src/file/rewind.c
0,0 → 1,9
#include "kolibc.h"
 
int fill_buff(FILE* f);
 
void rewind(FILE* file)
{
file->filepos=0;
fill_buff(file);
}
/programs/games/doom/trunk/kolibc/src/mem/malloc.c
0,0 → 1,598
 
#include "mf.h"
void * memcpy(void * dst, void * src, size_t count);
 
static struct m_state ms;
 
void init_malloc(void* p)
{ mchunkptr chp;
int i;
dword psize= 0x10000;
psize-= 40;
ms.top = (mchunkptr)p;
ms.topsize = psize;
chp = (mchunkptr)p;
chp->head=psize|1;
for(i=0; i<32; i++)
{
mchunkptr p = &ms.smallbins[i];
p->fd = p;
p->bk = p;
};
}
 
void *malloc(size_t size)
{ size_t nb, psize,rsize;
dword idx;
dword smallbits;
mchunkptr B,F,p,r;
void *mem;
 
nb = ((size+7)&~7)+8;
if (nb < 256)
{
// idx = nb >> 3;
// smallbits= (-1<<idx) & ms.smallmap;
_asm
{
mov ecx, [nb]
or eax, -1
shl eax, cl
and eax, [ms.smallmap]
mov [smallbits], eax
}
if (smallbits)
{
_asm
{ bsf eax, [smallbits]
mov [idx], eax
};
psize= idx<<3;
rsize= psize-nb;
 
B = &ms.smallbins[idx];
p = B->fd;
F = p->fd;
if (B == F)
{
// ms.smallmap &= ~(1<< idx);
_asm
{
mov eax, [idx]
btr [ms.smallmap], eax
}
}
B->fd = F;
F->bk = B;
 
if(rsize<16)
{
p->head = psize|PINUSE_BIT|CINUSE_BIT;
((mchunkptr)((char*)p + psize))->head |= PINUSE_BIT;
return chunk2mem(p);
};
p->head = nb|PINUSE_BIT|CINUSE_BIT;
r = chunk_plus_offset(p, nb);
r->head = rsize|PINUSE_BIT;
((mchunkptr)((char*)r + rsize))->prev_foot = rsize;
{
dword I;
mchunkptr B;
mchunkptr F;
I = rsize>>3;
ms.smallmap |= 1<< I;
B = &ms.smallbins[I];
F = B->fd;
B->fd = r;
F->bk = r;
r->fd = F;
r->bk = B;
}
return chunk2mem(p);
}
if (ms.treemap != 0 && (mem = malloc_small(nb)) != 0)
return mem;
}
else
{
if (ms.treemap != 0 && (mem = malloc_large(nb)) != 0)
return mem;
};
if (nb < ms.topsize)
{
size_t rsize = ms.topsize -= nb;
mchunkptr p = ms.top;
mchunkptr r = ms.top = chunk_plus_offset(p, nb);
r->head = rsize | PINUSE_BIT;
p->head = nb |PINUSE_BIT|CINUSE_BIT;
return chunk2mem(p);
};
return 0;
};
 
void free(void *mem)
{ size_t psize;
size_t prevsize;
size_t nsize;
mchunkptr next;
mchunkptr prev;
mchunkptr p = mem2chunk(mem);
if(p->head & CINUSE_BIT)
{
psize = p->head & (~3);
next = chunk_plus_offset(p, psize);
 
if(!(p->head & PINUSE_BIT))
{
prevsize = p->prev_foot;
prev=(mchunkptr)(((char*)p) - prevsize);
psize += prevsize;
p = prev;
if (prevsize < 256)
{
dword I;
mchunkptr F = p->fd;
mchunkptr B = p->bk;
I = prevsize>>3;
if (F == B)
{
ms.smallmap &= ~(1<< I);
}
F->bk = B;
B->fd = F;
}
else
unlink_large_chunk((tchunkptr)p);
};
if(next->head & PINUSE_BIT)
{
if (! (next->head & CINUSE_BIT))
{
if (next == ms.top)
{ size_t tsize = ms.topsize += psize;
ms.top = p;
p->head = tsize | PINUSE_BIT;
return;
}
nsize = next->head & ~INUSE_BITS;
psize += nsize;
 
if (nsize < 256)
{
dword I;
mchunkptr F = next->fd;
mchunkptr B = next->bk;
I = nsize>>3;
if (F == B)
ms.smallmap &= ~(1<< I);
F->bk = B;
B->fd = F;
}
else
unlink_large_chunk((tchunkptr)next);
p->head = psize|PINUSE_BIT;
((mchunkptr)((char*)p+psize))->prev_foot = psize;
}
else
{
next->head &= ~PINUSE_BIT;
p->head = psize|PINUSE_BIT;
((mchunkptr)((char*)p+psize))->prev_foot = psize;
};
insert_chunk(p,psize);
};
};
}
 
static void insert_chunk(mchunkptr P, size_t S)
{
dword I;
mchunkptr B;
mchunkptr F;
if (S < 256)
{
I = S>>3;
B = &ms.smallbins[I];
F = B->fd;
ms.smallmap |= 1<< I;
B->fd = P;
F->bk = P;
P->fd = F;
P->bk = B;
}
else
insert_large_chunk((tchunkptr)P, S);
};
 
/********
static void insert_small_chunk(mchunkptr p, size_t s)
{
DWORD I = s>>3;
mchunkptr B = &ms.smallbins[I];
mchunkptr F = B->fd;
if (!(ms.smallmap & 1<<I))
ms.smallmap |= 1<< I;
 
B->fd = p;
F->bk = p;
p->fd = F;
p->bk = B;
}
*********/
 
static dword compute_tree_index(size_t s)
{ dword idx;
 
_asm
{ mov edx, [s]
shr edx, 8
bsr eax, edx
lea ecx, [eax+7]
mov edx, [s]
shr edx, cl
and edx, 1
lea eax, [edx+eax*2]
mov [idx], eax
};
 
return idx;
};
 
static void insert_large_chunk(tchunkptr X, size_t S)
{
tbinptr* H;
dword I;
I = compute_tree_index(S);
H = &ms.treebins[I];
X->index = I;
X->child[0] = X->child[1] = 0;
if (!(ms.treemap & 1<<I))
{
ms.treemap |= 1<<I;
*H = X;
X->parent = (tchunkptr)H;
X->fd = X->bk = X;
}
else
{
tchunkptr T = *H;
size_t K = S << leftshift_for_tree_index(I);
for (;;)
{
if ((T->head & ~INUSE_BITS) != S)
{
tchunkptr* C = &(T->child[(K >> 31) & 1]);
K <<= 1;
if (*C != 0)
T = *C;
else
{
*C = X;
X->parent = T;
X->fd = X->bk = X;
break;
}
}
else
{
tchunkptr F = T->fd;
T->fd = F->bk = X;
X->fd = F;
X->bk = T;
X->parent = 0;
break;
};
};
};
};
 
static void* malloc_small(size_t nb)
{
tchunkptr t, v;
mchunkptr r;
size_t rsize;
dword i;
_asm
{ bsf ecx,[ms.treemap]
mov [i], ecx
}
v = t = ms.treebins[i];
rsize = (t->head & ~INUSE_BITS) - nb;
 
while ((t = leftmost_child(t)) != 0)
{
size_t trem = (t->head & ~INUSE_BITS) - nb;
if (trem < rsize)
{ rsize = trem;
v = t;
}
}
 
r = chunk_plus_offset((mchunkptr)v, nb);
unlink_large_chunk(v);
if (rsize < 16)
{
v->head = (rsize + nb)|PINUSE_BIT|CINUSE_BIT;
((mchunkptr)((char*)v+rsize + nb))->head |= PINUSE_BIT;
}
else
{
v->head = nb|PINUSE_BIT|CINUSE_BIT;
r->head = rsize|PINUSE_BIT;
((mchunkptr)((char*)r+rsize))->prev_foot = rsize;
insert_chunk(r, rsize);
// replace_dv(r, rsize);
}
return chunk2mem(v);
}
 
/********
static void replace_dv(mchunkptr P, size_t S)
{
size_t DVS = ms.dvsize;
if (DVS != 0)
{
mchunkptr DV = ms.dv;
insert_small_chunk(DV, DVS);
}
ms.dvsize = S;
ms.dv = P;
}
***********/
 
void static unlink_large_chunk(tchunkptr X)
{
tchunkptr XP = X->parent;
tchunkptr R;
if (X->bk != X)
{
tchunkptr F = X->fd;
R = X->bk;
F->bk = R;
R->fd = F;
}
else
{
tchunkptr* RP;
if (((R = *(RP = &(X->child[1]))) != 0) ||
((R = *(RP = &(X->child[0]))) != 0))
{
tchunkptr* CP;
while ((*(CP = &(R->child[1])) != 0) ||
(*(CP = &(R->child[0])) != 0))
{
R = *(RP = CP);
}
*RP = 0;
}
}
if (XP != 0)
{
tbinptr* H = &ms.treebins[X->index];
if (X == *H)
{
if ((*H = R) == 0)
ms.treemap &= ~(1<<X->index);
}
else
{
if (XP->child[0] == X)
XP->child[0] = R;
else
XP->child[1] = R;
};
if (R != 0)
{
tchunkptr C0, C1;
R->parent = XP;
if ((C0 = X->child[0]) != 0)
{
R->child[0] = C0;
C0->parent = R;
}
if ((C1 = X->child[1]) != 0)
{
R->child[1] = C1;
C1->parent = R;
}
}
}
}
 
static void* malloc_large(size_t nb)
{
tchunkptr v = 0;
size_t rsize = -nb; /* Unsigned negation */
tchunkptr t;
dword idx;
idx = compute_tree_index(nb);
 
if ((t = ms.treebins[idx]) != 0)
{
/* Traverse tree for this bin looking for node with size == nb */
size_t sizebits = nb << leftshift_for_tree_index(idx);
tchunkptr rst = 0; /* The deepest untaken right subtree */
for (;;)
{
tchunkptr rt;
size_t trem = (t->head & ~INUSE_BITS) - nb;
 
if (trem < rsize)
{
v = t;
if ((rsize = trem) == 0)
break;
}
rt = t->child[1];
t = t->child[(sizebits >> 31) & 1];
if (rt != 0 && rt != t)
rst = rt;
if (t == 0)
{
t = rst; /* set t to least subtree holding sizes > nb */
break;
}
sizebits <<= 1;
}
}
 
if (t == 0 && v == 0)
{ /* set t to root of next non-empty treebin */
dword leftbits = (-1<<idx) & ms.treemap;
if (leftbits != 0)
{ dword i;
_asm
{ bsf eax, [leftbits]
mov [i], eax
}
t = ms.treebins[i];
}
}
 
while (t != 0)
{ /* find smallest of tree or subtree */
size_t trem = (t->head & ~INUSE_BITS) - nb;
if (trem < rsize)
{
rsize = trem;
v = t;
}
t = leftmost_child(t);
}
 
/* If dv is a better fit, return 0 so malloc will use it */
if (v != 0)
{
mchunkptr r = chunk_plus_offset((mchunkptr)v, nb);
unlink_large_chunk(v);
if (rsize < 256)
{
v->head = (rsize + nb)|PINUSE_BIT|CINUSE_BIT;
((mchunkptr)((char*)v+rsize + nb))->head |= PINUSE_BIT;
}
else
{
v->head = nb|PINUSE_BIT|CINUSE_BIT;
r->head = rsize|PINUSE_BIT;
((mchunkptr)((char*)r+rsize))->prev_foot = rsize;
insert_large_chunk((tchunkptr)r, rsize);
}
return chunk2mem(v);
}
return 0;
}
 
static void* internal_realloc(struct m_state *m, void* oldmem,
size_t bytes);
 
void* realloc(void* oldmem, size_t bytes)
{
if (oldmem == 0)
return malloc(bytes);
else
{
struct m_state *m = &ms;
return internal_realloc(m, oldmem, bytes);
}
};
 
#define check_inuse_chunk(M,P)
 
#define MAX_REQUEST 256*1024*1024
#define set_inuse(M,p,s)\
((p)->head = (((p)->head & PINUSE_BIT)|s|CINUSE_BIT),\
((mchunkptr)(((char*)(p)) + (s)))->head |= PINUSE_BIT)
 
static void* internal_realloc(struct m_state *m, void* oldmem, size_t bytes)
{ mchunkptr oldp;
size_t oldsize;
mchunkptr next;
mchunkptr newp;
void* extra;
if (bytes >= MAX_REQUEST)
return 0;
oldp = mem2chunk(oldmem);
oldsize = oldp->head & ~INUSE_BITS;
next = chunk_plus_offset(oldp, oldsize);
newp = 0;
extra = 0;
 
/* Try to either shrink or extend into top. Else malloc-copy-free */
 
if( (oldp->head & CINUSE_BIT) &&
((char*)oldp < (char*)next)&&
(next->head & PINUSE_BIT))
{
size_t nb = ((bytes+7)&~7)+8;
if (oldsize >= nb)
{ /* already big enough */
size_t rsize = oldsize - nb;
newp = oldp;
if (rsize >= 16)
{
mchunkptr remainder = chunk_plus_offset(newp, nb);
set_inuse(m, newp, nb);
set_inuse(m, remainder, rsize);
extra = chunk2mem(remainder);
}
}
else
if (next == m->top && oldsize + m->topsize > nb)
{
/* Expand into top */
size_t newsize = oldsize + m->topsize;
size_t newtopsize = newsize - nb;
mchunkptr newtop = chunk_plus_offset(oldp, nb);
set_inuse(m, oldp, nb);
newtop->head = newtopsize |PINUSE_BIT;
m->top = newtop;
m->topsize = newtopsize;
newp = oldp;
}
}
else
{
return 0;
}
 
if (newp != 0)
{
if (extra != 0)
free(extra);
check_inuse_chunk(m, newp);
return chunk2mem(newp);
}
else
{
void* newmem = malloc(bytes);
if (newmem != 0)
{
size_t oc = oldsize - 4;
memcpy(newmem, oldmem, (oc < bytes)? oc : bytes);
free(oldmem);
}
return newmem;
}
return 0;
}
/programs/games/doom/trunk/kolibc/src/string/atoi.c
0,0 → 1,18
#include "kolibc.h"
 
/*
** atoi(s) - convert s to integer.
*/
int atoi(char *s)
{
int sign, n;
while(isspace(*s)) ++s;
sign = 1;
switch(*s) {
case '-': sign = -1;
case '+': ++s;
}
n = 0;
while(isdigit(*s)) n = 10 * n + *s++ - '0';
return (sign * n);
}
/programs/games/doom/trunk/kolibc/src/string/doprnt.c
0,0 → 1,756
#include "kolibc.h"
 
#define NULL (void*)0
 
static int isspeciall(long double d, char *bufp);
static char * exponentl(char *p, int expv, unsigned char fmtch);
 
 
/***
struct __FILE {
int _cnt;
char *_ptr;
char *_base;
int _bufsiz;
int _flag;
int _file;
int _fillsize;
};
 
typedef struct __FILE FILE;
*****/
 
static char decimal = '.';
 
/* 11-bit exponent (VAX G floating point) is 308 decimal digits */
#define MAXEXP 308
#define MAXEXPLD 4952 /* this includes subnormal numbers */
/* 128 bit fraction takes up 39 decimal digits; max reasonable precision */
#define MAXFRACT 39
 
#define DEFPREC 6
#define DEFLPREC 6
 
#define BUF (MAXEXPLD+MAXFRACT+1) /* + decimal point */
 
#define PUTC(ch) (void) putc(ch, fp)
 
#define ARG(basetype) \
_ulong = flags&LONGINT ? va_arg(argp, long basetype) : \
flags&SHORTINT ? (short basetype)va_arg(argp, int) : \
va_arg(argp, int)
 
static int nan2 = 0;
 
static int todigit(char c)
{
if (c<='0') return 0;
if (c>='9') return 9;
return c-'0';
}
static char tochar(int n)
{
if (n>=9) return '9';
if (n<=0) return '0';
return n+'0';
}
 
/* have to deal with the negative buffer count kludge */
 
#define LONGINT 0x01 /* long integer */
#define LONGDBL 0x02 /* long double */
#define SHORTINT 0x04 /* short integer */
#define ALT 0x08 /* alternate form */
#define LADJUST 0x10 /* left adjustment */
#define ZEROPAD 0x20 /* zero (as opposed to blank) pad */
#define HEXPREFIX 0x40 /* add 0x or 0X prefix */
 
static cvtl(long double number, int prec, int flags, char *signp,
unsigned char fmtch, char *startp, char *endp);
static char *roundl(long double fract, int *expv, char *start, char *end,
char ch, char *signp);
static char *exponentl(char *p, int expv, unsigned char fmtch);
 
static char NULL_REP[] = "(null)";
 
int _doprnt(char *dest, size_t maxlen, const char *fmt0, va_list argp)
{
const char *fmt; /* format string */
int ch; /* character from fmt */
int cnt; /* return value accumulator */
int n; /* random handy integer */
char *t; /* buffer pointer */
long double _ldouble; /* double and long double precision arguments
%L.[eEfgG] */
unsigned long _ulong; /* integer arguments %[diouxX] */
int base; /* base for [diouxX] conversion */
int dprec; /* decimal precision in [diouxX] */
int fieldsz; /* field size expanded by sign, etc */
int flags; /* flags as above */
int fpprec; /* `extra' floating precision in [eEfgG] */
int prec; /* precision from format (%.3d), or -1 */
int realsz; /* field size expanded by decimal precision */
int size; /* size of converted field or string */
int width; /* width from format (%8d), or 0 */
char sign; /* sign prefix (' ', '+', '-', or \0) */
char softsign; /* temporary negative sign for floats */
const char *digs; /* digits for [diouxX] conversion */
char buf[BUF]; /* space for %c, %[diouxX], %[eEfgG] */
char *p;
fmt = fmt0;
digs = "0123456789abcdef";
p = dest;
 
for (cnt = 0;; ++fmt)
{
while((ch=*fmt)&&(ch!='%'))
{ *p++ = ch;
cnt++;
fmt++;
maxlen--;
};
n = maxlen;
if (!ch)
{ *p=0;
return cnt;
};
flags = 0; dprec = 0; fpprec = 0; width = 0;
prec = -1;
sign = '\0';
rflag:
switch (*++fmt)
{ case ' ':
if (!sign)
sign = ' ';
goto rflag;
case '#':
flags |= ALT;
goto rflag;
case '*':
if ((width = va_arg(argp, int)) >= 0)
goto rflag;
width = -width;
/* FALLTHROUGH */
case '-':
flags |= LADJUST;
goto rflag;
case '+':
sign = '+';
goto rflag;
case '.':
if (*++fmt == '*')
n = va_arg(argp, int);
else
{ n = 0;
while (isascii(*fmt) && isdigit(*fmt))
n = 10 * n + todigit(*fmt++);
--fmt;
}
prec = n < 0 ? -1 : n;
goto rflag;
case '0':
flags |= ZEROPAD;
goto rflag;
case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
n = 0;
do
{ n = 10 * n + todigit(*fmt);
} while (isascii(*++fmt) && isdigit(*fmt));
width = n;
--fmt;
goto rflag;
case 'L':
flags |= LONGDBL;
goto rflag;
case 'h':
flags |= SHORTINT;
goto rflag;
case 'l':
flags |= LONGINT;
goto rflag;
case 'c':
*(t = buf) = va_arg(argp, int);
size = 1;
sign = '\0';
goto pforw;
case 'D':
flags |= LONGINT;
/*FALLTHROUGH*/
case 'd':
case 'i':
ARG(int);
if ((long)_ulong < 0)
{ _ulong = -_ulong;
sign = '-';
}
base = 10;
goto number;
case 'e':
case 'E':
case 'f':
case 'g':
case 'G':
if (flags & LONGDBL)
_ldouble = va_arg(argp, long double);
else
_ldouble = (long double)va_arg(argp, double);
if (prec > MAXFRACT)
{
if (*fmt != 'g' && (*fmt != 'G' || (flags&ALT)))
fpprec = prec - MAXFRACT;
prec = MAXFRACT;
}
else if (prec == -1)
{ if (flags&LONGINT)
prec = DEFLPREC;
else
prec = DEFPREC;
}
if (_ldouble < 0)
{
softsign = '-';
_ldouble = -_ldouble;
}
else
softsign = 0;
*buf = 0;
size = cvtl(_ldouble, prec, flags, &softsign, *fmt, buf,
buf + sizeof(buf));
if (softsign && !nan2)
sign = '-';
nan2 = 0;
t = *buf ? buf : buf + 1;
goto pforw;
case 'n':
if (flags & LONGINT)
*va_arg(argp, long *) = cnt;
else if (flags & SHORTINT)
*va_arg(argp, short *) = cnt;
else
*va_arg(argp, int *) = cnt;
break;
case 'O':
flags |= LONGINT;
/*FALLTHROUGH*/
case 'o':
ARG(unsigned);
base = 8;
goto nosign;
case 'p':
/* NOSTRICT */
_ulong = (unsigned long)va_arg(argp, void *);
base = 16;
goto nosign;
case 's':
if (!(t = va_arg(argp, char *)))
t = NULL_REP;
if (prec >= 0)
{ char *p /*, *memchr() */;
if ((p = memchr(t, 0, prec)))
{ size = p - t;
if (size > prec)
size = prec;
}
else
size = prec;
}
else
size = strlen(t);
sign = '\0';
goto pforw;
case 'U':
flags |= LONGINT;
/*FALLTHROUGH*/
case 'u':
ARG(unsigned);
base = 10;
goto nosign;
case 'X':
digs = "0123456789ABCDEF";
/* FALLTHROUGH */
case 'x':
ARG(unsigned);
base = 16;
/* leading 0x/X only if non-zero */
if (flags & ALT && _ulong != 0)
flags |= HEXPREFIX;
 
/* unsigned conversions */
nosign: sign = '\0';
number: if ((dprec = prec) >= 0)
flags &= ~ZEROPAD;
 
t = buf + BUF;
if (_ulong != 0 || prec != 0)
{
do
{
*--t = digs[_ulong % base];
_ulong /= base;
} while (_ulong);
digs = "0123456789abcdef";
if (flags & ALT && base == 8 && *t != '0')
*--t = '0'; /* octal leading 0 */
}
size = buf + BUF - t;
 
pforw:
fieldsz = size + fpprec;
realsz = dprec > fieldsz ? dprec : fieldsz;
if (sign)
realsz++;
if (flags & HEXPREFIX)
realsz += 2;
 
/* right-adjusting blank padding */
if ((flags & (LADJUST|ZEROPAD)) == 0 && width)
for (n = realsz; n < width; n++)
*p++ = ' ';
/* prefix */
if (sign)
*p++ = sign;
if (flags & HEXPREFIX)
{
*p++ = '0';
*p++ = (char)*fmt;
}
/* right-adjusting zero padding */
if ((flags & (LADJUST|ZEROPAD)) == ZEROPAD)
for (n = realsz; n < width; n++)
*p++ = '0';
/* leading zeroes from decimal precision */
for (n = fieldsz; n < dprec; n++)
*p++ = '0';
 
/* the string or number proper */
n = size;
// if (fp->_cnt - n >= 0 )
// {
// fp->_cnt -= n;
maxlen-= n;
memcpy(p, t, n);
p+=n;
// fp->_ptr += n;
// }
// else
// while (--n >= 0)
// PUTC(*t++);
/* trailing f.p. zeroes */
while (--fpprec >= 0)
*p++= '0';
/* left-adjusting padding (always blank) */
if (flags & LADJUST)
for (n = realsz; n < width; n++)
*p++ = ' ';
/* finally, adjust cnt */
cnt += width > realsz ? width : realsz;
break;
case '\0': /* "%?" prints ?, unless ? is NULL */
return cnt;
default:
*p++ = (char)*fmt;
cnt++;
}
}
/* NOTREACHED */
}
 
static long double pten[] =
{
1e1, 1e2, 1e4, 1e8, 1e16, 1e32, 1e64, 1e128, 1e256};
 
static long double ptenneg[] =
{
1e-1L, 1e-2L, 1e-4L, 1e-8L, 1e-16L, 1e-32L, 1e-64L, 1e-128L, 1e-256L,
1e-512L, 1e-1024L, 1e-2048L, 1e-4096L
};
 
#define MAXP 4096
#define NP 12
#define P (4294967296.0L * 4294967296.0L * 2.0L) /* 2^65 */
static long double INVPREC = P;
static long double PREC = 1.0L/P;
#undef P
/*
* Defining FAST_LDOUBLE_CONVERSION results in a little bit faster
* version, which might be less accurate (about 1 bit) for long
* double. For 'normal' double it doesn't matter.
*/
/* #define FAST_LDOUBLE_CONVERSION */
 
static int
cvtl(long double number, int prec, int flags, char *signp, unsigned char fmtch,
char *startp, char *endp)
{
char *p, *t;
long double fract;
int dotrim, expcnt, gformat;
long double integer, tmp;
 
if ((expcnt = isspeciall(number, startp)))
return(expcnt);
 
dotrim = expcnt = gformat = 0;
/* fract = modfl(number, &integer); */
integer = number;
 
/* get an extra slot for rounding. */
t = ++startp;
 
p = endp - 1;
if (integer)
{
int i, lp=NP, pt=MAXP;
#ifndef FAST_LDOUBLE_CONVERSION
long double oint = integer, dd=1.0L;
#endif
if (integer > INVPREC)
{
integer *= PREC;
while(lp >= 0) {
if (integer >= pten[lp])
{
expcnt += pt;
integer *= ptenneg[lp];
#ifndef FAST_LDOUBLE_CONVERSION
dd *= pten[lp];
#endif
}
pt >>= 1;
lp--;
}
#ifndef FAST_LDOUBLE_CONVERSION
integer = oint/dd;
#else
integer *= INVPREC;
#endif
}
/*
* Do we really need this ?
*/
for (i = 0; i < expcnt; i++)
*p-- = '0';
}
number = integer;
// fract = modfl(number, &integer);
/*
* get integer portion of number; put into the end of the buffer; the
* .01 is added for modf(356.0 / 10, &integer) returning .59999999...
*/
for (; integer; ++expcnt)
{
// tmp = modfl(integer * 0.1L , &integer);
*p-- = tochar((int)((tmp + .01L) * 10));
}
switch(fmtch)
{
case 'f':
/* reverse integer into beginning of buffer */
if (expcnt)
for (; ++p < endp; *t++ = *p);
else
*t++ = '0';
/*
* if precision required or alternate flag set, add in a
* decimal point.
*/
if (prec || flags&ALT)
*t++ = decimal;
/* if requires more precision and some fraction left */
if (fract)
{
if (prec)
do {
// fract = modfl(fract * 10.0L, &tmp);
*t++ = tochar((int)tmp);
} while (--prec && fract);
if (fract)
startp = roundl(fract, (int *)NULL, startp,
t - 1, (char)0, signp);
}
for (; prec--; *t++ = '0');
break;
case 'e':
case 'E':
eformat:
if (expcnt)
{
*t++ = *++p;
if (prec || flags&ALT)
*t++ = decimal;
/* if requires more precision and some integer left */
for (; prec && ++p < endp; --prec)
*t++ = *p;
/*
* if done precision and more of the integer component,
* round using it; adjust fract so we don't re-round
* later.
*/
if (!prec && ++p < endp)
{
fract = 0;
startp = roundl((long double)0.0L, &expcnt,
startp, t - 1, *p, signp);
}
/* adjust expcnt for digit in front of decimal */
--expcnt;
}
/* until first fractional digit, decrement exponent */
else if (fract)
{
int lp=NP, pt=MAXP;
#ifndef FAST_LDOUBLE_CONVERSION
long double ofract = fract, dd=1.0L;
#endif
expcnt = -1;
if (fract < PREC)
{
fract *= INVPREC;
while(lp >= 0)
{
if (fract <= ptenneg[lp])
{
expcnt -= pt;
fract *= pten[lp];
#ifndef FAST_LDOUBLE_CONVERSION
dd *= pten[lp];
#endif
}
pt >>= 1;
lp--;
}
#ifndef FAST_LDOUBLE_CONVERSION
fract = ofract*dd;
#else
fract *= PREC;
#endif
}
/* adjust expcnt for digit in front of decimal */
for ( /* expcnt = -1 */ ;; --expcnt)
{
// fract = modfl(fract * 10.0L, &tmp);
if (tmp)
break;
}
*t++ = tochar((int)tmp);
if (prec || flags&ALT)
*t++ = decimal;
}
else
{
*t++ = '0';
if (prec || flags&ALT)
*t++ = decimal;
}
/* if requires more precision and some fraction left */
if (fract)
{
if (prec)
do {
// fract = modfl(fract * 10.0L, &tmp);
*t++ = tochar((int)tmp);
} while (--prec && fract);
if (fract)
startp = roundl(fract, &expcnt, startp,
t - 1, (char)0, signp);
}
/* if requires more precision */
for (; prec--; *t++ = '0');
 
/* unless alternate flag, trim any g/G format trailing 0's */
if (gformat && !(flags&ALT))
{
while (t > startp && *--t == '0');
if (*t == decimal)
--t;
++t;
}
t = exponentl(t, expcnt, fmtch);
break;
case 'g':
case 'G':
/* a precision of 0 is treated as a precision of 1. */
if (!prec)
++prec;
/*
* ``The style used depends on the value converted; style e
* will be used only if the exponent resulting from the
* conversion is less than -4 or greater than the precision.''
* -- ANSI X3J11
*/
if (expcnt > prec || (!expcnt && fract && fract < .0001))
{
/*
* g/G format counts "significant digits, not digits of
* precision; for the e/E format, this just causes an
* off-by-one problem, i.e. g/G considers the digit
* before the decimal point significant and e/E doesn't
* count it as precision.
*/
--prec;
fmtch -= 2; /* G->E, g->e */
gformat = 1;
goto eformat;
}
/*
* reverse integer into beginning of buffer,
* note, decrement precision
*/
if (expcnt)
for (; ++p < endp; *t++ = *p, --prec);
else
*t++ = '0';
/*
* if precision required or alternate flag set, add in a
* decimal point. If no digits yet, add in leading 0.
*/
if (prec || flags&ALT)
{
dotrim = 1;
*t++ = decimal;
}
else
dotrim = 0;
/* if requires more precision and some fraction left */
while (prec && fract)
{
// fract = modfl(fract * 10.0L, &tmp);
*t++ = tochar((int)tmp);
prec--;
}
if (fract)
startp = roundl(fract, (int *)NULL, startp, t - 1,
(char)0, signp);
/* alternate format, adds 0's for precision, else trim 0's */
if (flags&ALT)
for (; prec--; *t++ = '0');
else if (dotrim)
{
while (t > startp && *--t == '0');
if (*t != decimal)
++t;
}
}
return t - startp;
}
 
static char *
roundl(long double fract, int *expv, char *start, char *end, char ch,
char *signp)
{
long double tmp;
 
if (fract)
{
if (fract == 0.5L)
{
char *e = end;
if (*e == '.')
e--;
if (*e == '0' || *e == '2' || *e == '4'
|| *e == '6' || *e == '8')
{
tmp = 3.0;
goto start;
}
}
// (void)modfl(fract * 10.0L, &tmp);
}
else
tmp = todigit(ch);
start:
if (tmp > 4)
for (;; --end)
{
if (*end == decimal)
--end;
if (++*end <= '9')
break;
*end = '0';
if (end == start)
{
if (expv)
{ /* e/E; increment exponent */
*end = '1';
++*expv;
}
else
{ /* f; add extra digit */
*--end = '1';
--start;
}
break;
}
}
/* ``"%.3f", (double)-0.0004'' gives you a negative 0. */
else if (*signp == '-')
for (;; --end)
{
if (*end == decimal)
--end;
if (*end != '0')
break;
if (end == start)
*signp = 0;
}
return start;
}
 
static char * exponentl(char *p, int expv, unsigned char fmtch)
{
char *t;
char expbuf[MAXEXPLD];
 
*p++ = fmtch;
if (expv < 0)
{
expv = -expv;
*p++ = '-';
}
else
*p++ = '+';
t = expbuf + MAXEXPLD;
if (expv > 9)
{
do {
*--t = tochar(expv % 10);
} while ((expv /= 10) > 9);
*--t = tochar(expv);
for (; t < expbuf + MAXEXPLD; *p++ = *t++);
}
else
{
*p++ = '0';
*p++ = tochar(expv);
}
return p;
}
 
static int isspeciall(long double d, char *bufp)
{
struct IEEExp {
unsigned manl:32;
unsigned manh:32;
unsigned exp:15;
unsigned sign:1;
} *ip = (struct IEEExp *)&d;
 
nan2 = 0; /* don't assume the static is 0 (emacs) */
if (ip->exp != 0x7fff)
return(0);
if ((ip->manh & 0x7fffffff) || ip->manl)
{
strcpy(bufp, "NaN");
nan2 = 1; /* kludge: we don't need the sign, it's not nice
but it should work */
}
else
(void)strcpy(bufp, "Inf");
return(3);
}
 
 
 
/programs/games/doom/trunk/kolibc/src/string/doscan.c
0,0 → 1,354
 
//#include <stdio.h>
//#include <stdlib.h>
#include "ctype.h"
 
//#include <libc/file.h>
//#include <libc/local.h>
 
#define SPC 01
#define STP 02
 
#define SHORT 0
#define REGULAR 1
#define LONG 2
#define LONGDOUBLE 4
#define INT 0
#define FLOAT 1
 
//static int _innum(int **ptr, int type, int len, int size, FILE *iop,
// int (*scan_getc)(FILE *), int (*scan_ungetc)(int, FILE *),
// int *eofptr);
//static int _instr(char *ptr, int type, int len, FILE *iop,
// int (*scan_getc)(FILE *), int (*scan_ungetc)(int, FILE *),
// int *eofptr);
//static const char *_getccl(const unsigned char *s);
 
static char _sctab[256] = {
0,0,0,0,0,0,0,0,
0,SPC,SPC,SPC,SPC,SPC,0,0,
0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,
SPC,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,0,0,0,0,0,
};
 
static int nchars = 0;
 
//int
//_doscan(FILE *iop, const char *fmt, void **argp)
//{
// return(_doscan_low(iop, fgetc, ungetc, fmt, argp));
//}
 
int _doscan_low(char *src, const char *fmt, void **argp)
{
int ch;
int nmatch, len, ch1;
int **ptr, fileended, size;
 
nchars = 0;
nmatch = 0;
fileended = 0;
for (;;) switch (ch = *fmt++) {
case '\0':
return (nmatch);
case '%':
if ((ch = *fmt++) == '%')
goto def;
if (ch == 'n')
{
**(int **)argp++ = nchars;
break;
}
if (fileended)
return(nmatch? nmatch: -1);
ptr = 0;
if (ch != '*')
ptr = (int **)argp++;
else
ch = *fmt++;
len = 0;
size = REGULAR;
while (isdigit(ch)) {
len = len*10 + ch - '0';
ch = *fmt++;
}
if (len == 0)
len = 30000;
if (ch=='l') {
size = LONG;
ch = *fmt++;
} else if (ch=='h') {
size = SHORT;
ch = *fmt++;
} else if (ch=='L') {
size = LONGDOUBLE;
ch = *fmt++;
} else if (ch=='[')
fmt = _getccl((const unsigned char *)fmt);
if (isupper(ch)) {
/* ch = tolower(ch);
gcc gives warning: ANSI C forbids braced
groups within expressions */
ch += 'a' - 'A';
size = LONG;
}
if (ch == '\0')
return(-1);
if (_innum(ptr, ch, len, size, src, &fileended) && ptr)
nmatch++;
/* breaks %n */
/* if (fileended) {
return(nmatch? nmatch: -1);
} */
break;
case ' ':
case '\n':
case '\t':
case '\r':
case '\f':
case '\v':
while (((nchars++, ch1 = scan_getc(iop))!=EOF) && (_sctab[ch1] & SPC))
;
if (ch1 != EOF)
{
scan_ungetc(ch1, iop);
}
nchars--;
break;
 
default:
def:
ch1 = scan_getc(iop);
if (ch1 != EOF) nchars++;
if (ch1 != ch) {
if (ch1==EOF)
return(-1);
scan_ungetc(ch1, iop);
nchars--;
return(nmatch);
}
}
}
 
static int
_innum(int **ptr, int type, int len, int size, FILE *iop,
int (*scan_getc)(FILE *), int (*scan_ungetc)(int, FILE *), int *eofptr)
{
register char *np;
char numbuf[64];
register c, base;
int expseen, scale, negflg, c1, ndigit;
long lcval;
int cpos;
 
if (type=='c' || type=='s' || type=='[')
return(_instr(ptr? *(char **)ptr: (char *)NULL, type, len,
iop, scan_getc, scan_ungetc, eofptr));
lcval = 0;
ndigit = 0;
scale = INT;
if (type=='e'||type=='f'||type=='g')
scale = FLOAT;
base = 10;
if (type=='o')
base = 8;
else if (type=='x')
base = 16;
np = numbuf;
expseen = 0;
negflg = 0;
while (((nchars++, c = scan_getc(iop)) != EOF) && (_sctab[c] & SPC))
;
if (c == EOF) nchars--;
if (c=='-') {
negflg++;
*np++ = c;
c = scan_getc(iop);
nchars++;
len--;
} else if (c=='+') {
len--;
c = scan_getc(iop);
nchars++;
}
cpos = 0;
for ( ; --len>=0; *np++ = c, c = scan_getc(iop), nchars++) {
cpos++;
if (c == '0' && cpos == 1 && type == 'i')
base = 8;
if ((c == 'x' || c == 'X') && (type == 'i' || type == 'x')
&& cpos == 2 && lcval == 0)
{
base = 16;
continue;
}
if (isdigit(c)
|| (base==16 && (('a'<=c && c<='f') || ('A'<=c && c<='F')))) {
ndigit++;
if (base==8)
lcval <<=3;
else if (base==10)
lcval = ((lcval<<2) + lcval)<<1;
else
lcval <<= 4;
c1 = c;
if (isdigit(c))
c -= '0';
else if ('a'<=c && c<='f')
c -= 'a'-10;
else
c -= 'A'-10;
lcval += c;
c = c1;
continue;
} else if (c=='.') {
if (base!=10 || scale==INT)
break;
ndigit++;
continue;
} else if ((c=='e'||c=='E') && expseen==0) {
if (base!=10 || scale==INT || ndigit==0)
break;
expseen++;
*np++ = c;
c = scan_getc(iop);
nchars++;
if (c!='+'&&c!='-'&&('0'>c||c>'9'))
break;
} else
break;
}
if (negflg)
lcval = -lcval;
if (c != EOF) {
scan_ungetc(c, iop);
*eofptr = 0;
} else
*eofptr = 1;
nchars--;
if (ptr==NULL || np==numbuf || (negflg && np==numbuf+1) ) /* gene dykes*/
return(0);
*np++ = 0;
switch((scale<<4) | size) {
 
case (FLOAT<<4) | SHORT:
case (FLOAT<<4) | REGULAR:
**(float **)ptr = atof(numbuf);
break;
 
case (FLOAT<<4) | LONG:
**(double **)ptr = atof(numbuf);
break;
 
case (FLOAT<<4) | LONGDOUBLE:
**(long double **)ptr = _atold(numbuf);
break;
 
case (INT<<4) | SHORT:
**(short **)ptr = (short)lcval;
break;
 
case (INT<<4) | REGULAR:
**(int **)ptr = (int)lcval;
break;
 
case (INT<<4) | LONG:
case (INT<<4) | LONGDOUBLE:
**(long **)ptr = lcval;
break;
}
return(1);
}
 
static int
_instr(char *ptr, int type, int len, FILE *iop,
int (*scan_getc)(FILE *), int (*scan_ungetc)(int, FILE *), int *eofptr)
{
register ch;
register char *optr;
int ignstp;
 
*eofptr = 0;
optr = ptr;
if (type=='c' && len==30000)
len = 1;
ignstp = 0;
if (type=='s')
ignstp = SPC;
while ((nchars++, ch = scan_getc(iop)) != EOF && _sctab[ch] & ignstp)
;
ignstp = SPC;
if (type=='c')
ignstp = 0;
else if (type=='[')
ignstp = STP;
while (ch!=EOF && (_sctab[ch]&ignstp)==0) {
if (ptr)
*ptr++ = ch;
if (--len <= 0)
break;
ch = scan_getc(iop);
nchars++;
}
if (ch != EOF) {
if (len > 0)
{
scan_ungetc(ch, iop);
nchars--;
}
*eofptr = 0;
} else
{
nchars--;
*eofptr = 1;
}
if (ptr && ptr!=optr) {
if (type!='c')
*ptr++ = '\0';
return(1);
}
return(0);
}
 
static const char *
_getccl(const unsigned char *s)
{
register c, t;
 
t = 0;
if (*s == '^') {
t++;
s++;
}
for (c = 0; c < (sizeof _sctab / sizeof _sctab[0]); c++)
if (t)
_sctab[c] &= ~STP;
else
_sctab[c] |= STP;
if ((c = *s) == ']' || c == '-') { /* first char is special */
if (t)
_sctab[c] |= STP;
else
_sctab[c] &= ~STP;
s++;
}
while ((c = *s++) != ']') {
if (c==0)
return((const char *)--s);
else if (c == '-' && *s != ']' && s[-2] < *s) {
for (c = s[-2] + 1; c < *s; c++)
if (t)
_sctab[c] |= STP;
else
_sctab[c] &= ~STP;
} else if (t)
_sctab[c] |= STP;
else
_sctab[c] &= ~STP;
}
return((const char *)s);
}
/programs/games/doom/trunk/kolibc/src/string/is.c
0,0 → 1,20
#include "ctype.h"
 
short int _is[128] = {
0x004, 0x004, 0x004, 0x004, 0x004, 0x004, 0x004, 0x004,
0x004, 0x104, 0x104, 0x104, 0x104, 0x104, 0x004, 0x004,
0x004, 0x004, 0x004, 0x004, 0x004, 0x004, 0x004, 0x004,
0x004, 0x004, 0x004, 0x004, 0x004, 0x004, 0x004, 0x004,
0x140, 0x0D0, 0x0D0, 0x0D0, 0x0D0, 0x0D0, 0x0D0, 0x0D0,
0x0D0, 0x0D0, 0x0D0, 0x0D0, 0x0D0, 0x0D0, 0x0D0, 0x0D0,
0x459, 0x459, 0x459, 0x459, 0x459, 0x459, 0x459, 0x459,
0x459, 0x459, 0x0D0, 0x0D0, 0x0D0, 0x0D0, 0x0D0, 0x0D0,
0x0D0, 0x653, 0x653, 0x653, 0x653, 0x653, 0x653, 0x253,
0x253, 0x253, 0x253, 0x253, 0x253, 0x253, 0x253, 0x253,
0x253, 0x253, 0x253, 0x253, 0x253, 0x253, 0x253, 0x253,
0x253, 0x253, 0x253, 0x0D0, 0x0D0, 0x0D0, 0x0D0, 0x0D0,
0x0D0, 0x473, 0x473, 0x473, 0x473, 0x473, 0x473, 0x073,
0x073, 0x073, 0x073, 0x073, 0x073, 0x073, 0x073, 0x073,
0x073, 0x073, 0x073, 0x073, 0x073, 0x073, 0x073, 0x073,
0x073, 0x073, 0x073, 0x0D0, 0x0D0, 0x0D0, 0x0D0, 0x004
};
/programs/games/doom/trunk/kolibc/src/string/istable.c
0,0 → 1,263
#include "kolibc.h"
 
const char _IsTable[257] = {
 
#define ___0__ 0
 
/* -1,EOF */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* 00,NUL */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|_CNTRL,
/* 01,SOH */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|_CNTRL,
/* 02,STX */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|_CNTRL,
/* 03,ETX */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|_CNTRL,
/* 04,EOT */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|_CNTRL,
/* 05,ENQ */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|_CNTRL,
/* 06,NAK */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|_CNTRL,
/* 07,BEL */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|_CNTRL,
/* 08,BS */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|_CNTRL,
/* 09,TAB */ ___0__|___0__|___0__|___0__|___0__|___0__|_SPACE|_CNTRL,
/* 0A,LF */ ___0__|___0__|___0__|___0__|___0__|___0__|_SPACE|_CNTRL,
/* 0B,VT */ ___0__|___0__|___0__|___0__|___0__|___0__|_SPACE|_CNTRL,
/* 0C,FF */ ___0__|___0__|___0__|___0__|___0__|___0__|_SPACE|_CNTRL,
/* 0D,CR */ ___0__|___0__|___0__|___0__|___0__|___0__|_SPACE|_CNTRL,
/* 0E,SI */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|_CNTRL,
/* 0F,SO */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|_CNTRL,
/* 10, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|_CNTRL,
/* 11, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|_CNTRL,
/* 12, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|_CNTRL,
/* 13, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|_CNTRL,
/* 14, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|_CNTRL,
/* 15, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|_CNTRL,
/* 16, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|_CNTRL,
/* 17, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|_CNTRL,
/* 18, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|_CNTRL,
/* 19, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|_CNTRL,
/* 1A, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|_CNTRL,
/* 1B, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|_CNTRL,
/* 1C, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|_CNTRL,
/* 1D, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|_CNTRL,
/* 1E, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|_CNTRL,
/* 1F, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|_CNTRL,
/* 20, */ ___0__|___0__|___0__|___0__|_PRINT|___0__|_SPACE|___0__,
/* 21, ! */ ___0__|___0__|___0__|___0__|_PRINT|_PUNCT|___0__|___0__,
/* 22, " */ ___0__|___0__|___0__|___0__|_PRINT|_PUNCT|___0__|___0__,
/* 23, # */ ___0__|___0__|___0__|___0__|_PRINT|_PUNCT|___0__|___0__,
/* 24, $ */ ___0__|___0__|___0__|___0__|_PRINT|_PUNCT|___0__|___0__,
/* 25, % */ ___0__|___0__|___0__|___0__|_PRINT|_PUNCT|___0__|___0__,
/* 26, & */ ___0__|___0__|___0__|___0__|_PRINT|_PUNCT|___0__|___0__,
/* 27, ' */ ___0__|___0__|___0__|___0__|_PRINT|_PUNCT|___0__|___0__,
/* 28, ( */ ___0__|___0__|___0__|___0__|_PRINT|_PUNCT|___0__|___0__,
/* 29, ) */ ___0__|___0__|___0__|___0__|_PRINT|_PUNCT|___0__|___0__,
/* 2A, * */ ___0__|___0__|___0__|___0__|_PRINT|_PUNCT|___0__|___0__,
/* 2B, + */ ___0__|___0__|___0__|___0__|_PRINT|_PUNCT|___0__|___0__,
/* 2C, , */ ___0__|___0__|___0__|___0__|_PRINT|_PUNCT|___0__|___0__,
/* 2D, - */ ___0__|___0__|___0__|___0__|_PRINT|_PUNCT|___0__|___0__,
/* 2E, . */ ___0__|___0__|___0__|___0__|_PRINT|_PUNCT|___0__|___0__,
/* 2F, / */ ___0__|___0__|___0__|___0__|_PRINT|_PUNCT|___0__|___0__,
/* 30, 0 */ ___0__|___0__|_DIGIT|_XDIGT|_PRINT|___0__|___0__|___0__,
/* 31, 1 */ ___0__|___0__|_DIGIT|_XDIGT|_PRINT|___0__|___0__|___0__,
/* 32, 2 */ ___0__|___0__|_DIGIT|_XDIGT|_PRINT|___0__|___0__|___0__,
/* 33, 3 */ ___0__|___0__|_DIGIT|_XDIGT|_PRINT|___0__|___0__|___0__,
/* 34, 4 */ ___0__|___0__|_DIGIT|_XDIGT|_PRINT|___0__|___0__|___0__,
/* 35, 5 */ ___0__|___0__|_DIGIT|_XDIGT|_PRINT|___0__|___0__|___0__,
/* 36, 6 */ ___0__|___0__|_DIGIT|_XDIGT|_PRINT|___0__|___0__|___0__,
/* 37, 7 */ ___0__|___0__|_DIGIT|_XDIGT|_PRINT|___0__|___0__|___0__,
/* 38, 8 */ ___0__|___0__|_DIGIT|_XDIGT|_PRINT|___0__|___0__|___0__,
/* 39, 9 */ ___0__|___0__|_DIGIT|_XDIGT|_PRINT|___0__|___0__|___0__,
/* 3A, : */ ___0__|___0__|___0__|___0__|_PRINT|_PUNCT|___0__|___0__,
/* 3B, ; */ ___0__|___0__|___0__|___0__|_PRINT|_PUNCT|___0__|___0__,
/* 3C, < */ ___0__|___0__|___0__|___0__|_PRINT|_PUNCT|___0__|___0__,
/* 3D, = */ ___0__|___0__|___0__|___0__|_PRINT|_PUNCT|___0__|___0__,
/* 3E, > */ ___0__|___0__|___0__|___0__|_PRINT|_PUNCT|___0__|___0__,
/* 3F, ? */ ___0__|___0__|___0__|___0__|_PRINT|_PUNCT|___0__|___0__,
/* 40, @ */ ___0__|___0__|___0__|___0__|_PRINT|_PUNCT|___0__|___0__,
/* 41, A */ ___0__|_UPPER|___0__|_XDIGT|_PRINT|___0__|___0__|___0__,
/* 42, B */ ___0__|_UPPER|___0__|_XDIGT|_PRINT|___0__|___0__|___0__,
/* 43, C */ ___0__|_UPPER|___0__|_XDIGT|_PRINT|___0__|___0__|___0__,
/* 44, D */ ___0__|_UPPER|___0__|_XDIGT|_PRINT|___0__|___0__|___0__,
/* 45, E */ ___0__|_UPPER|___0__|_XDIGT|_PRINT|___0__|___0__|___0__,
/* 46, F */ ___0__|_UPPER|___0__|_XDIGT|_PRINT|___0__|___0__|___0__,
/* 47, G */ ___0__|_UPPER|___0__|___0__|_PRINT|___0__|___0__|___0__,
/* 48, H */ ___0__|_UPPER|___0__|___0__|_PRINT|___0__|___0__|___0__,
/* 49, I */ ___0__|_UPPER|___0__|___0__|_PRINT|___0__|___0__|___0__,
/* 4A, J */ ___0__|_UPPER|___0__|___0__|_PRINT|___0__|___0__|___0__,
/* 4B, K */ ___0__|_UPPER|___0__|___0__|_PRINT|___0__|___0__|___0__,
/* 4C, L */ ___0__|_UPPER|___0__|___0__|_PRINT|___0__|___0__|___0__,
/* 4D, M */ ___0__|_UPPER|___0__|___0__|_PRINT|___0__|___0__|___0__,
/* 4E, N */ ___0__|_UPPER|___0__|___0__|_PRINT|___0__|___0__|___0__,
/* 4F, O */ ___0__|_UPPER|___0__|___0__|_PRINT|___0__|___0__|___0__,
/* 50, P */ ___0__|_UPPER|___0__|___0__|_PRINT|___0__|___0__|___0__,
/* 51, Q */ ___0__|_UPPER|___0__|___0__|_PRINT|___0__|___0__|___0__,
/* 52, R */ ___0__|_UPPER|___0__|___0__|_PRINT|___0__|___0__|___0__,
/* 53, S */ ___0__|_UPPER|___0__|___0__|_PRINT|___0__|___0__|___0__,
/* 54, T */ ___0__|_UPPER|___0__|___0__|_PRINT|___0__|___0__|___0__,
/* 55, U */ ___0__|_UPPER|___0__|___0__|_PRINT|___0__|___0__|___0__,
/* 56, V */ ___0__|_UPPER|___0__|___0__|_PRINT|___0__|___0__|___0__,
/* 57, W */ ___0__|_UPPER|___0__|___0__|_PRINT|___0__|___0__|___0__,
/* 58, X */ ___0__|_UPPER|___0__|___0__|_PRINT|___0__|___0__|___0__,
/* 59, Y */ ___0__|_UPPER|___0__|___0__|_PRINT|___0__|___0__|___0__,
/* 5A, Z */ ___0__|_UPPER|___0__|___0__|_PRINT|___0__|___0__|___0__,
/* 5B, [ */ ___0__|___0__|___0__|___0__|_PRINT|_PUNCT|___0__|___0__,
/* 5C, \ */ ___0__|___0__|___0__|___0__|_PRINT|_PUNCT|___0__|___0__,
/* 5D, ] */ ___0__|___0__|___0__|___0__|_PRINT|_PUNCT|___0__|___0__,
/* 5E, ^ */ ___0__|___0__|___0__|___0__|_PRINT|_PUNCT|___0__|___0__,
/* 5F, _ */ ___0__|___0__|___0__|___0__|_PRINT|_PUNCT|___0__|___0__,
/* 60, ` */ ___0__|___0__|___0__|___0__|_PRINT|_PUNCT|___0__|___0__,
/* 61, a */ _LOWER|___0__|___0__|_XDIGT|_PRINT|___0__|___0__|___0__,
/* 62, b */ _LOWER|___0__|___0__|_XDIGT|_PRINT|___0__|___0__|___0__,
/* 63, c */ _LOWER|___0__|___0__|_XDIGT|_PRINT|___0__|___0__|___0__,
/* 64, d */ _LOWER|___0__|___0__|_XDIGT|_PRINT|___0__|___0__|___0__,
/* 65, e */ _LOWER|___0__|___0__|_XDIGT|_PRINT|___0__|___0__|___0__,
/* 66, f */ _LOWER|___0__|___0__|_XDIGT|_PRINT|___0__|___0__|___0__,
/* 67, g */ _LOWER|___0__|___0__|___0__|_PRINT|___0__|___0__|___0__,
/* 68, h */ _LOWER|___0__|___0__|___0__|_PRINT|___0__|___0__|___0__,
/* 69, i */ _LOWER|___0__|___0__|___0__|_PRINT|___0__|___0__|___0__,
/* 6A, j */ _LOWER|___0__|___0__|___0__|_PRINT|___0__|___0__|___0__,
/* 6B, k */ _LOWER|___0__|___0__|___0__|_PRINT|___0__|___0__|___0__,
/* 6C, l */ _LOWER|___0__|___0__|___0__|_PRINT|___0__|___0__|___0__,
/* 6D, m */ _LOWER|___0__|___0__|___0__|_PRINT|___0__|___0__|___0__,
/* 6E, n */ _LOWER|___0__|___0__|___0__|_PRINT|___0__|___0__|___0__,
/* 6F, o */ _LOWER|___0__|___0__|___0__|_PRINT|___0__|___0__|___0__,
/* 70, p */ _LOWER|___0__|___0__|___0__|_PRINT|___0__|___0__|___0__,
/* 71, q */ _LOWER|___0__|___0__|___0__|_PRINT|___0__|___0__|___0__,
/* 72, r */ _LOWER|___0__|___0__|___0__|_PRINT|___0__|___0__|___0__,
/* 73, s */ _LOWER|___0__|___0__|___0__|_PRINT|___0__|___0__|___0__,
/* 74, t */ _LOWER|___0__|___0__|___0__|_PRINT|___0__|___0__|___0__,
/* 75, u */ _LOWER|___0__|___0__|___0__|_PRINT|___0__|___0__|___0__,
/* 76, v */ _LOWER|___0__|___0__|___0__|_PRINT|___0__|___0__|___0__,
/* 77, w */ _LOWER|___0__|___0__|___0__|_PRINT|___0__|___0__|___0__,
/* 78, x */ _LOWER|___0__|___0__|___0__|_PRINT|___0__|___0__|___0__,
/* 79, y */ _LOWER|___0__|___0__|___0__|_PRINT|___0__|___0__|___0__,
/* 7A, z */ _LOWER|___0__|___0__|___0__|_PRINT|___0__|___0__|___0__,
/* 7B, { */ ___0__|___0__|___0__|___0__|_PRINT|_PUNCT|___0__|___0__,
/* 7C, | */ ___0__|___0__|___0__|___0__|_PRINT|_PUNCT|___0__|___0__,
/* 7D, } */ ___0__|___0__|___0__|___0__|_PRINT|_PUNCT|___0__|___0__,
/* 7E, ~ */ ___0__|___0__|___0__|___0__|_PRINT|_PUNCT|___0__|___0__,
/* 7F,DEL */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|_CNTRL,
/* 80, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* 81, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* 82, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* 83, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* 84, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* 85, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* 86, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* 87, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* 88, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* 89, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* 8A, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* 8B, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* 8C, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* 8D, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* 8E, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* 8F, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* 90, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* 91, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* 92, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* 93, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* 94, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* 95, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* 96, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* 97, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* 98, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* 99, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* 9A, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* 9B, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* 9C, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* 9D, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* 9E, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* 9F, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* A0, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* A1, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* A2, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* A3, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* A4, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* A5, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* A6, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* A7, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* A8, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* A9, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* AA, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* AB, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* AC, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* AD, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* AE, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* AF, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* B0, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* B1, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* B2, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* B3, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* B4, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* B5, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* B6, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* B7, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* B8, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* B9, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* BA, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* BB, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* BC, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* BD, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* BE, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* BF, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* C0, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* C1, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* C2, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* C3, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* C4, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* C5, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* C6, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* C7, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* C8, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* C9, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* CA, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* CB, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* CC, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* CD, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* CE, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* CF, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* D0, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* D1, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* D2, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* D3, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* D4, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* D5, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* D6, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* D7, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* D8, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* D9, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* DA, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* DB, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* DC, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* DD, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* DE, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* DF, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* E0, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* E1, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* E2, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* E3, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* E4, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* E5, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* E6, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* E7, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* E8, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* E9, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* EA, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* EB, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* EC, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* ED, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* EE, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* EF, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* F0, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* F1, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* F2, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* F3, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* F4, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* F5, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* F6, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* F7, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* F8, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* F9, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* FA, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* FB, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* FC, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* FD, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* FE, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__,
/* FF, */ ___0__|___0__|___0__|___0__|___0__|___0__|___0__|___0__ };
/programs/games/doom/trunk/kolibc/src/string/memchr.c
0,0 → 1,13
#include "string.h"
 
void* memchr(const void* buf,int c,int count)
{
int i;
for (i=0;i<count;i++)
if (*(char*)buf==c)
return (void*)buf;
else
((char*)buf)++;
return (void*)0;
}
 
/programs/games/doom/trunk/kolibc/src/string/sprintf.c
0,0 → 1,14
#include "kolibc.h"
 
int _doprnt(char *dest, size_t maxlen, const char *fmt,
va_list argp);
 
 
int sprintf(char *dest, const char *format,...)
{
va_list arg;
va_start (arg, format);
return _doprnt(dest,512, format, arg);
}
 
 
/programs/games/doom/trunk/kolibc/src/string/strcpy.c
0,0 → 1,7
 
char* strcpy(char* dst,const char* src)
{
char* res= dst;
while(*dst++ = *src++) ;
return res;
}
/programs/games/doom/trunk/kolibc/src/string/strlen.c
0,0 → 1,7
int strlen(const char* string)
{
int i;
i=0;
while (*string++) i++;
return i;
}
/programs/games/doom/trunk/kolibc/src/string/strncmp.c
0,0 → 1,12
int strncmp(const char* string1, const char* string2, int count)
{
while(count>0 && *string1==*string2)
{
if (*string1) return 0;
++string1;
++string2;
--count;
}
if(count) return (*string1 - *string2);
return 0;
}
/programs/games/doom/trunk/kolibc/src/string/strncpy.c
0,0 → 1,14
char* strncpy(char* strDest,const char* strSource,int count)
{
char* res;
res=strDest;
while (count>0)
{
*strDest=*strSource;
if (*strSource!='\0')
strSource++;
strDest++;
count--;
}
return res;
}
/programs/games/doom/trunk/kolibc/src/string/strrchr.c
0,0 → 1,14
char* strrchr(const char* s,int c)
{
char* res;
res=(char*)0;
while (1)
{
if (*s==(char)c)
res=(char*)s;
if (*s=='\0')
break;
s++;
}
return res;
}
/programs/games/doom/trunk/kolibc/src/string/strupr.c
0,0 → 1,13
#include "ctype.h"
#include "string.h"
 
char * strupr(char *_s)
{
char *rv = _s;
while (*_s)
{
*_s = toupper(*_s);
_s++;
}
return rv;
}
/programs/games/doom/trunk/kolibc/src/string/toupper.c
0,0 → 1,8
/*
** return upper-case of c if it is lower-case, else c
*/
char toupper(char c)
{
if(c<='z' && c>='a') return (c-32);
return (c);
}
/programs/games/doom/trunk/m_menu.c
1733,40 → 1733,42
static short y;
short i;
short max;
char *p;
int len;
char string[40];
int start;
 
inhelpscreens = false;
 
// Horiz. & Vertically center string and print it.
if (messageToPrint)
{
start = 0;
y = 100 - M_StringHeight(messageString)/2;
while(*(messageString+start))
p = messageString;
len = strlen(p);
while(*p)
{
for (i = 0;i < strlen(messageString+start);i++)
if (*(messageString+start+i) == '\n')
for (i = 0;len;i++,len--)
{
memset(string,0,40);
strncpy(string,messageString+start,40);
start += i+1;
if (*(p+i) == '\n')
{ memset(string,0,40);
strncpy(string,p,i);
p+= i+1;
len-= 1;
break;
}
};
};
if (i == strlen(messageString+start))
{
strcpy(string,messageString+start);
start += i;
}
if (len == 0)
{ strncpy(string,p,i);
p+=i;
};
x = 160 - M_StringWidth(string)/2;
M_WriteText(x,y,string);
y += SHORT(hu_font[0]->height);
}
};
return;
}
};
 
if (!menuactive)
return;
/programs/games/doom/trunk/m_misc.c
294,9 → 294,9
&& defaults[i].defaultvalue < 0xfff)
{
v = *defaults[i].location;
fprintf (f,"%s\t\t%i\n",defaults[i].name,v);
printf ("%s\t\t%i\n",defaults[i].name,v);
} else {
fprintf (f,"%s\t\t\"%s\"\n",defaults[i].name,
printf ("%s\t\t\"%s\"\n",defaults[i].name,
* (char **) (defaults[i].location));
}
}
335,7 → 335,7
}
else
defaultfile = basedefault;
/**********
// read the file in, overriding any set defaults
f = fopen (defaultfile, "r");
if (f)
373,6 → 373,7
fclose (f);
}
**********/
}
 
 
/programs/games/doom/trunk/v_video.c
38,8 → 38,8
#include "m_bbox.h"
 
#include "v_video.h"
#include "kolibri.h"
 
 
// Each screen is [SCREENWIDTH*SCREENHEIGHT];
byte* screens[5];
225,9 → 225,9
|| y+SHORT(patch->height)>SCREENHEIGHT
|| (unsigned)scrn>4)
{
fprintf( stderr, "Patch at %d,%d exceeds LFB\n", x,y );
printf("Patch at %d,%d exceeds LFB\n", x,y );
// No I_Error abort - what is up with TNT.WAD?
fprintf( stderr, "V_DrawPatch: bad patch (ignored)\n");
printf("V_DrawPatch: bad patch (ignored)\n");
return;
}
#endif
292,7 → 292,7
|| y+SHORT(patch->height)>SCREENHEIGHT
|| (unsigned)scrn>4)
{
fprintf( stderr, "Patch origin %d,%d exceeds LFB\n", x,y );
printf("Patch origin %d,%d exceeds LFB\n", x,y );
I_Error ("Bad V_DrawPatch in V_DrawPatchFlipped");
}
#endif
483,11 → 483,11
{
int i;
byte* base;
size_t size;
// stick these in low dos memory on PCs
size = SCREENWIDTH*SCREENHEIGHT*4;
base = (byte*)UserAlloc(size);
 
base = _aligned_malloc(SCREENWIDTH*SCREENHEIGHT*4, 128);I_AllocLow (SCREENWIDTH*SCREENHEIGHT*4);
 
for (i=0 ; i<4 ; i++)
screens[i] = base + i*SCREENWIDTH*SCREENHEIGHT;
}
/programs/games/doom/trunk/w_wad.c
515,6 → 515,7
return W_CacheLumpNum (W_GetNumForName(name), tag);
}
 
#if 0
 
//
// W_Profile
567,14 → 568,14
for ( ; j<8 ; j++)
name[j] = ' ';
 
fprintf (f,"%s ",name);
printf ("%s ",name);
 
for (j=0 ; j<profilecount ; j++)
fprintf (f," %c",info[i][j]);
 
fprintf (f,"\n");
printf ("\n");
}
fclose (f);
}
 
 
#endif
/programs/games/doom/trunk/wi_stuff.c
494,7 → 494,7
else
{
// DEBUG
// __libclog_printf("Could not place patch on level %d", n+1);
printf("Could not place patch on level %d", n+1);
}
}