diff --git a/programs/games/doom/trunk/d_main.c b/programs/games/doom/trunk/d_main.c
index 2b1228c903..6605819d7a 100644
--- a/programs/games/doom/trunk/d_main.c
+++ b/programs/games/doom/trunk/d_main.c
@@ -633,8 +633,8 @@ void IdentifyVersion (void)
 
     char *home;
     char *doomwaddir;
-    doomwaddir = getenv("DOOMWADDIR");
-    if (!doomwaddir)
+//    doomwaddir = getenv("DOOMWADDIR");
+//    if (!doomwaddir)
 	doomwaddir = ".";
 
     // Commercial.
@@ -666,8 +666,8 @@ void IdentifyVersion (void)
     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 @@ void D_DoomMain (void)
 
  //   I_BeginSplash();
 
-    setbuf (stdout, NULL);
+//    setbuf (stdout, NULL);
     modifiedgame = false;
 	
     nomonsters = M_CheckParm ("-nomonsters");
@@ -1102,15 +1102,15 @@ void D_DoomMain (void)
     // 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 @@ void D_DoomMain (void)
     {
       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 @@ void D_DoomMain (void)
 	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
diff --git a/programs/games/doom/trunk/d_net.c b/programs/games/doom/trunk/d_net.c
index 7181ff3f0f..9b672e820c 100644
--- a/programs/games/doom/trunk/d_net.c
+++ b/programs/games/doom/trunk/d_net.c
@@ -139,10 +139,7 @@ int ExpandTics (int low)
 //
 // HSendPacket
 //
-void
-HSendPacket
- (int	node,
-  int	flags )
+void HSendPacket (int node,int flags )
 {
     netbuffer->checksum = NetbufferChecksum () | flags;
 
@@ -172,14 +169,14 @@ HSendPacket
 	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,14 +211,14 @@ boolean HGetPacket (void)
     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;
     }
 	
     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 @@ boolean HGetPacket (void)
 	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 @@ boolean HGetPacket (void)
 	    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 @@ void GetPackets (void)
 	{
 	    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 @@ void GetPackets (void)
 	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 @@ void GetPackets (void)
 	{
 	    // 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;
diff --git a/programs/games/doom/trunk/i_sound.c b/programs/games/doom/trunk/i_sound.c
index 099a8df491..dcea05f5f4 100644
--- a/programs/games/doom/trunk/i_sound.c
+++ b/programs/games/doom/trunk/i_sound.c
@@ -552,7 +552,7 @@ void I_ShutdownSound(void)
   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_ShutdownSound(void)
 void I_InitSound()
 { int i;
 
-  printf( stderr, "I_InitSound: ");
+  printf("I_InitSound: ");
   
   for (i=1 ; i<NUMSFX ; i++)
   { 
@@ -586,14 +586,14 @@ void I_InitSound()
     }
   }
 
-  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++ )
     mixbuffer[i] = 0;
   
   // Finished initialization.
-  printf(stderr, "I_InitSound: sound module ready\n");
+  printf("I_InitSound: sound module ready\n");
     
 }
 
diff --git a/programs/games/doom/trunk/i_system.c b/programs/games/doom/trunk/i_system.c
index dea668696e..7bb4a3c95b 100644
--- a/programs/games/doom/trunk/i_system.c
+++ b/programs/games/doom/trunk/i_system.c
@@ -39,6 +39,7 @@ rcsid[] = "$Id: m_bbox.c,v 1.1 1997/02/03 22:45:10 b1 Exp $";
 
 
 #include "i_system.h"
+#include "kolibri.h"
 
 int	mb_used = 6;
 
@@ -81,7 +82,7 @@ int  I_GetHeapSize (void)
 byte* I_ZoneBase (int*	size)
 {
  *size = mb_used*1024*1024;
- return (byte *) _aligned_malloc(*size, 128);;
+ return (byte *) UserAlloc(*size);
 }
 
 
@@ -169,8 +170,8 @@ void I_Error (char *error, ...)
     // 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 @@ void I_Error (char *error, ...)
 
     D_QuitNetGame ();
     I_ShutdownGraphics();
-    getch();
+//    getch();
     exit(-1);
 }
diff --git a/programs/games/doom/trunk/i_video.c b/programs/games/doom/trunk/i_video.c
index ff246094f0..9ee295f17d 100644
--- a/programs/games/doom/trunk/i_video.c
+++ b/programs/games/doom/trunk/i_video.c
@@ -493,30 +493,30 @@ void I_InitGraphics(void)
     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,20 +606,20 @@ static LRESULT CALLBACK WndProc(HWND hwnd, UINT message,
                 ClipCursor(NULL);
                 ShowCursor(TRUE);
             }
