*** org\bsdfiler.c	Wed Jun 12 20:38:08 1996
--- bsdfiler.c	Fri Jun 21 12:50:29 1996
***************
*** 3,17 ****
--- 3,54 ----
   *
   *  revision history:
   *	0.0: Jun. 8, 1996 by Dai ISHIJIMA
+  *	0.0: Jun. 14, 1996 by Eiichiroh ITOH(WIN32 Version)
+  *	0.1: Jun. 19, 1996 by Eiichiroh ITOH(File View&Available Drives)
   */
  
+ #ifdef	WIN32
+ #define	STRICT
+ #include <windows.h>
  #include <stdio.h>
+ #include <stdlib.h>
  #include <string.h>
+ //#define	EBUG
+ #define	BSD_COMPAT
+ #else	/* WIN32 */
+ #include <stdio.h>
+ #include <string.h>
  #include <sys/types.h>
  #include <time.h>
+ #endif	/* WIN32 */
  
  #include "bsdfiler.h"
  
+ #ifdef	WIN32
+ BOOL		opentty_w32( LPSTR, DWORD ) ;
+ void		closetty_w32( void ) ;
+ int		ttyputc( int, char ) ;
+ int		ttygetc( int ) ;
+ int		ttycount( int fd ) ;
+ int		mkdir( const char *name ) ;
+ int		rmdir( const char *name ) ;
+ int		chdir( const char *name ) ;
+ char *		getcwd( char *buffer, int maxlen ) ;
+ int		unlink( const char *filename ) ;
+ unsigned short	crc16c(unsigned short crc, unsigned char ch, int rev) ;
+ void		ltos(char *s, unsigned long l) ;
+ int		filetype( char *name ) ;
+ long		filelength(char *name) ;
+ void		tblini( void ) ;
+ 
+ #define		FOPEN_WRITE		"wb"
+ #define		FOPEN_READ		"rb"
+ 
+ DWORD		RetryCount = 0 ;	/* đ */
+ DWORD		SendLoop = 0 ;		/* _~[[v */
+ DWORD		SendTime = 0 ;
+ DWORD		SendSize = 0 ;
+ #endif	/* WIN32 */
  
  char *prog;
  #define shift --argc; ++argv
***************
*** 30,62 ****
      static int getput = EOS;
      int n;
      static unsigned char asciidump[NDUMP];
      
      if ((getput != mode) || (dumppos >= NDUMP)) {
  	for (n = dumppos; n < NDUMP; n++) {
! 	    fprintf(stderr, "   ");
  	}
! 	fprintf(stderr, "  ");
  	for (n = 0; n < dumppos; n++) {
! 	    putc(dumpchar(asciidump[n]), stderr);
  	}
  	if (mode == PUT) {
! 	    fprintf(stderr, "\nPUT:");
  	}
  	else {
! 	    fprintf(stderr, "\nGET:");
  	}
  	dumppos = 0;
      }
      getput = mode;
!     fprintf(stderr, " %02x", ch);
      asciidump[dumppos] = ch;
      ++dumppos;
  }
  #endif /* -DEBUG */
  
  
  int getbyte(int fd)
  {
      time_t t;
      int ch;
  
--- 67,146 ----
      static int getput = EOS;
      int n;
      static unsigned char asciidump[NDUMP];
+     static FILE	*fp = NULL ;
      
+     if ( fp == NULL ) {
+ 	fp = fopen( "OUT", "a" ) ;
+     }
+     if ( fp == NULL ) {
+ 	fp = stderr ;
+     }
      if ((getput != mode) || (dumppos >= NDUMP)) {
  	for (n = dumppos; n < NDUMP; n++) {
! 	    fprintf(fp, "   ");
  	}
! 	fprintf(fp, "  ");
  	for (n = 0; n < dumppos; n++) {
! 	    putc(dumpchar(asciidump[n]), fp);
  	}
  	if (mode == PUT) {
! 	    fprintf(fp, "\nPUT:");
  	}
  	else {
! 	    fprintf(fp, "\nGET:");
  	}
  	dumppos = 0;
      }
      getput = mode;
!     fprintf(fp, " %02x", ch);
!     fflush( fp ) ;
      asciidump[dumppos] = ch;
      ++dumppos;
  }
  #endif /* -DEBUG */
  
  
+ #ifdef	WIN32
+ void
+ dump_buf( const char *buf, int len )
+ {
+     int		i ;
+ 
+     fprintf( stderr, "[" ) ;
+     for ( i = 0 ; i < len ; i ++ ) {
+ 	fprintf( stderr, " %02X", 0xFF & buf[ i ] ) ;
+     }
+     fprintf( stderr, " ]\n" ) ;
+ }
+ #endif	/* WIN32 */
+ 
+ #ifdef	BSD_COMPAT
+ unsigned short
+ buf2word( const unsigned char *buf )
+ {
+     return *buf + *(buf+1) * 256 ;
+ }
+ 
+ unsigned long
+ buf2dword( const unsigned char *buf )
+ {
+     return *buf + *(buf+1) * 256 + (*(buf+2) + *(buf+3) * 256) * 65536 ;
+ }
+ #endif	/* BSD_COMPAT */
+ 
+ 
  int getbyte(int fd)
  {
+ #ifdef	WIN32
+     int		ch ;
+     DWORD	t = GetTickCount() ;
+ 
+     while ( ( ch = ttygetc(fd) ) < 0 ) {
+ 	if ( (GetTickCount() - t) / 1000 > TIMEOUT) {
+ 	    return -1 ;
+ 	}
+     }
+ #else	/* WIN32 */
      time_t t;
      int ch;
  
***************
*** 66,71 ****
--- 150,156 ----
  	    return(-1);
  	}
      }
+ #endif	/* WIN32 */
  #ifdef EBUG
      debugdump(GET, ch);
  #endif
