Subversion Repositories Kolibri OS

Compare Revisions

Ignore whitespace Rev 323 → Rev 324

/programs/games/doom/trunk/d_net.h
File deleted
/programs/games/doom/trunk/p_local.h
File deleted
/programs/games/doom/trunk/i_video.h
File deleted
/programs/games/doom/trunk/r_bsp.h
File deleted
/programs/games/doom/trunk/d_englsh.h
File deleted
/programs/games/doom/trunk/doomstat.h
File deleted
/programs/games/doom/trunk/hu_stuff.h
File deleted
/programs/games/doom/trunk/r_draw.h
File deleted
/programs/games/doom/trunk/r_things.h
File deleted
/programs/games/doom/trunk/st_lib.h
File deleted
/programs/games/doom/trunk/d_think.h
File deleted
/programs/games/doom/trunk/m_bbox.h
File deleted
/programs/games/doom/trunk/d_textur.h
File deleted
/programs/games/doom/trunk/f_wipe.h
File deleted
/programs/games/doom/trunk/m_menu.h
File deleted
/programs/games/doom/trunk/r_segs.h
File deleted
/programs/games/doom/trunk/m_misc.h
File deleted
/programs/games/doom/trunk/v_video.h
File deleted
/programs/games/doom/trunk/z_zone.h
File deleted
/programs/games/doom/trunk/d_event.h
File deleted
/programs/games/doom/trunk/d_french.h
File deleted
/programs/games/doom/trunk/r_plane.h
File deleted
/programs/games/doom/trunk/d_player.h
File deleted
/programs/games/doom/trunk/m_cheat.h
File deleted
/programs/games/doom/trunk/r_local.h
File deleted
/programs/games/doom/trunk/doomdata.h
File deleted
/programs/games/doom/trunk/i_sound.h
File deleted
/programs/games/doom/trunk/f_finale.h
File deleted
/programs/games/doom/trunk/r_sky.h
File deleted
/programs/games/doom/trunk/p_setup.h
File deleted
/programs/games/doom/trunk/i_system.h
File deleted
/programs/games/doom/trunk/d_items.h
File deleted
/programs/games/doom/trunk/st_stuff.h
File deleted
/programs/games/doom/trunk/m_random.h
File deleted
/programs/games/doom/trunk/wi_stuff.h
File deleted
/programs/games/doom/trunk/info.h
File deleted
/programs/games/doom/trunk/m_fixed.h
File deleted
/programs/games/doom/trunk/am_map.h
File deleted
/programs/games/doom/trunk/dstrings.h
File deleted
/programs/games/doom/trunk/hu_lib.h
File deleted
/programs/games/doom/trunk/d_main.h
File deleted
/programs/games/doom/trunk/s_sound.h
File deleted
/programs/games/doom/trunk/m_argv.h
File deleted
/programs/games/doom/trunk/g_game.h
File deleted
/programs/games/doom/trunk/m_swap.h
File deleted
/programs/games/doom/trunk/p_mobj.h
File deleted
/programs/games/doom/trunk/tables.h
File deleted
/programs/games/doom/trunk/r_defs.h
File deleted
/programs/games/doom/trunk/p_tick.h
File deleted
/programs/games/doom/trunk/p_spec.h
File deleted
/programs/games/doom/trunk/sounds.h
File deleted
/programs/games/doom/trunk/r_main.h
File deleted
/programs/games/doom/trunk/w_wad.h
File deleted
/programs/games/doom/trunk/r_data.h
File deleted
/programs/games/doom/trunk/p_pspr.h
File deleted
/programs/games/doom/trunk/d_ticcmd.h
File deleted
/programs/games/doom/trunk/p_inter.h
File deleted
/programs/games/doom/trunk/doomdef.h
File deleted
/programs/games/doom/trunk/doomtype.h
File deleted
/programs/games/doom/trunk/r_state.h
File deleted
/programs/games/doom/trunk/i_net.h
File deleted
/programs/games/doom/trunk/p_saveg.h
File deleted
/programs/games/doom/trunk/kolibc/include/kolibc.h
15,9 → 15,11
typedef unsigned int fpos_t;
typedef unsigned int size_t;
 