-            fprintf(stderr, "WM_DESTROY\n");
+            printf("WM_DESTROY\n");
             PostQuitMessage(0);
             closed = 1;
             break;
 
         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 @@ static LRESULT CALLBACK WndProc(HWND hwnd, UINT message,
                     {
                         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);
diff --git a/programs/games/doom/trunk/kolibc/include/kolibc.h b/programs/games/doom/trunk/kolibc/include/kolibc.h
new file mode 100644
index 0000000000..e80cf9e170
--- /dev/null
+++ b/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
\ No newline at end of file
diff --git a/programs/games/doom/trunk/kolibc/include/kolibri.h b/programs/games/doom/trunk/kolibc/include/kolibri.h
new file mode 100644
index 0000000000..c47c076a18
--- /dev/null
+++ b/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
diff --git a/programs/games/doom/trunk/kolibc/include/mf.h b/programs/games/doom/trunk/kolibc/include/mf.h
new file mode 100644
index 0000000000..6a169542ae
--- /dev/null
+++ b/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)))
+
diff --git a/programs/games/doom/trunk/kolibc/src/file/fclose.c b/programs/games/doom/trunk/kolibc/src/file/fclose.c
new file mode 100644
index 0000000000..23c64b85be
--- /dev/null
+++ b/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;
+}
\ No newline at end of file
diff --git a/programs/games/doom/trunk/kolibc/src/file/feof.c b/programs/games/doom/trunk/kolibc/src/file/feof.c
new file mode 100644
index 0000000000..d97ffa840e
--- /dev/null
+++ b/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;
+}
\ No newline at end of file
diff --git a/programs/games/doom/trunk/kolibc/src/file/fgetc.c b/programs/games/doom/trunk/kolibc/src/file/fgetc.c
new file mode 100644
index 0000000000..fde615c410
--- /dev/null
+++ b/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; 
+}
\ No newline at end of file
diff --git a/programs/games/doom/trunk/kolibc/src/file/fopen.c b/programs/games/doom/trunk/kolibc/src/file/fopen.c
new file mode 100644
index 0000000000..09e49d5bd4
--- /dev/null
+++ b/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;
+}
diff --git a/programs/games/doom/trunk/kolibc/src/file/fprintf.c b/programs/games/doom/trunk/kolibc/src/file/fprintf.c
new file mode 100644
index 0000000000..e8e702ebf7
--- /dev/null
+++ b/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++;
+	}
+}
diff --git a/programs/games/doom/trunk/kolibc/src/file/fputc.c b/programs/games/doom/trunk/kolibc/src/file/fputc.c
new file mode 100644
index 0000000000..611637bb13
--- /dev/null
+++ b/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;  
+};
diff --git a/programs/games/doom/trunk/kolibc/src/file/fread.c b/programs/games/doom/trunk/kolibc/src/file/fread.c
new file mode 100644
index 0000000000..a9350249db
--- /dev/null
+++ b/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; 
+};
\ No newline at end of file
diff --git a/programs/games/doom/trunk/kolibc/src/file/fscanf.c b/programs/games/doom/trunk/kolibc/src/file/fscanf.c
new file mode 100644
index 0000000000..b462cd6572
--- /dev/null
+++ b/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;	
+}
diff --git a/programs/games/doom/trunk/kolibc/src/file/fseek.c b/programs/games/doom/trunk/kolibc/src/file/fseek.c
new file mode 100644
index 0000000000..e33ed9d87b
--- /dev/null
+++ b/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);		
+}
\ No newline at end of file
diff --git a/programs/games/doom/trunk/kolibc/src/file/fsetpos.c b/programs/games/doom/trunk/kolibc/src/file/fsetpos.c
new file mode 100644
index 0000000000..bb768b5fbb
--- /dev/null
+++ b/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;
+}
\ No newline at end of file
diff --git a/programs/games/doom/trunk/kolibc/src/file/ftell.c b/programs/games/doom/trunk/kolibc/src/file/ftell.c
new file mode 100644
index 0000000000..5f0f7af929
--- /dev/null
+++ b/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;
+}
\ No newline at end of file
diff --git a/programs/games/doom/trunk/kolibc/src/file/fwrite.c b/programs/games/doom/trunk/kolibc/src/file/fwrite.c
new file mode 100644
index 0000000000..a5101a9ca9
--- /dev/null
+++ b/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;
+};
\ No newline at end of file
diff --git a/programs/games/doom/trunk/kolibc/src/file/rewind.c b/programs/games/doom/trunk/kolibc/src/file/rewind.c
new file mode 100644
index 0000000000..5dc865bae0
--- /dev/null
+++ b/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);
+}
\ No newline at end of file
diff --git a/programs/games/doom/trunk/kolibc/src/mem/malloc.c b/programs/games/doom/trunk/kolibc/src/mem/malloc.c
new file mode 100644
index 0000000000..bfe1769025
--- /dev/null
+++ b/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;
+}
+  
\ No newline at end of file
diff --git a/programs/games/doom/trunk/kolibc/src/string/atoi.c b/programs/games/doom/trunk/kolibc/src/string/atoi.c
new file mode 100644
index 0000000000..9ac5bf4c8b
--- /dev/null
+++ b/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);
+}
diff --git a/programs/games/doom/trunk/kolibc/src/string/doprnt.c b/programs/games/doom/trunk/kolibc/src/string/doprnt.c
new file mode 100644
index 0000000000..80afd8ab40
--- /dev/null
+++ b/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);
+}
+
+
+
diff --git a/programs/games/doom/trunk/kolibc/src/string/doscan.c b/programs/games/doom/trunk/kolibc/src/string/doscan.c
new file mode 100644
index 0000000000..9f28b936f3
--- /dev/null
+++ b/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);
+}
diff --git a/programs/games/doom/trunk/kolibc/src/string/is.c b/programs/games/doom/trunk/kolibc/src/string/is.c
new file mode 100644
index 0000000000..9d1e6de27f
--- /dev/null
+++ b/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
+ };
diff --git a/programs/games/doom/trunk/kolibc/src/string/istable.c b/programs/games/doom/trunk/kolibc/src/string/istable.c
new file mode 100644
index 0000000000..4f1a12cd6e
--- /dev/null
+++ b/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__  };
diff --git a/programs/games/doom/trunk/kolibc/src/string/memchr.c b/programs/games/doom/trunk/kolibc/src/string/memchr.c
new file mode 100644
index 0000000000..45e79b9c69
--- /dev/null
+++ b/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;
+}
+
diff --git a/programs/games/doom/trunk/kolibc/src/string/sprintf.c b/programs/games/doom/trunk/kolibc/src/string/sprintf.c
new file mode 100644
index 0000000000..ca9498342e
--- /dev/null
+++ b/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);
+}
+
+
diff --git a/programs/games/doom/trunk/kolibc/src/string/strcpy.c b/programs/games/doom/trunk/kolibc/src/string/strcpy.c
new file mode 100644
index 0000000000..3ff1b2b365
--- /dev/null
+++ b/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;	
+}
\ No newline at end of file
diff --git a/programs/games/doom/trunk/kolibc/src/string/strlen.c b/programs/games/doom/trunk/kolibc/src/string/strlen.c
new file mode 100644
index 0000000000..08914d3e5f
--- /dev/null
+++ b/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;
+}
diff --git a/programs/games/doom/trunk/kolibc/src/string/strncmp.c b/programs/games/doom/trunk/kolibc/src/string/strncmp.c
new file mode 100644
index 0000000000..1eb92f26cf
--- /dev/null
+++ b/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;
+}
\ No newline at end of file
diff --git a/programs/games/doom/trunk/kolibc/src/string/strncpy.c b/programs/games/doom/trunk/kolibc/src/string/strncpy.c
new file mode 100644
index 0000000000..9c4b9fab2c
--- /dev/null
+++ b/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;
+}
\ No newline at end of file
diff --git a/programs/games/doom/trunk/kolibc/src/string/strrchr.c b/programs/games/doom/trunk/kolibc/src/string/strrchr.c
new file mode 100644
index 0000000000..4eb7166ab0
--- /dev/null
+++ b/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;
+}
diff --git a/programs/games/doom/trunk/kolibc/src/string/strupr.c b/programs/games/doom/trunk/kolibc/src/string/strupr.c
new file mode 100644
index 0000000000..95fab2a6ab
--- /dev/null
+++ b/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;
+}
diff --git a/programs/games/doom/trunk/kolibc/src/string/toupper.c b/programs/games/doom/trunk/kolibc/src/string/toupper.c
new file mode 100644
index 0000000000..a8b1becdc6
--- /dev/null
+++ b/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);
+}
diff --git a/programs/games/doom/trunk/m_menu.c b/programs/games/doom/trunk/m_menu.c
index 0133ea6048..e9ec469f27 100644
--- a/programs/games/doom/trunk/m_menu.c
+++ b/programs/games/doom/trunk/m_menu.c
@@ -1733,40 +1733,42 @@ void M_Drawer (void)
     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))