***************
*** 132,142 ****
      pcrc += 256 * getbyte(fd);
      if (crc != pcrc) {
  	fprintf(stderr, "crc error, %04x != %04x\n", crc, pcrc);
      }
      return(len);
  }
  
! 
  /*  len ̃pPbg𑗐M */
  void sendpacket(int fd, int len, unsigned char *buf)
  {
--- 217,232 ----
      pcrc += 256 * getbyte(fd);
      if (crc != pcrc) {
  	fprintf(stderr, "crc error, %04x != %04x\n", crc, pcrc);
+ #ifdef	BSD_COMPAT
+ 	return 0 ;
+ #endif	/* BSD_COMPAT */
      }
      return(len);
  }
  
! #ifdef	WIN32
! #pragma optimize( "g", off )
! #endif	/* WIN32 */
  /*  len ̃pPbg𑗐M */
  void sendpacket(int fd, int len, unsigned char *buf)
  {
***************
*** 156,161 ****
--- 246,263 ----
  	}
  	putbyte(fd, buf[i]);
  	crc = crc16c(crc, buf[i], YES);
+ #ifdef	WIN32
+ 	if ( ttycount( fd ) > 0 ) {
+ 	    fprintf( stderr, "[Cancel]\n" ) ;
+ 	    return ;
+ 	}
+ 	{
+ 	    DWORD	j = SendLoop ;
+ 	    while ( j ) {
+ 		j -- ;
+ 	    }
+ 	}
+ #endif	/* WIN32 */
      }
      putbyte(fd, DLE);
      putbyte(fd, ETX);
***************
*** 171,177 ****
--- 273,283 ----
      int i;
      int len;
  
+ #ifdef	BSD_COMPAT
+     len = buf2word( &buf[ ofs ] ) ;
+ #else	/* BSD_COMPAT */
      len = buf[ofs] + buf[ofs + 1] * 256;
+ #endif	/* BSD_COMPAT */
      for (i = 0; i < len; i++) {
  	msg[i] = buf[ofs + i + 2];
      }
***************
*** 250,255 ****
--- 356,367 ----
  
      finish = NO;
      rlen = recvpacket(fd, rbuf);
+ #ifdef	BSD_COMPAT
+     if ( !rlen ) {
+ 	/* pPbgُ̏ꍇ */
+ 	return NO ;
+     }
+ #endif	/* BSD_COMPAT */
      cmd = sbuf[0] = rbuf[0];
      cnt = sbuf[1] = rbuf[1];
      sbuf[2] = REPLYSOH;