#define NULL (void*)0
#//define NULL (void*)0
 
typedef enum SEEKPOS {SEEK_SET=0,SEEK_CUR,SEEK_END};
#define SEEK_SET 0
#define SEEK_CUR 1
#define SEEK_END 2
 
#define FILE_OPEN_READ 0x01
#define FILE_OPEN_WRITE 0x02
111,6 → 113,7
 
#define abs(i) (((i)<0)?(-(i)):(i))
 
#if 0
extern int atoib(char *s,int b);
extern int atoi(char *s);
extern char tolower(char c);
139,19 → 142,36
#define isascii(char) ( (unsigned)char < 0x80 )
 
extern void* memchr(const void*,int,int);
extern extern void* memchr(const void*,int,int);
extern int memcmp(const void*,const void*,int);
extern void* memcpy(void*,const void*,int);
extern void* memcpy(void*,const void*,size_t);
void kmemset (void *dst, int val, size_t count);
 
extern void* memmove(void*,const void*,int);
extern void* memset(void*,int,int);
int memcmp(const void*,const void*,int);
extern void* memcpy(void*,const void*,size_t);
void kmemset (void *dst, int val, size_t count);
 
extern void *malloc(size_t size);
extern void* realloc(void* oldmem, size_t bytes);
extern void free(void *mem);
extern void* memmove(void*,const void*,int);
extern void* memset(void*,int,int);
 
#endif
 
void debug_out_str(char* str);
 
void* _cdecl dlmalloc(size_t size);
void* _cdecl dlrealloc(void* oldmem, size_t bytes);
void _cdecl dlfree(void *mem);
 
//double pow_test(x,y);
 
 
#ifdef __cplusplus
extern "C"
}
#endif
 
#endif //kolibc_h
#endif //kolibc_h
 
 
/programs/games/doom/trunk/kolibc/include/kolibri.h
64,6 → 64,8
 
void _stdcall InitHeap(int heap_size);
void* _stdcall UserAlloc(int size);
int _stdcall UserFree(void* p);
void _stdcall GetNotify(DWORD *event);
 
//void _stdcall CreateThread(void *fn, char *p_stack);
82,13 → 84,16
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);
int _stdcall get_fileinfo(const char *name,FILEINFO* pinfo);
int _stdcall read_file (const char *name,char*buff,DWORD offset, DWORD count,DWORD *reads);
int _stdcall write_file(const char *name,char*buff,int offset,int count,int *writes);
 
//void exit();
int _cdecl get_key(void);
int _stdcall get_key(int *key);
int _stdcall remap_key(int key);
 
int _cdecl get_button_id();
 
void delay(int val);
int wait_for_event(int time);
int wait_for_event_infinite();
/programs/games/doom/trunk/kolibc/include/mf.h
1,91 → 1,100
#include "kolibc.h"
 
 
 
//#include "kolibc.h"
 
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
 
typedef unsigned int dword;
typedef unsigned int size_t;
 
 
#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)))
 
 
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;
 
typedef 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];
};
 
 
void _cdecl mf_init();
void* _cdecl dlmalloc(size_t);
void* _cdecl dlrealloc(void *,size_t);
void _cdecl dlfree(void*);
 
 
dword compute_tree_index(size_t s);
 
static void insert_chunk(mchunkptr P, size_t S);
static void insert_large_chunk(tchunkptr X, size_t S);
 
static 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)))
 
 
#ifdef __cplusplus
}
#endif /* __cplusplus */
 
 
 