-	{
-	    for (i = 0;i < strlen(messageString+start);i++)
-		if (*(messageString+start+i) == '\n')
-		{
-		    memset(string,0,40);
-		    strncpy(string,messageString+start,40);
-		    start += i+1;
+	  y = 100 - M_StringHeight(messageString)/2;
+	  p = messageString;
+	  len = strlen(p);
+	  while(*p)
+	  {
+        for (i = 0;len;i++,len--)
+        {
+ 	      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;
-	    }
-				
-	    x = 160 - M_StringWidth(string)/2;
-	    M_WriteText(x,y,string);
-	    y += SHORT(hu_font[0]->height);
-	}
-	return;
-    }
+		  };
+	    };	  
+	
+        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;
diff --git a/programs/games/doom/trunk/m_misc.c b/programs/games/doom/trunk/m_misc.c
index 24a23a4f85..8855134170 100644
--- a/programs/games/doom/trunk/m_misc.c
+++ b/programs/games/doom/trunk/m_misc.c
@@ -294,9 +294,9 @@ void M_SaveDefaults (void)
 	    && 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 @@ void M_LoadDefaults (void)
     }
     else
 	defaultfile = basedefault;
-    
+/**********
     // read the file in, overriding any set defaults
     f = fopen (defaultfile, "r");
     if (f)
@@ -373,6 +373,7 @@ void M_LoadDefaults (void)
 		
 	fclose (f);
     }
+**********/    
 }
 
 