***************
*** 257,262 ****
--- 369,377 ----
      slen = 4;
      if (cmd == CONNECT) {
  	slen = clrparm(sbuf, slen, 2);
+ #ifdef	WIN32
+ 	fprintf( stderr, "[Connect]\n" ) ;
+ #endif	/* WIN32 */
      }
      else if (cmd == LOGDSK) {
  	curdrv = rbuf[4];
***************
*** 265,274 ****
--- 380,412 ----
      else if (cmd == CHANGEDIR) {
  	dirlen = getmesg(rbuf, 4, curdir);
  	slen = clrparm(sbuf, slen, 6);
+ #ifdef	WIN32
+ 	curdir[dirlen] = 0 ;
+ 	if ( !strcmp( curdir, ".." ) ) {
+ 	    char	tmpbuf[ 100 ] ;
+ 	    if ( getcwd( tmpbuf, sizeof tmpbuf ) != NULL ) {
+ 		if ( !strcmp( &tmpbuf[1], ":\\" ) ) {
+ 		    sbuf[slen - 4] = (char) 0xD1 ;
+ 		}
+ 	    }
+ 	}
+ 	if ( chdir( curdir ) ) {
+ 	    sbuf[slen - 4] = (char) 0x01 ;
+ 	}
+ #endif	/* WIN32 */
      }
      else if (cmd == REQCWD) {
+ #ifdef	WIN32
+ 	/* JgfBNg擾 */
+ 	if ( getcwd( curdir, MAXLINE ) == NULL ) {
+ 	    strcpy( curdir, "C:\\" ) ;
+ 	}
+ 	curdrv = 0xFF & curdir[0] ;
+ 	fprintf( stderr, "[Current Directory:%s]\n", curdir ) ;
+ #else	/* WIN32 */
  	strcpy(curdir, "C:\\");
  	curdrv = rbuf[4];
+ #endif	/* WIN32 */
  	curdir[0] = curdrv;
  	slen = clrparm(sbuf, slen, 4);
  	slen = setmesg(sbuf, slen, strlen(curdir), curdir);
***************
*** 309,318 ****
  	if (fp != NULL) {
  	    fclose(fp);
  	}
! 	fp = efopen(convname(path), "w");
      }
      else if (cmd == GETFILE) {
  	blklen = getmesg(rbuf, 6, transbuf);
  	fwrite(transbuf, 1, blklen, fp);
  	if (blklen < DATBLKSIZ) {
  	    fclose(fp);
--- 447,463 ----
  	if (fp != NULL) {
  	    fclose(fp);
  	}
! #ifdef	WIN32
! 	SendSize = 0 ;
! 	SendTime = GetTickCount() ;
! #endif	/* WIN32 */
! 	fp = efopen(convname(path), FOPEN_WRITE);
      }
      else if (cmd == GETFILE) {
  	blklen = getmesg(rbuf, 6, transbuf);
+ #ifdef	WIN32
+ 	SendSize += blklen ;
+ #endif	/* WIN32 */
  	fwrite(transbuf, 1, blklen, fp);
  	if (blklen < DATBLKSIZ) {
  	    fclose(fp);
***************
*** 325,343 ****
--- 470,515 ----
  	slen = clrparm(sbuf, slen, 6);
      }
      else if (cmd == TRANSOK) {
+ #ifdef	WIN32
+ 	DWORD	now = GetTickCount() ;
+ 	if ( SendTime && now > SendTime ) {
+ 	    DWORD	tm = now - SendTime ;
+ 	    printf( "[Transfer rate=%d bytes/sec (%d bytes/%d ms)]\n",
+ 		    SendSize * 1000 / tm, SendSize, tm ) ;
+ 	    SendTime = 0 ;
+ 	}
+ 	/* t@CN[Y */
+ 	if ( fp != NULL ) {
+ 	    fclose( fp ) ;
+ 	    fp = NULL ;
+ 	}
+ #endif	/* WIN32 */
  	slen = clrparm(sbuf, slen, 6);
      }
      else if (cmd == RENAME) {
  	oldpathlen = getmesg(rbuf, 4, oldpath);
+ #ifdef	BSD_COMPAT
+ 	pathlen = getmesg(rbuf, 4 + oldpathlen + 2 + 2, path);
+ #else	/* BSD_COMPAT */
  	pathlen = getmesg(rbuf, 4 + oldpathlen + 2, path);
+ #endif	/* BSD_COMPAT */
+ #ifdef	WIN32
+ 	fprintf( stderr, "[Rename:%s to %s]\n", oldpath, path ) ;
+ #endif	/* WIN32 */
  	rename(convname(oldpath), convname(path));
  	slen = clrparm(sbuf, slen, 6);
      }
      else if (cmd == DELFILE) {
  	oldpathlen = getmesg(rbuf, 4, oldpath);
+ #ifdef	WIN32
+ 	fprintf( stderr, "[Delete:%s]\n", oldpath ) ;
+ 	/* {ɏĂ܂ */
+ 	unlink( convname(oldpath) ) ;
+ #else	/* WIN32 */
  	strcpy(path, convname(oldpath));
  	strcat(path, ".~~~~");
  	rename(oldpath, path);
+ #endif	/* WIN32 */
  	slen = clrparm(sbuf, slen, 6);
      }
      else if (cmd == PATHTOPUT) {
***************
*** 345,357 ****
  	if (fp != NULL) {
  	    fclose(fp);
  	}
! 	fp = efopen(convname(path), "r");
  	slen = clrparm(sbuf, slen, 6);
      }
      else if (cmd == TRANSRDY) {
  	slen = clrparm(sbuf, slen, 6);
      }
      else if (cmd == PUTFILE) {
  	blklen = rbuf[6] + rbuf[7] * 256;
  	if (cnt == lastcnt) {	/* gC */
  	    fseek(fp, lastfilpos, SEEK_SET);
--- 517,554 ----
  	if (fp != NULL) {
  	    fclose(fp);
  	}
! #ifdef	WIN32
! 	SendSize = filelength( path ) ;
! 	SendTime = GetTickCount() ;
! #endif	/* WIN32 */
! 	fp = efopen(convname(path), FOPEN_READ);
  	slen = clrparm(sbuf, slen, 6);
      }
      else if (cmd == TRANSRDY) {
  	slen = clrparm(sbuf, slen, 6);
      }
      else if (cmd == PUTFILE) {
+ #ifdef	WIN32
+ 	blklen = buf2word( &rbuf[6] ) ;
+ 	if (cnt == lastcnt) {	/* gC */
+ 	    RetryCount ++ ;	/* gC̏ꍇ͍đ񐔂𑝂₷ */
+ 	    fprintf( stderr, "[Retry:%d]\n", RetryCount ) ;
+ 	    fseek(fp, lastfilpos, SEEK_SET);
+ 	} else if ( RetryCount ) {
+ 	    RetryCount -- ;	/* gC̏ꍇ͍đ񐔂炷 */
+ 	    if ( !RetryCount ) {
+ 		fprintf( stderr, "[Retry off]\n" ) ;
+ 	    }
+ 	}
+ 	if ( blklen <= 0 ) {
+ 	    slen = clrparm( sbuf, slen, 6 ) ;
+ 	} else {
+ 	    lastfilpos = ftell(fp);
+ 	    blklen = fread(transbuf, 1, blklen, fp);
+ 	    slen = clrparm(sbuf, slen, 4);
+ 	    slen = setmesg(sbuf, slen, blklen, transbuf);
+ 	}
+ #else	/* WIN32 */
  	blklen = rbuf[6] + rbuf[7] * 256;
  	if (cnt == lastcnt) {	/* gC */
  	    fseek(fp, lastfilpos, SEEK_SET);
***************
*** 363,389 ****
--- 560,680 ----
  	if (blklen <= 0) {
  	    fclose(fp);
  	}
+ #endif	/* WIN32 */
      }
      else if (cmd == REQSTAMP) {
  	slen = clrparm(sbuf, slen, 4);
  	slen = setparm(sbuf, slen, 4, getstamp(path));
      }
      else if (cmd == MKDIR) {
+ #ifdef	WIN32
+ 	pathlen = getmesg(rbuf, 4, path);
+ 	fprintf( stderr, "[Mkdir:%s]\n", path ) ;
+ 	mkdir( path ) ;
+ #endif	/* WIN32 */
  	slen = clrparm(sbuf, slen, 6);
      }
      else if (cmd == DISCON) {	
  	slen = clrparm(sbuf, slen, 6);
+ #ifdef	WIN32
+ 	fprintf( stderr, "[Disconnect]\n" ) ;
+ #else	/* WIN32 */
  	finish = YES;
+ #endif	/* WIN32 */
+     }
+ #ifdef	WIN32
+     else if (cmd == 0x0F) {
+ 	fseek( fp, buf2dword( &rbuf[8] ), buf2word( &rbuf[ 6 ] ) ) ;
+ 	slen = clrparm( sbuf, slen, 6 ) ;
+     }
+     else if (cmd == 0x13) {
+ 	slen = clrparm( sbuf, slen, 4 ) ;
+ 	ltos( &sbuf[ slen ], ftell(fp) ) ;
+ 	slen += 4 ;
+     }
+     else if (cmd == 0x1B) {
+ 	char	drivestr[ 32 ], *drv = drivestr ;
+ 	DWORD	avail, i ;
+ 
+ 	for ( avail = GetLogicalDrives(), i = 0 ; avail ; avail >>= 1, i ++ ) {
+ 	    if ( avail & 1 ) {
+ 		*drv++ = (BYTE) ('A' + i) ;
+ 	    }
+ 	}
+ 	*drv = 0 ;
+ 	printf( "[Available drives=%s]\n", drivestr ) ;
+ 	slen = clrparm( sbuf, slen, 4 ) ;
+ 	slen = setmesg( sbuf, slen, strlen( drivestr ) + 1, drivestr ) ;
+ 	slen = clrparm( sbuf, slen, 4 ) ;
+     }
+     else if (cmd == 0x0E) {
+ 	pathlen = getmesg(rbuf, 4, path);
+ 	fprintf( stderr, "[Rmdir:%s]\n", path ) ;
+ 	rmdir( path ) ;
+ 	slen = clrparm(sbuf, slen, 6);
      }
+ #endif	/* WIN32 */
      else {
  	fprintf(stderr, "Unknown command: ");
+ #ifdef	WIN32
+ 	dump_buf( rbuf, rlen ) ;
+ #endif	/* WIN32 */
      }
      lastcnt = cnt;
      sendpacket(fd, slen, sbuf);
      return(finish);
  }
  
+ #ifdef	WIN32
+ #define		EXCEPTION_USER			0xEFFFFFFF
  
+ void
+ main( int argc, char *argv[] )
+ {
+     int		fd = 0 ;		/* _~[ */
+     char	*name = "COM1" ;
+     DWORD	baud = 9600 ;
+ 
+     fprintf( stderr, "W32 Filer  Version 0.02           Copyright 1996, Eiichiroh ITOH\n" ) ;
+     fprintf( stderr, "  Based on BSD Filer V0.0         Copyright 1996, Dai ISHIJIMA\n\n" ) ;
+     prog = *argv ;
+     shift ;
+     if ( argc > 0 ) {
+ 	name = *argv ;
+ 	shift ;
+ 	if ( argc > 0 ) {
+ 	    baud = atoi( *argv ) ;
+ 	    shift ;
+ 	    if ( argc > 0 ) {
+ 		SendLoop = atoi( *argv ) ;
+ 	    }
+ 	}
+     }
+     SetErrorMode( SEM_FAILCRITICALERRORS ) ;
+     /* ʐM|[gI[v */
+     if ( opentty_w32( name, baud ) != TRUE ) {
+ 	return ;
+     }
+     fprintf( stderr, "Monitoring port %s at %d\n", name, baud ) ;
+     fprintf( stderr, "To QUIT, Please Enter ESC Key\n" ) ;
+     __try {
+ 	tblini() ;
+ 	__try {
+ 	    while ( emulfiler(fd) != YES ) {
+ 		; /* loop */
+ 	    }
+ 	} __except( GetExceptionCode() == EXCEPTION_USER ?
+ 			EXCEPTION_EXECUTE_HANDLER :
+ 			EXCEPTION_CONTINUE_SEARCH ) {
+ 	    fprintf( stderr, "\n[USER break]\n", prog ) ;
+ 	}
+     } __finally {
+ 	/* ʐM|[gN[Y */
+ 	closetty_w32() ;
+ 	fprintf( stderr, "bye.\n" ) ;
+     } 
+ }
+ #else	/* WIN32 */
  main(int argc, char *argv[])
  {
      int fd;
***************
*** 404,408 ****
      }
      exit(0);
  }
! 
!      
--- 695,698 ----
      }
      exit(0);
  }
! #endif	/* WIN32 */
*** org\filemisc.c	Sat Jun 08 23:29:22 1996
--- filemisc.c	Thu Jun 20 20:01:48 1996
***************
*** 1,17 ****
  /*
!  *  filemisc.c -- $B%U%!%$%kL>$N=hM}!"%o%$%k%I%+!<%I!"%?%$%`%9%?%s%W!"$J$I$J$I(B
   *
   *  revision history
   *	0.0: Jun. 8, 1996 by Dai ISHIJIMA
   */
  
  #include <stdio.h>
  #include <sys/types.h>
  #include <sys/stat.h>
  #include <sys/param.h>
  #include <sys/mount.h>
  #include <time.h>
  #include <dirent.h>
  
  #include "bsdfiler.h"
  
--- 1,25 ----
  /*
!  *  filemisc.c -- t@C̏AChJ[hA^CX^vAȂǂȂ
   *
   *  revision history
   *	0.0: Jun. 8, 1996 by Dai ISHIJIMA
+  *	0.0: Jun. 14, 1996 by Eiichiroh ITOH(WIN32 Version)
   */
  
+ #ifdef	WIN32
+ #define	STRICT
+ #include <windows.h>
  #include <stdio.h>
+ #include <stdlib.h>
+ #else	/* WIN32 */
+ #include <stdio.h>
  #include <sys/types.h>
  #include <sys/stat.h>
  #include <sys/param.h>
  #include <sys/mount.h>
  #include <time.h>
  #include <dirent.h>
+ #endif	/* WIN32 */
  
  #include "bsdfiler.h"
  
***************
*** 19,24 ****
--- 27,124 ----
  static char filnams[MAXDIRENT * FILNAMSIZ];
  static char *entries[MAXDIRENT + 1];
  
+ #ifdef	WIN32
+ BOOL
+ get_time_w32( HANDLE hFile, LPDWORD result )
+ {
+     WORD		dos_date, dos_time ;
+     FILETIME		ft_c, ft_a, ft_w, ft_lw ;
+ 
+     if ( GetFileTime( hFile, &ft_c, &ft_a, &ft_w ) != TRUE ) {
+ 	/* ̎擾łȂ */
+ 	fprintf( stderr, "Error:GetFileTime(%d)\n", GetLastError() ) ;
+ 	return FALSE ;
+     }
+     if ( FileTimeToLocalFileTime( &ft_w, &ft_lw ) != TRUE ) {
+ 	/* [Jt@Ctւ̕ϊłȂ */
+ 	fprintf( stderr, "Error:FileTimeToLocalFileTime(%d)\n", GetLastError() ) ;
+ 	return FALSE ;
+     }
+     if ( FileTimeToDosDateTime( &ft_lw, &dos_date, &dos_time ) != TRUE ) {
+ 	/* [Jt@Ctւ̕ϊłȂ */
+ 	fprintf( stderr, "Error:FileTimeToDosDateTime(%d)\n", GetLastError() ) ;
+ 	return FALSE ;
+     }
+     *result = (((DWORD)dos_date) << 16) | (DWORD)dos_time ;
+     return TRUE ;
+ }
+ 
+ BOOL
+ get_size_w32( HANDLE hFile, LPDWORD result )
+ {
+     DWORD	size ;
+ 
+     /* t@CTCY擾 */
+     size = GetFileSize( hFile, NULL ) ;
+     if ( size == 0xFFFFFFFF ) {
+ 	fprintf( stderr, "Error:GetFileSize(%d)\n", GetLastError() ) ;
+ 	return FALSE ;
+     }
+     *result = size ;
+     return TRUE ;
+ }
+ 
+ int
+ mkdir( const char *name )
+ {
+     if ( CreateDirectory( name, NULL ) != TRUE ) {
+ 	fprintf( stderr, "Error:CreateDirectory(%d)\n", GetLastError() ) ;
+ 	return -1 ;
+     }
+     return 0 ;
+ }
+ 
+ int
+ rmdir( const char *name )
+ {
+     if ( RemoveDirectory( name ) != TRUE ) {
+ 	fprintf( stderr, "Error:RemoveDirectory(%d)\n", GetLastError() ) ;
+ 	return -1 ;
+     }
+     return 0 ;
+ }
+ 
+ int
+ chdir( const char *name )
+ {
+     if ( SetCurrentDirectory( name ) != TRUE ) {
+ 	fprintf( stderr, "Error:SetCurrentDirectory(%d)\n", GetLastError() ) ;
+ 	return -1 ;
+     }
+     return 0 ;
+ }
+ 
+ char *
+ getcwd( char *buffer, int maxlen )
+ {
+     /* JgfBNg擾 */
+     if ( !GetCurrentDirectory( maxlen, buffer ) ) {
+ 	fprintf( stderr, "Error:GetCurrentDirectory(%d)\n", GetLastError() ) ;
+ 	return NULL ;
+     }
+     return buffer ;
+ }
+ 
+ int
+ unlink( const char *filename )
+ {
+     if ( DeleteFile( filename ) != TRUE ) {
+ 	fprintf( stderr, "Error:DeleteFile(%d)\n", GetLastError() ) ;
+ 	return -1 ;
+     }
+     return 0 ;
+ }
+ #endif	/* WIN32 */
  
  void ltos(char *s, unsigned long l)
  {
***************
*** 36,44 ****
  }
  
      
! /* DOS$BIw$N%?%$%`%9%?%s%W$rJV$9(B */
  unsigned long tmstamp(char *name)
  {
      struct stat sb;
      time_t clock;
      struct tm *p;
--- 136,166 ----
  }
  
      
! /* DOS̃^CX^vԂ */
  unsigned long tmstamp(char *name)
  {
+ #ifdef	WIN32
+     DWORD		time ;
+     HANDLE		hSrc ;
+ 
+     hSrc = CreateFile( name,
+ 			GENERIC_READ,
+ 			FILE_SHARE_READ,
+ 			NULL,
+ 			OPEN_EXISTING,
+ 			FILE_ATTRIBUTE_NORMAL|FILE_FLAG_SEQUENTIAL_SCAN,
+ 			NULL ) ;
+     if ( hSrc == INVALID_HANDLE_VALUE ) {
+ 	/* t@CI[vłȂ */
+ 	fprintf( stderr, "Error:CreateFile(%s:%d)\n", name, GetLastError() ) ;
+ 	return 0UL ;
+     }
+     if ( get_time_w32( hSrc, &time ) != TRUE ) {
+ 	time = 0UL ;
+     }
+     CloseHandle( hSrc ) ;
+     return time ;
+ #else	/* WIN32 */
      struct stat sb;
      time_t clock;
      struct tm *p;
***************
*** 54,59 ****
--- 176,182 ----
      stamp.dos.mon = p->tm_mon + 1;
      stamp.dos.year = p->tm_mday + 1900 - 1980;
      return(stamp.val);
+ #endif	/* WIN32 */
  }
  
  
***************
*** 66,84 ****
  }
  
  
