#define STRICT

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <io.h>
#include <process.h>
#include <fcntl.h>
#include <sys\stat.h>
#include <alloc.h>
#include <dos.h>

#include <windows.h>

#define CLM 8
#define cursor_on() printf( "\x1B[>5l" );
#define cursor_off() printf( "\x1B[>5h" );
#define cursor( x, y ) printf( "\x1B[%d;%dH", y+1, x+1 );
#define lineup( n ) printf( "\x1B[%dA", n );
/*------------------------------------------------------------------
【ファイル読み込み】
in : WORD  wHandle ファイルハンドル
	 LPSTR lpFPTR  ファイル格納ポインタ
	 DWORD dwSize  ファイルサイズ

out: なし
------------------------------------------------------------------*/
void LoadFile( WORD wHandle, char huge *lpFPTR, DWORD dwSize ){
	PSTR pPTR;
	WORD i;
	pPTR = malloc( 8192 );
	while( dwSize > 8192 ){
		i = read( wHandle, pPTR, 8192 );
		movedata( FP_SEG(pPTR), FP_OFF(pPTR),
								FP_SEG(lpFPTR), FP_OFF(lpFPTR),8192 );
		dwSize -= i;
		lpFPTR += i;
	}
	i = read( wHandle, pPTR, dwSize );
	movedata( FP_SEG(pPTR), FP_OFF(pPTR),
								FP_SEG(lpFPTR), FP_OFF(lpFPTR),i );
}
/*------------------------------------------------------------------
【ファイル書き込み】
in : WORD wHandle  ファイルハンドル
	 LPSTR lpFPTR  ファイル格納ポインタ
	 DWORD dwSize  ファイルサイズ

out: なし
------------------------------------------------------------------*/
void SaveFile( WORD wHandle, char huge *lpFPTR, DWORD dwSize ){
	PSTR pPTR;
	WORD i;
	pPTR = malloc( 8192 );
	while( dwSize > 8192 ){
		movedata( FP_SEG(lpFPTR), FP_OFF(lpFPTR),
								FP_SEG(pPTR), FP_OFF(pPTR), 8192 );
		i = write( wHandle, pPTR, 8192 );
		dwSize -= i;
		lpFPTR += i;
	}
	movedata( FP_SEG(lpFPTR), FP_OFF(lpFPTR),
								FP_SEG(pPTR), FP_OFF(pPTR), dwSize );
	write( wHandle, pPTR, dwSize );
}
/*------------------------------------------------------------------
【ＳＬＤデコーダ】
in : char huge *lpSrc  圧縮データエントリ
     char huge *lpDst  展開データバッファ
out: DWORD  展開データの大きさ
------------------------------------------------------------------*/
static DWORD DecodeSLD( char huge *lpSrc, char huge *lpDst ){
	WORD Count;
	DWORD ExSize=0;
	char huge *lpSLDPtr;

	while (*lpSrc != 0){
		Count = (WORD)*lpSrc++;
		if ((Count & 0x80) == 0){
			ExSize += Count;
			while (Count--){				/* 非圧縮データ展開 */
				*lpDst++ = *lpSrc++;
			}
		}else{
			Count &= 0x7F;					/* 圧縮データ展開 */
			Count += 3;
			ExSize += (WORD)Count;
			lpSLDPtr = lpDst - LOBYTE(*lpSrc++) - 1;
			while (Count--){
				*lpDst++ = *lpSLDPtr++;
			}
		}
	}
	return (ExSize);						/* 展開データサイズ */
}
/*------------------------------------------------------------------
【ＳＬＤエンコーダ】
in : char huge *lpSrc  元データエントリ
     DWORD dwSrcSize   元データサイズ
     char huge *lpDst  圧縮データバッファ
out: DWORD  圧縮データの大きさ
------------------------------------------------------------------*/
static DWORD EncodeSLD( char huge *lpSrc, DWORD dwSrcSize, char huge *lpDst ){
	BYTE SLDBUF[256];
	WORD i,j;
	WORD s,d;
	WORD max;

	char huge *lpSSPtr;
	char huge *lpSDPtr;

	DWORD dwSrcCount;			/* Src counter */
	DWORD dwDstCount;			/* Dst counter */
	WORD wDicPtr = 0;			/* Dic pointer */
	WORD wDicCount = 0;			/* Dic counter */
	WORD wBufCount = 0;			/* SLDBUF counter */

	lpSSPtr = lpSDPtr = lpSrc;
	dwSrcCount = dwDstCount = 0;

	SLDBUF[wBufCount++] = *lpSrc++;			/* 一文字めをバッファに */
	dwSrcCount++;

	while ( dwSrcSize > dwSrcCount ){
		s = 256;
		if ( dwSrcCount < (DWORD)s ) s = dwSrcCount;

		wDicPtr = wDicCount = d = 0;
		max = dwSrcSize - dwSrcCount;
		if( max > 0x7F+3 ) max = 0x7F+3;
		for ( i=0; i<s; i++ ){					/* 最長一致文字列の検索 */
			d++;
			lpSSPtr = lpSrc;
			lpSDPtr = lpSSPtr - d;
			if ( *lpSSPtr == *lpSDPtr ){
				for ( j=0; j<max; j++ ){
					if( *lpSSPtr++ != *lpSDPtr++ ) break;
				}
				if( wDicCount < j ){
					wDicCount = j;
					wDicPtr = d;
				}
			}
		}
		if ( wDicCount >= 3 ){
			if ( wBufCount ){
				*lpDst++ = (BYTE)wBufCount;
				dwDstCount++;
				for ( i = 0; i < wBufCount; i++ ){
					*lpDst++ = (BYTE)SLDBUF[i];
					dwDstCount++;
				}
				wBufCount = 0;
			}
			lpSrc += wDicCount;
			dwSrcCount += wDicCount;
			*lpDst++ = (BYTE)((wDicCount-3)|0x80);
			*lpDst++ = (BYTE)wDicPtr-1;
			dwDstCount += 2;
		}else{
			SLDBUF[wBufCount++] = *lpSrc++;			/* バッファに格納 */
			dwSrcCount++;
			if ( wBufCount == 0x7F ){
				*lpDst++ = (BYTE)wBufCount;
				dwDstCount++;
				for ( i = 0; i < wBufCount; i++ ){
					*lpDst++ = (BYTE)SLDBUF[i];
					dwDstCount++;
				}
				wBufCount = 0;
			}
		}
	}
	if ( wBufCount ){
		*lpDst++ = (BYTE)wBufCount;
		dwDstCount++;
		for ( i = 0; i < wBufCount; i++ ){
			*lpDst++ = (BYTE)SLDBUF[i];
			dwDstCount++;
		}
		wBufCount = 0;
	}
	*lpDst++ = 0;								/* エンドマーク */
	dwDstCount++;
	return( dwDstCount );
}
/*------------------------------------------------------------------
	試験
------------------------------------------------------------------*/
void TestExSLD( PSTR argv[] ){
	BYTE srcfile[128],dstfile[128];	//入力・出力パス＆ファイル名
	char huge *lpSRC,huge *lpDST;
	short hSRC,hDST;
	WORD i,j,k,l,m,n;				//作業用
	DWORD dwSize;

	sscanf( argv[1], "%s", srcfile );
	sscanf( argv[2], "%s", dstfile );

	if (( hDST = open( dstfile, O_CREAT|O_WRONLY|O_BINARY,
										S_IREAD|S_IWRITE )) == -1 ){
		fprintf( stderr, "Cannot open DST file.\n" );
		exit(1);
	}
	if (( hSRC = open( srcfile, O_BINARY|O_RDWR )) == -1 ){
		fprintf( stderr, "Cannot open SRC file.\n" );
		exit(1);
	}
	dwSize = filelength( hSRC );

	lpSRC = farmalloc( dwSize );

	lpDST = farmalloc( dwSize );

	LoadFile( hSRC, lpSRC, dwSize );
	//dwSize = DecodeSLD( lpSRC, lpDST );
	printf( "元データサイズ　%d\n",dwSize );

	dwSize = EncodeSLD( lpSRC, dwSize, lpDST );
	printf( "圧縮データサイズ　%d\n",dwSize );

	printf( "%d\r\n",dwSize );

	SaveFile( hDST, lpDST, dwSize );

	close( hDST );
	close( hSRC );

}

void main( WORD argc, PSTR *argv )
{
	PSTR argp;
	cursor_off();

	if ( argc == 3 ){
		TestExSLD( argv );
	}
	cursor_on();
}