/programs/games/doom/trunk/kolibc/src/file/fclose.c
6,13 → 6,13
{
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);
// if((file->mode & FILE_OPEN_WRITE)||
// (file->mode & FILE_OPEN_APPEND)||
// (file->mode & FILE_OPEN_PLUS))
// err=write_buffer(file);
// UserFree dlfree(file->buffer);
dlfree(file->filename);
dlfree(file);
return err == 0 ? 0:EOF;
}
}
/programs/games/doom/trunk/kolibc/src/file/fgetc.c
9,7 → 9,7
return EOF;
 
if(f->remain ==0)
{ f->filepos+=4096;
{ f->filepos+=8192;
if(!fill_buff(f))
return EOF;
};
/programs/games/doom/trunk/kolibc/src/file/fopen.c
1,98 → 1,126
 
#include "kolibri.h"
#include <string.h>
#include <malloc.h>
#include "kolibc.h"
#include "kolibri.h"
 
extern struct{int argc; char** argv;} __ARGS;
extern char *__appcwd;
extern int __appcwdlen;
 
char* getfullpath(const char* relpath){
byte prev_is_slash=0;
char* getfullpath(char* path)
{
int 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));
char c;
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++;
len= __appcwdlen;
buff = (char*)malloc(len+strlen(path)+1);
strncpy(buff, __appcwd, __appcwdlen);
if(*path == '/')
{ buff[0] = '\0';
len=0;
}
else
{
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;
}
}
while(c=*path++)
{
switch (c)
{
case '.':
if((*path == '.')&&
(*path+1)== '/')
{ if(!depth)
{ free(buff);
return 0;
};
buff[len-1] = 0;
len = strrchr(buff, '/') + 1 - buff;
buff[len] = 0;
depth--;
path +=2;
prev_is_slash = 1;
continue;
}
if(*path == '/')
{
path++;
prev_is_slash = 1;
continue;
}
buff[len++] = c;
continue;
case '/':
prev_is_slash = 1;
buff[len++] = c;
continue;
default:
prev_is_slash = 0;
buff[len++] = c;
continue;
};
};
buff[len]= '\0';
*************/
return buff;
}
 
FILE* fopen(const char* filename, const char *mode)
{
FILEINFO fileinfo;
FILE* res;
FILEINFO fileinfo;
FILE* res;
char *path;
int err;
int imode;
int err;
int imode;
size_t bytes;
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);
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)
{
107,40 → 135,46
}
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=(FILE*)malloc(sizeof(FILE));
if(!res)
{ free(path);
return 0;
};
 
res->buffer=UserAlloc(8192);
res->stream=res->buffer;
res->strpos=0;
res->remain=8192;
res->buffersize=8192;
res->filesize=fileinfo.size;
res->filename=path;
res->mode=imode;
if (imode & FILE_OPEN_APPEND)
{ size_t bytes;
res->strpos= res->filesize & 4095;
res->strpos= res->filesize & 8191;
if (res->strpos) //not align
{
res->filepos=res->filesize & -4096; // align buffer
res->remain=4096-res->strpos;
res->filepos=res->filesize & -8192; // align buffer
res->remain=8192-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;
err=read_file(res->filename,res->buffer,
0,8192,&bytes);
res->filepos=0;
};
return res;
return res;
}
 
size_t FileSize(FILE *handle)
{
return handle->filesize;
}
/programs/games/doom/trunk/kolibc/src/file/fputc.c
12,7 → 12,7
if(!f->remain)
{ if (!write_buffer(f))
return EOF;
f->filepos+=4096;
f->filepos+=8192;
fill_buff(f);
};
30,7 → 30,7
{ size_t bytes;
int err;
 
bytes= f->filepos+4096 > f->filesize ? f->strpos:4096;
bytes= f->filepos+8192 > f->filesize ? f->strpos:8192;
err=write_file(f->filename,f->buffer,f->filepos,bytes,&bytes);
if(err)
return 0;
/programs/games/doom/trunk/kolibc/src/file/fread.c
1,50 → 1,59
#include "kolibc.h"
 
#include "kolibri.h"
#include <string.h>
 
#include "kolibc.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;
char *p;
// if(!((f->mode & FILE_OPEN_READ)|(f->mode & FILE_OPEN_PLUS)))
// return 0;
req=count*size;
p= (char*)dst;
if (req+f->filepos+f->strpos > f->filesize)
req=f->filesize-f->filepos-f->strpos;
count=0;
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;
}
{ 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+=8192;
if(!fill_buff(f))
{ printf("error reading file %d=",f->filepos); //eof or error
break;
}
};
};
return count/size;
}
 