! /* $B%U%!%$%k$N%5%$%:$rJV$9(B */
  long filelength(char *name)
  {
      struct stat sb;
  
      stat(name, &sb);
      return(sb.st_size);
  }
  
  
! /* $B%U%!%$%k$N%?%$%W$rJV$9(B (00: $BIaDL$N%U%!%$%k(B, 02: $B%G%#%l%/%H%j(B) */
  int filetype(char *name)
  {
      struct stat sb;
  
      stat(name, &sb);
--- 189,243 ----
  }
  
  
! /* t@C̃TCYԂ */
  long filelength(char *name)
  {
+ #ifdef	WIN32
+     DWORD		size ;
+     HANDLE		hSrc ;
+ 
+     hSrc = CreateFile( name,
+ 			GENERIC_READ,
+ 			FILE_SHARE_READ,
+ 			NULL,
+ 			OPEN_EXISTING,
+ 			FILE_ATTRIBUTE_NORMAL|FILE_FLAG_SEQUENTIAL_SCAN,
+ 			NULL ) ;
+     if ( hSrc == INVALID_HANDLE_VALUE ) {
+ 	/* t@CI[vłȂ */
+ 	fprintf( stderr, "Error:CreateFile[3](%s:%d)\n", name, GetLastError() ) ;
+ 	return 0UL ;
+     }
+     if ( get_size_w32( hSrc, &size ) != TRUE ) {
+ 	size = 0UL ;
+     }
+     CloseHandle( hSrc ) ;
+     return size ;
+ #else	/* WIN32 */
      struct stat sb;
  
      stat(name, &sb);
      return(sb.st_size);
+ #endif	/* WIN32 */
  }
  
  