diff --git a/programs/games/doom/trunk/v_video.c b/programs/games/doom/trunk/v_video.c
index 1fbb81416a..d4daddfb49 100644
--- a/programs/games/doom/trunk/v_video.c
+++ b/programs/games/doom/trunk/v_video.c
@@ -38,7 +38,7 @@ rcsid[] = "$Id: v_video.c,v 1.5 1997/02/03 22:45:13 b1 Exp $";
 #include "m_bbox.h"
 
 #include "v_video.h"
-
+#include "kolibri.h"
 
 // Each screen is [SCREENWIDTH*SCREENHEIGHT]; 
 byte*				screens[5];	
@@ -225,9 +225,9 @@ V_DrawPatch
 	|| 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 @@ V_DrawPatchFlipped
 	|| 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,10 +483,10 @@ void V_Init (void)
 { 
     int		i;
     byte*	base;
-		
+	size_t  size;	
     // stick these in low dos memory on PCs
-
-    base = _aligned_malloc(SCREENWIDTH*SCREENHEIGHT*4, 128);I_AllocLow (SCREENWIDTH*SCREENHEIGHT*4);
+    size = SCREENWIDTH*SCREENHEIGHT*4;
+    base = (byte*)UserAlloc(size);
 
     for (i=0 ; i<4 ; i++)
 	screens[i] = base + i*SCREENWIDTH*SCREENHEIGHT;
diff --git a/programs/games/doom/trunk/w_wad.c b/programs/games/doom/trunk/w_wad.c
index 67a8df10ca..a6fc3f9635 100644
--- a/programs/games/doom/trunk/w_wad.c
+++ b/programs/games/doom/trunk/w_wad.c
@@ -515,6 +515,7 @@ W_CacheLumpName
     return W_CacheLumpNum (W_GetNumForName(name), tag);
 }
 
+#if 0
 
 //
 // W_Profile
@@ -567,14 +568,14 @@ void W_Profile (void)
 	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
diff --git a/programs/games/doom/trunk/wi_stuff.c b/programs/games/doom/trunk/wi_stuff.c
index 9c2dd68b2e..119132563b 100644
--- a/programs/games/doom/trunk/wi_stuff.c
+++ b/programs/games/doom/trunk/wi_stuff.c
@@ -494,7 +494,7 @@ WI_drawOnLnode
     else
     {
 	// DEBUG
-//	__libclog_printf("Could not place patch on level %d", n+1); 
+	  printf("Could not place patch on level %d", n+1); 
     }
 }