int fill_buff(FILE* f)
{ int err;
size_t bytes;
{ 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;
8192,&bytes);
if(bytes == -1)
return 0;
// if(!bytes) return 0;
f->stream = f->buffer;
f->remain = 8192;
f->strpos=0;
return bytes;
};
};
 
/programs/games/doom/trunk/kolibc/src/file/fseek.c
1,11 → 1,15
 
//#include <stdio.h>
#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);
}
if (origin==SEEK_CUR)
offset+=file->filepos+file->strpos;
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
1,23 → 1,23
 
#include "kolibri.h"
#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;
}
bytes = *pos;
bytes= *pos & -8192;
err=read_file(f->filename,f->buffer,bytes,
8192,&bytes);
if(bytes == -1)
return EOF;
f->filepos= *pos & -8192;
f->strpos = *pos & 8191;
f->remain = 8192-f->strpos;
f->stream = f->buffer+f->strpos;
return 0;
}
 
/programs/games/doom/trunk/kolibc/src/file/ftell.c
1,5 → 1,7
#include "kolibc.h"
 
long ftell(FILE* file)
{
return file->filepos+file->strpos;
}
return file->filepos+file->strpos;
}
 
/programs/games/doom/trunk/kolibc/src/file/fwrite.c
1,3 → 1,5
 
#include <string.h>
#include "kolibc.h"
 
int write_buffer(FILE *f);
9,10 → 11,11
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)
19,20 → 22,23
{
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);
};
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+=8192;
fill_buff(f);
};
};
***********/
return count;
return count/size;
};
};
/programs/games/doom/trunk/kolibc/src/file/rewind.c
1,9 → 1,12
 
#include "kolibc.h"
 
int fill_buff(FILE* f);
 
void rewind(FILE* file)
{
file->filepos=0;
fill_buff(file);
}
file->filepos=0;
file->stream=file->buffer;
file->strpos=0;
file->remain=8192;
fill_buff(file);
}
/programs/games/doom/trunk/kolibc/src/mem/malloc.c
1,17 → 1,22
 
#include "mf.h"
void * memcpy(void * dst, void * src, size_t count);
#include "kolibri.h"
 
void * kmemcpy(void * dst, const void * src, size_t count);
 
static struct m_state ms;
 
void init_malloc(void* p)
void mf_init()
{ mchunkptr chp;
int i;
dword psize= 0x10000;
char *p;
psize-= 40;
dword psize= 0x40000;
p = 0x2600000; //(char*)UserAlloc(psize);
ms.top = (mchunkptr)p;
ms.topsize = psize;
ms.smallmap=0;
ms.treemap=0;
chp = (mchunkptr)p;
chp->head=psize|1;
18,108 → 23,108
for(i=0; i<32; i++)
{
mchunkptr p = &ms.smallbins[i];
p->fd = p;
p->bk = p;
mchunkptr p = &ms.smallbins[i];
p->fd = p;
p->bk = p;
};
}
 