! /* t@C̃^CvԂ (00: ʂ̃t@C, 02: fBNg) */
  int filetype(char *name)
  {
+ #ifdef	WIN32
+     DWORD	attr ;
+ 
+     attr = GetFileAttributes( name ) ;
+     if ( attr == 0xFFFFFFFF ) {
+ 	/* t@C擾łȂꍇ */
+ 	fprintf( stderr, "Error:GetFileAttributes(%s:%d)\n", name, GetLastError() ) ;
+ 	return -1 ;
+     } else if ( attr & FILE_ATTRIBUTE_DIRECTORY ) {
+ 	return ISDIR ;
+     }
+     return ISREG ;
+ #else	/* WIN32 */
      struct stat sb;
  
      stat(name, &sb);
***************
*** 91,109 ****
      else {
  	return(-1);
      }
  }
  
  
! /* $B%G%#%/%9(B ($B%+%l%s%H%G%#%l%/%H%j(B) $B$N6u$-MFNL$rJV$9(B */
  long diskfree()
  {
      struct statfs buf;
      statfs(".", &buf);
      return(buf.f_bavail * buf.f_bsize);
  }
  
  
! /* $B%\%j%e!<%`%i%Y%k$H%G%#%9%/$N6u$-MFNL$rJV$9(B */
  char *volblock()
  {
      static volblk_t vol;
--- 250,279 ----
      else {
  	return(-1);
      }
+ #endif	/* WIN32 */
  }
  
  
