/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); |
} |
} |