void *malloc(size_t size)
void *dlmalloc(size_t size)
{ size_t nb, psize,rsize;
dword idx;
dword smallbits;
mchunkptr B,F,p,r;
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);
};
if (nb < 256)
{
idx = nb >> 3;
// smallbits= (-1<<idx) & ms.smallmap;
_asm
{
mov ecx, [idx]
or eax, -1
shl eax, cl
and eax, dword ptr [ms]
mov dword ptr [smallbits], eax
}
if (smallbits)
{
_asm
{ bsf eax, dword ptr [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 dword ptr [ms], 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)
void dlfree(void *mem)
{ size_t psize;
size_t prevsize;
size_t nsize;
126,473 → 131,473
mchunkptr next;
mchunkptr prev;
mchunkptr p = mem2chunk(mem);
mchunkptr p = mem2chunk(mem);
if(p->head & CINUSE_BIT)
{
psize = p->head & (~3);
next = chunk_plus_offset(p, psize);
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);
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);
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_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 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 dword compute_tree_index(size_t s)
{ dword 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;
};
};
};
};
_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
};
 
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;
}
return idx;
};
 
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;
}
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,dword ptr [ms+4]
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 < 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((mchunkptr)r, rsize);
}
return chunk2mem(v);
}
return 0;
}
 
static void* internal_realloc(struct m_state *m, void* oldmem,
size_t bytes);
 
void* dlrealloc(void* oldmem, size_t bytes)
{
if (oldmem == 0)
return dlmalloc(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)
dlfree(extra);
check_inuse_chunk(m, newp);
return chunk2mem(newp);
}
else
{
void* newmem = dlmalloc(bytes);
if (newmem != 0)
{
size_t oc = oldsize - 4;
memcpy(newmem, oldmem, (oc < bytes)? oc : bytes);
dlfree(oldmem);
}
return newmem;
}
return 0;
}
/programs/games/doom/trunk/kolibc/src/string/doprnt.c
72,6 → 72,7
static char *exponentl(char *p, int expv, unsigned char fmtch);
 
static char NULL_REP[] = "(null)";
static char buf[BUF]; /* space for %c, %[diouxX], %[eEfgG] */
 
int _doprnt(char *dest, size_t maxlen, const char *fmt0, va_list argp)
{
95,11 → 96,10
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;
digs = "0123456789abcdef";
fmt = fmt0;
digs = "0123456789abcdef";
p = dest;
 
for (cnt = 0;; ++fmt)
752,5 → 752,18
return(3);
}
 
static unsigned int strlen(const char* string)
{
int i;
i=0;
while (*string++) i++;
return i;
}
 
static char* strcpy(char* dst,const char* src)
{
char* res= dst;
while(*dst++ = *src++) ;
return res;
}
 
/programs/games/doom/trunk/kolibc/src/string/memchr.c
1,5 → 1,6
#include "string.h"
 
#if 0
void* memchr(const void* buf,int c,int count)
{
int i;
11,3 → 12,48
return (void*)0;
}
 
 
void *memset (void *dst, int val, size_t count)
{ void *start = dst;
 
while (count--)
{
*(char *)dst = (char)val;
dst = (char *)dst + 1;
}
return start;
}
 
 
int strcmp (const char * src, const char * dst)
{
int ret = 0 ;
 
while( ! (ret = *(unsigned char *)src - *(unsigned char *)dst) && *dst)
++src, ++dst;
 
if ( ret < 0 )
ret = -1 ;
else if ( ret > 0 )
ret = 1 ;
return( ret );
}
 
char *strcat (char * dst, const char * src)
{
char * cp = dst;
 
while( *cp )
cp++;
 
while( *cp++ = *src++ ) ;
 
return dst ;
}
 
int abs (int number )
{
return( number>=0 ? number : -number );
}
 
#endif
/programs/games/doom/trunk/kolibc/src/string/strlen.c
1,4 → 1,4
int strlen(const char* string)
unsigned int strlen(const char* string)
{
int i;
i=0;
/programs/games/doom/trunk/kolibc/src/string/strupr.c
1,5 → 1,4
#include "ctype.h"
#include "string.h"
#include "kolibc.h"
 
char * strupr(char *_s)
{