! /* fBNX (JgfBNg) ̋󂫗eʂԂ */
  long diskfree()
  {
+ #ifdef	WIN32
+     DWORD	sec_clu, byte_sec, free_clu, num_clu ;
+ 
+     if ( GetDiskFreeSpace( NULL, &sec_clu, &byte_sec, &free_clu, &num_clu ) != TRUE ) {
+ 	fprintf( stderr, "Error:GetDiskFreeSpace(%d)\n", GetLastError() ) ;
+ 	return 0L ;
+     }
+     return sec_clu * byte_sec * free_clu ;
+ #else	/* WIN32 */
      struct statfs buf;
      statfs(".", &buf);
      return(buf.f_bavail * buf.f_bsize);
+ #endif	/* WIN32 */
  }
  
  
! /* {[xƃfBXN̋󂫗eʂԂ */
  char *volblock()
  {
      static volblk_t vol;
***************
*** 115,121 ****
  }
  
  
! /* $BJ8;zNs$NCf$NBgJ8;z$r>.J8;z$KJQ49$9$k(B */
  char *lowercase(char *s)
  {
      char *t;
--- 285,291 ----
  }
  
  
! /* ̒̑啶ɕϊ */
  char *lowercase(char *s)
  {
      char *t;
***************
*** 131,137 ****
  }
  
  
! /* $BJ8;zNs$NCf$N>.J8;z$rBgJ8;z$KJQ49$9$k(B */
  char *uppercase(char *s)
  {
      char *t;
--- 301,307 ----
  }
  
  
! /* ̒̏啶ɕϊ */
  char *uppercase(char *s)
  {
      char *t;
***************
*** 147,153 ****
  }
  
  
! /* $B%Q%9L>$+$i%U%!%$%kL>$@$1$r<h$j=P$9(B $BNc(B: foo/baa.c -> baa.c */
  char *filnam(char *path)
  {
      int i;
--- 317,330 ----
  }
  
  
! #ifdef	WIN32
! char *
! convname(char *path)
! {
!     return path ;
! }
! #else	/* WIN32 */
! /* pXt@Co : foo/baa.c -> baa.c */
  char *filnam(char *path)
  {
      int i;
***************
*** 170,182 ****
      strcpy(path, filnam(s));
      return(path);
  }
  
  
  #define validchar(c) \
  	((('a' <= (c)) && ((c) <= 'z')) || (('0' <= (c)) && ((c) <= '9')))
  
  
! /* $B%o%$%k%I%+!<%ICf$N(B '*' $B$r(B '?' $B$KE83+$9$k(B ($B<jH4$-HG(B) */
  char *expandwild(char *s)
  {
      static char t[100];
--- 347,403 ----
      strcpy(path, filnam(s));
      return(path);
  }
+ #endif	/* WIN32 */
  
+ #ifdef	WIN32
  
+ /* wildcard Ƀ}b`t@CԂ */
+ char **searchdir(char *wildcard)
+ {
+     /* fBNgJn */
+     WIN32_FIND_DATA	find ;
+     int			i = 0 ;
+     HANDLE		hSearch ;
+ 
+     hSearch = FindFirstFile( wildcard, &find ) ;
+     if ( hSearch != INVALID_HANDLE_VALUE ) {
+ 	while ( i < MAXDIRENT ) {
+ 	    char	*fn ;
+ 
+ 	    if ( find.cAlternateFileName && *find.cAlternateFileName ) {
+ 		fn = find.cAlternateFileName ;
+ 	    } else if ( find.cFileName && *find.cFileName && strlen( find.cFileName ) < FILNAMSIZ ) {
+ 		fn = find.cFileName ;
+ 	    } else {
+ 		fprintf( stderr, "Warning:LongFilename=%s ... skipped\n", find.cFileName ) ;
+ 		goto next ;
+ 	    }
+ 	    entries[i] = &filnams[FILNAMSIZ * i] ;
+ 	    strcpy( entries[i], fn ) ;
+ 	    ++ i ;
+ next:
+ 	    if ( FindNextFile( hSearch, &find ) != TRUE ) {
+ 		break ;
+ 	    }
+ 	}
+ 	FindClose( hSearch ) ;
+     } else {
+ 	fprintf( stderr, "Error:FindFirstFile(%s:%d)\n", wildcard, GetLastError() ) ;
+     }
+     if ( i == 0 ) {
+ 	entries[i] = &filnams[0] ;
+ 	strcpy( entries[i], "." ) ;
+ 	++ i ;
+     }
+     entries[i] = NULL ;
+     return entries ;
+ }
+ #else	/* WIN32 */
  #define validchar(c) \
  	((('a' <= (c)) && ((c) <= 'z')) || (('0' <= (c)) && ((c) <= '9')))
  
  
! /* ChJ[h '*'  '?' ɓWJ (蔲) */
  char *expandwild(char *s)
  {
      static char t[100];
***************
*** 193,199 ****
  
  #define DOTPOS 8
  
! /* $B%U%!%$%k$,%o%$%k%I%+!<%I$K%^%C%A$9$k$+$rD4$Y$k(B ($B<jH4$-HG(B) */
  int match(char *name, char *wild)
  {
      int i, j;
--- 414,420 ----
  
  #define DOTPOS 8
  
! /* t@CChJ[hɃ}b`邩𒲂ׂ (蔲) */
  int match(char *name, char *wild)
  {
      int i, j;
***************
*** 229,235 ****
  }
  
  
! /* wildcard $B$K%^%C%A$9$k%U%!%$%kL>$rJV$9(B */
  char **searchdir(char *wildcard)
  {
      DIR *dirp;
--- 450,456 ----
  }
  
  
! /* wildcard Ƀ}b`t@CԂ */
  char **searchdir(char *wildcard)
  {
      DIR *dirp;
***************
*** 254,263 ****
--- 475,518 ----
      entries[i] = NULL;
      return(entries);
  }
+ #endif	/* WIN32 */
  
  
  char *direntry(char *name)
  {
+ #ifdef	WIN32
+     static lxdirent	entry;
+     HANDLE		hSrc ;
+     DWORD		time, size ;
+ 
+     /* entry  */
+     entry.type = (filetype(name) == ISDIR) ? ENTDIR : ENTFIL;
+     ltos( entry.ts, 0UL ) ;
+     ltos( entry.sz, 0UL ) ;
+     strcpy( entry.name, name ) ;
+     if ( entry.type == ENTFIL ) {
+ 	/* t@C̑𓾂 */
+ 	hSrc = CreateFile( name,
+ 			   GENERIC_READ,
+ 			   FILE_SHARE_READ,
+ 			   NULL,
+ 			   OPEN_EXISTING,
+ 			   FILE_ATTRIBUTE_NORMAL|FILE_FLAG_SEQUENTIAL_SCAN,
+ 			   NULL ) ;
+ 	if ( hSrc != INVALID_HANDLE_VALUE ) {
+ 	    if ( get_time_w32( hSrc, &time ) == TRUE ) {
+ 		ltos( entry.ts, time ) ;
+ 	    }
+ 	    if ( get_size_w32( hSrc, &size ) == TRUE ) {
+ 		ltos( entry.sz, size ) ;
+ 	    }
+ 	    CloseHandle( hSrc ) ;
+ 	} else {
+ 	    fprintf( stderr, "Error:CreateFile[2](%s:%d)\n", name, GetLastError() ) ;
+ 	}
+     }
+     return (char*) &entry ;
+ #else	/* WIN32 */
      static lxdirent entry;
  
      entry.type = (filetype(name) == ISDIR) ? ENTDIR : ENTFIL;
***************
*** 265,268 ****
--- 520,524 ----
      ltos(entry.sz, filelength(name));
      strcpy(entry.name, name);
      return((char *)&entry);
+ #endif	/* WIN32 */
  }
*** org\tty.c	Mon Jun 10 23:02:20 1996
--- tty.c	Sat Jun 15 12:33:14 1996
***************
*** 1,80 ****
  /*
!  *  tty.c -- RS-232C o͊֘A
   *
   *  revision history:
!  *	0.0: May 19, 1996 by Dai ISHIJIMA
   */
  
! #include <stdio.h>
! #include <fcntl.h>
! 
! #define FILEMODE 0777
! #define TIMEOUT 15
! 
! 
! /* ǂݏpɃI[v */
! int opentty(char *name)
  {
!     int fd;
  
!     if ((fd = open(name, O_RDWR | O_NONBLOCK, FILEMODE)) <= 0) {
! 	fprintf(stderr, "can't open %s\n", name);
! 	exit(1);
      }
!     return(fd);
  }
  
! 
! /* Rg[o͂ł悤ɁARAW[hɂ */
! void ttyraw(char *name)
! {
!     char s[BUFSIZ];
! 
!     sprintf(s, "stty -f %s raw clocal", name);
!     system(s);
!     sprintf(s, "stty -f %s dsusp undef erase undef werase undef", name);
!     system(s);
!     sprintf(s, "stty -f %s lnext undef quit undef reprint undef", name);
!     system(s);
!     sprintf(s, "stty -f %s susp undef intr undef eof undef kill undef", name);
!     system(s);
!     sprintf(s, "stty -f %s discard undef start undef stop undef", name);
!     system(s);
!     /* system() ĝ͂܂悢@ł͂Ȃł f(^^;) */
! }    
! 
! 
! /* 𑗐M */
! int ttyputc(int fd, char ch)
  {
!     int status;
!     time_t t;
  
!     t = time(NULL);
!     while ((status = write(fd, &ch, 1)) < 1) {
! #if 0	
! 	if (status < 0) {
! 	    fprintf(stderr, "ttyputc(): write failed\n");
! 	    return(EOF);
  	}
! #endif
! 	if (time(NULL) - t > TIMEOUT) {
! 	    fprintf(stderr, "ttyputc(): timeout\n");
! 	    return(EOF);
! 	}
      }
!     return(ch);
  }
  
! 
! /* MBMobt@̂Ƃ EOF 𑗂 */
! int ttygetc(int fd)
  {
!     unsigned char buf[1];
!     
!     if (read(fd, &buf[0], 1) != 1) {
! 	return(EOF);
      }
!     return(buf[0]);
  }
  
--- 1,122 ----
  /*
!  *  tty.c -- RS-232C o͊֘A(WIN32API Version)
   *
   *  revision history:
!  *	0.0: Jun. 14, 1996 by Eiichiroh ITOH(WIN32 Version)
   */
+ #define		STRICT
+ #include	<windows.h>
+ #include	<stdio.h>
+ #include	<stdlib.h>
+ #include	<conio.h>
+ 
+ #define		EXCEPTION_USER			0xEFFFFFFF
+ 
+ HANDLE			hComm ;
+ DCB				CommDCB ;
+ COMMTIMEOUTS	CommTimeouts ;
  
! int
! ttyputc( int fd, char ch )
  {
!     DWORD	nWrite ;
  
!     if ( WriteFile( hComm, &ch, 1, &nWrite, NULL ) != TRUE || nWrite != 1 ) {
! 	return EOF ;
      }
!     return ch ;
  }
  
! int
! ttygetc( int fd )
  {
!     DWORD	nRead ;
!     char	ch ;
  
!     if ( ReadFile( hComm, &ch, 1, &nRead, NULL ) != TRUE || nRead != 1 ) {
! 	if ( kbhit() && getch() == 27 ) {
! 	    /* ESC ͂ł߂Ă܂ */
! 	    RaiseException(	EXCEPTION_USER, 0, 0, NULL ) ;
  	}
! 	return EOF ;
      }
!     return 0xFF & ch ;
  }
  
! int
! ttycount( int fd )
  {
!     COMSTAT	ComStat ;
!     DWORD	dwErrorFlags ;
!     if ( ClearCommError( hComm, &dwErrorFlags, &ComStat ) != TRUE ) {
! 	return 0 ;
      }
!     return (int) ComStat.cbInQue ;
  }
+  
+ BOOL
+ opentty_w32( LPSTR name, DWORD baud )
+ {
+     hComm = CreateFile( name,
+ 			GENERIC_READ|GENERIC_WRITE,
+ 			0,
+ 			NULL,
+ 			OPEN_EXISTING,
+ 			FILE_ATTRIBUTE_NORMAL,
+ 			NULL ) ;
+     if ( hComm == INVALID_HANDLE_VALUE ) {
+ 	fprintf( stderr, "Can't open port named '%s'(error=%d).\n", name, GetLastError() ) ;
+ 	return FALSE ;
+     }
+     if ( SetCommMask( hComm, EV_RXCHAR ) != TRUE ) {
+ 	fprintf( stderr, "Error:SetCommMask:%d\n", GetLastError() ) ;
+ 	CloseHandle( hComm ) ;
+ 	return FALSE ;
+     }
+     if ( SetupComm( hComm, 2000L, 2000L ) != TRUE ) {
+ 	fprintf( stderr, "Error:SetupComm:%d\n", GetLastError() ) ;
+ 	CloseHandle( hComm ) ;
+ 	return FALSE ;
+     }
+     CommTimeouts.ReadIntervalTimeout = MAXDWORD ;
+     CommTimeouts.ReadTotalTimeoutMultiplier = 0 ;
+     CommTimeouts.ReadTotalTimeoutConstant = 1000 ;
+     CommTimeouts.WriteTotalTimeoutMultiplier = 0 ;
+     CommTimeouts.WriteTotalTimeoutConstant = 10000 ;
+     if ( SetCommTimeouts( hComm, &CommTimeouts ) != TRUE ) {
+ 	fprintf( stderr, "Error:SetCommTimeouts:%d\n", GetLastError() ) ;
+ 	CloseHandle( hComm ) ;
+ 	return FALSE ;
+     }
+     if ( GetCommState( hComm, &CommDCB ) != TRUE ) {
+ 	fprintf( stderr, "Error:GetCommState:%d\n", GetLastError() ) ;
+ 	CloseHandle( hComm ) ;
+ 	return FALSE ;
+     }
+     CommDCB.DCBlength = sizeof (DCB) ;
+     CommDCB.BaudRate = baud ;
+     CommDCB.fBinary = TRUE ;
+     CommDCB.ByteSize = 8 ;
+     CommDCB.Parity = NOPARITY ;
+     CommDCB.StopBits = ONESTOPBIT ;
+     CommDCB.fRtsControl = RTS_CONTROL_HANDSHAKE ;
+     CommDCB.fOutxCtsFlow = TRUE ;
+     CommDCB.fInX = CommDCB.fOutX = FALSE ;
+     CommDCB.XonChar = 0 ;
+     CommDCB.XoffChar = 0 ;
+     CommDCB.XonLim = 0 ;
+     CommDCB.XoffLim = 0 ;
+     CommDCB.fParity = FALSE ;
+     if ( SetCommState( hComm, &CommDCB ) != TRUE ) {
+ 	fprintf( stderr, "Error:SetCommState:%d\n", GetLastError() ) ;
+ 	CloseHandle( hComm ) ;
+ 	return FALSE ;
+     }
+     return TRUE ;
+ }
  
+ void
+ closetty_w32( void )
+ {
+     CloseHandle( hComm ) ;
+ }
