/* DIVIDE_START=collect.c */
/*
	ＮＩＦＴＹのＬＯＧ整理				collect.c
*/

#include	"catlog.h"
#include	<dir.h>
#include	<fcntl.h>
#include	<process.h>

extern	int		max_tmp0_size;

#define	TEST	1
#undef	TEST

static	char	input_path_name[ 128 ];

int		do_not_consol_out_sw = TRUE;	/* use only consol.c */

#define	MAX_ARGV	20
static	char	*SpawnArgv[ MAX_ARGV + 1 ];
static	int		SpawnArgvP= 0;

static	void	SpawnTree( const char *mes )
{
	if ( SpawnArgvP >= MAX_ARGV ) {
		/* エラー */
		error_bug( "コマンドラインの引数の数が多すぎます(in SpawnTree)" );
	};
	SpawnArgv[ SpawnArgvP ] = malloc( strlen( mes ) + 2 );
	if ( SpawnArgv[ SpawnArgvP ] == NULL ) {
		/* メモリーが足りません エラー */
		error_bug( "メモリーが足りません(in SpawnTree)" );
	};
	strcpy( SpawnArgv[ SpawnArgvP++ ], mes);
	SpawnArgv[ SpawnArgvP ] = NULL;
}

static	void	collect_system( char *Command )
{
	int		i;

	mess_check {
		color( GREEN );
		printf( "\n%s", Command );
		for ( i =0; i<SpawnArgvP; i++ )		printf( " %s", SpawnArgv[i] );
		color( WHITE );
/*
		puts( " を起動します" );
*/
	};
	fclose( catlog_fpo );
	catlog_mes_file_close();
	do_not_consol_out_sw = FALSE;
	mess_check do_not_consol_out_sw = TRUE;

	i = spawnvpe( P_WAIT, Command, SpawnArgv, NULL );

	do_not_consol_out_sw = TRUE;
	catlog_mes_file_reopen();
	open_append_tmp0_file();

	if (	i != 0
/*
	||		errno != 0
	||		_dos_errno != 0
*/
	) {
		/* _dos_errno に MS-DOS のエラーコードが入る */
		switch( errno ) {
			case EFUNCTION:	puts( "\nP_WAIT で起動していない" );	break;
			case ENOMEM:	puts( "\nメモリーが不足した" );		break;
			case ENOENT:	puts( "\nパス名またはファイルが見つからない" );
																break;
			case E2BIG:		puts( "\n引数リストが長すぎる" );		break;
			case EACCESS:	puts( "\nEACCESS エラーです" );		break;
			case ENOEXEC:	puts( "\nexecフォーマットエラー" );	break;
			default:
				printf( "\nエラーです errno=%02x _dos_errno=%02x\n"
							, errno
							, _dos_errno
				);												break;
		};
		puts( "\nというエラーが発生しました\n処理を中断します" );
		error_end( );
	};

	/* 確保していたメモリーを解放する */
	for ( i =0; i<SpawnArgvP; i++ )		free( SpawnArgv[i] );
	SpawnArgvP= 0;
}

void	rmdir( char *path )
{
	_dos_rmdir( path );
}

static	void	call_divide_main()
{
	fclose( catlog_fpo );
	mess_check puts("\n分割処理中です。しばらくお待ち下さい。\n");
	divide_main();
	open_out_tmp0_file();
}

void	check_drive_space( int fsize )
{
			int			drive , drive_free;
	struct	_disk_space info;

	if ( TmpDir[ 1 ] == ':' ) {
		drive = toupper( TmpDir[ 0 ] ) & 0x0f;
	} else {
		drive = 0;	/* ｶﾚﾝﾄ drive */
	};
	info = _dos_get_disk_space( drive );
	drive_free = info.nsectors * info.free_clusters * info.nbytes;
/*
	printf("\n%s : %ld\n", TmpDir , drive_free);
*/

	if ( drive_free < fsize * 2 ) call_divide_main();
}

/************************************************************************/
/*                                                                      */
/*   check : tmp file かどうか                                          */
/*                                                                      */
/************************************************************************/
static	void	append_done_file( const char *file_path , unsigned long ftime )
{
	char	file[ 128 ];
	FILE	*fp;

	/************************************************/
	/* 時刻のチェックを行わない場合は append しない */
	/************************************************/
	if ( NoTimeStampFile == YES ) return;

	sprintf( file, "%s%s", input_path_name, DONE_FILE_NAME );
	if ( ( fp = fopen( file , "a") ) == NULL ) {
		strcpy( file_name , file );
		error_open_file( "append_done_file" );	exit( 1 );
	};
	fprintf( fp , "%-50s %ld\n" , file_path , ftime );
	fclose(fp);
}

static	int	is_done_file( const char *file_path , unsigned long ftime )
{
				int		sw,len;
				size_t	done_fsize;
	unsigned	long	gftime;
				char	sub[ 128 ] , *p;

	/******************************************************/
	/* 時刻のチェックを行わない場合は検索していないとする */
	/******************************************************/
	if ( NoTimeStampFile == YES ) return( FALSE );

	/**********************/
	/* file_name[] を保存 */
	/**********************/
	strcpy( sub , file_name );

	sprintf( file_name, "%s%s", input_path_name, DONE_FILE_NAME );

	done_fsize = file_size();

	sw = FALSE;
	if (	done_fsize != 0		/* 初めての起動ではない */
	&&	initial_check_pool( done_fsize , NO ) != FALSE
	) {	/* file.c */
		len = strlen( file_path );
		forever {
			GET_LINE2 break;
			p = PSP;
			while ( *p != ' ' ) p++;
			p++;
			gftime = atol( p );
			if (	ftime == gftime
			&&		strncmp( PSP , file_path , len ) == 0
			) {
				sw = TRUE;	break;
			};
		};
		end_check_pool();
	};
	strcpy( file_name , sub );

	return ( sw );
}

static	int	isWithoutDelFile( char *f_name )
{
	int		i;
	char	*p1 , *p2;
	char	name1[ 12 ] , atr1[ 4 ];
	char	name2[ 12 ] , atr2[ 4 ];

	/***********************************************/
	/* S:xxxx が設定されていない場合は全部検索する */
	/***********************************************/
	if ( max_WithoutDelFileName == 0 )	return( NO );

	p1 = (char *)last_comma( f_name );
	if ( p1 == f_name ) {	/* 拡張子なし */
		strcpy( name1 , f_name );	strcpy( atr1 , "" );
	} else {
		strncpy( name1 , f_name , p1 - f_name );
		name1[ p1 - f_name ] = '\0';
		strcpy( atr1 , p1 + 1 );
	};
	for ( i=0 ; i<max_WithoutDelFileName ; i++ ) {
		p2 = WithoutDelFileName[ i ];
		p1 = (char *)last_comma( p2 );
		if ( p1 == p2 ) {	/* 拡張子なし */
			strcpy( name2 , p2 );		strcpy( atr2 , "" );
		} else {
			strncpy( name2 , p2 , p1 - p2 );	name2[ p1 - p2 ] = '\0';
			strcpy( atr2 , p1 + 1 );
		};
		if (	isSearchFileSub( name1 , name2 ) == YES
		&&		isSearchFileSub( atr1 , atr2 ) == YES
		) return( YES );
	};
	return( NO );
}

/*
  MDDhmmss.LOG	:	Mの所を数字かA,B,Cである
					hの所を数字かA,B,C,D,E,F,G,H,I,J,K,L,P,Qであること
*/
static	int	isFAPXfileFL( const char *f_name )
{
	int		c;

	if ( matchstr(f_name,"?%%?%%%%") == FALSE )					return( NO );
	c = f_name[ 0 ];
	if ( ! isdigit( c ) ) {
		if ( c < 'A' || 'C' < c )								return( NO );
	};
	c = f_name[ 3 ];
	if ( ! isdigit( c ) ) {
		if ( c < 'A' || 'Q' < c )								return( NO );
	};
	return( YES );
}

static	int	isFAPXfile( const char *f_name )
{
	char	str1[ 16 ] , *p;

#ifdef	TEST
	printf("\n isFAPXfile(%s)です。",f_name);
#endif

	/* ファイル名の長さは 10 文字以上？ */
	if ( strlen( f_name ) < 10 )			return( FALSE );

	strcpy( str1 , f_name );
	if ( isFAPXfileFL( str1 ) != YES )		return( FALSE );

	/* 拡張子は下の通り？ */
	p = (char *)last_comma( str1 );
	if ( strcmp( p , ".LOG" ) == 0 )		return( TRUE );
	if ( strcmp( p , ".EML" ) == 0 )		return( TRUE );
	if ( strcmp( p , ".BML" ) == 0 )		return( TRUE );
	if ( strcmp( p , ".RES" ) == 0 )		return( TRUE );
	if ( strcmp( p , ".UP" ) == 0 )			return( TRUE );
	if ( strcmp( p , ".NPB" ) == 0 )		return( TRUE );
	return( FALSE );
}

int		isTmpFile( char *file )
{
	char	*ptr;

	if ( CATLOG_tmp_file( file ) == YES )						return( YES );

	ptr = (char *)last_comma( file );

	if ( search_all_file_sw == YES ) {	/* 全ﾌｧｲﾙの検索 */
		/* 拡張子が .TMP のものは検索しない */
		if ( strcmp( ptr , ".TMP" ) == 0 )						return( YES );
		return( NO );
	};

	if ( isWithoutSearchFile( file ) == YES )					return( YES );

	if ( strcmp( ptr , ".COM" ) == 0 )							return( YES );
	if ( strcmp( ptr , ".EXE" ) == 0 )							return( YES );
	if ( strcmp( ptr , ".EXP" ) == 0 )							return( YES );
	if ( strcmp( ptr , ".IDX" ) == 0 )							return( YES );
	if ( strcmp( ptr , ".BML" ) == 0 )							return( YES );
	if ( strcmp( ptr , ".NAP" ) == 0 )							return( YES );
	if ( strcmp( ptr , ".NPB" ) == 0 )							return( YES );

	if ( strcmp( ptr , ".LZH" ) == 0 )							return( YES );

/*
	if ( strcmp( ptr , ".ISH" ) == 0 )							return( YES );
*/
/*
　除外ファイルには、*.BML(FAPXが作成するバイナリメールファイル名)と*.NAP
(FAPXが作成するNAPLPSメールファイル名)を追加してもいいかもしれませんね。
*.ISHも除外してもいいかもしれないけど、ちょっと迷ってしまうところです。
		ありがとう Yama-Chan

　また、このような内部情報を持つことは可搬性に欠けるとする<Nakatani>さん
の意見も無視できないが、取り敢えずということで入れています。
*/

	if ( strcmp( file , ALL_IN_1_MAIL_FILE_NAME ) == 0 )		return( YES );

	if ( matchstr(file, "$$$%%%%%") == TRUE ) {
		if ( isdigit( ptr[3] ) ) {
			if (	strncmp( ptr , ".HP" , 3 ) == 0			/* HP */
			||		strncmp( ptr , ".ML" , 3 ) == 0			/* MAIL */
			||		strncmp( ptr , ".ID" , 3 ) == 0			/* インデックス */
			||		strncmp( ptr , ".TX" , 3 ) == 0			/* Collect ID */
			||		strncmp( ptr , ".PA" , 3 ) == 0			/* PATIO */
			||		strncmp( ptr , ".LIB" , 4 ) == 0		/* Collect LIB */
			) {
																return( YES );
			};
		};
	};

	/* BILL_FILE_NAME.BLx */
	if ( strncmp( file,BILL_FILE_NAME,strlen( BILL_FILE_NAME ) ) == 0 ) {
		if ( isdigit( ptr[3] ) ) {
			if ( strncmp( ptr , ".BL" , 3 ) == 0 )	return( YES );
		};
	};

	if ( matchstr(file, "MES%%_%%.TXT")==TRUE )					return( YES );
	if ( matchstr(file, "LIB%%.TXT"   )==TRUE )					return( YES );
	return( NO );
}

/**********************************************/
/* file_name がそのファイルへのフルパスである */
/**********************************************/
static	int		is_delete_old_file( const char *ff_name )
{
	int		date;
	char	file[ 16 ] , *p;

	if ( strlen( ff_name ) != 12 )					return( NO );

	strcpy( file , ff_name );

	/****************/
	/* FAPXのﾌｧｲﾙ ? */
	/****************/
	if ( isFAPXfile( ff_name ) == FALSE )			return( NO );

	/************************/
	/* 削除しないファイル？ */
	/************************/
	if ( isWithoutDelFile( file ) == YES )			return( NO );

	/*********************************/
	/* 拡張子は LOG or EML or RES ？ */
	/*********************************/
	p = (char *)last_comma( file );
	if (	strcmp( p , ".LOG" ) != 0
	&&		strcmp( p , ".RES" ) != 0
	&&		strcmp( p , ".UP" ) != 0
	&&		strcmp( p , ".EML" ) != 0
	&&		strcmp( p , ".NPB" ) != 0
	)												return( NO );

	/******************************/
	/* ファイルの年月日のチェック */
	/******************************/
	if ( FapxLogMode == 2 ) {				/* 圧縮あり */
		/* 月の設定 */
		date = (*file) & 0x0f;		if ( ! isdigit( *file ) ) date += 9;
		/* 日の設定 */
		file[ 3 ] = '\0';			date = date * 100 + atoi( file + 1 );
		/* 年の設定 */
		strcpy( file , today );	file[ 2 ] = '\0';
		date = atoi( file ) * 10000 + date;
		/* CATLOGの内部形式に変更 */
		date = date * 100;
		/* 文字列に変更 */
		sprintf( file , "%-8d" , date );
		file_name_space_0( file );
	};
	file[ 8 ] = '\0';
	if ( strcmp( file , today ) >= 0 )				return( NO );

	return( YES );
}

static	void	do_delete_old_file( const char *file_name )
{
	if ( QuietSw != YES ) {
		color( YELLOW );
		printf("\n\t<%s>を削除します" , file_name );
		color( WHITE );
	};
	remove( file_name );
}

/**********************************************/
/* file_name がそのファイルへのフルパスである */
/*                            1993.12.29 修正 */
/**********************************************/
static	void	delete_old_file( const char *ff_name )
{
	char	*p;

	/* FAPXが作るファイル以外は削除の対象から外す */
	if ( is_delete_old_file( ff_name ) == NO )		return;

	p = (char *)last_comma( ff_name );

	/* 強制削除 */
	if ( ForcedDeleteOldFileSw == YES ) {
		do_delete_old_file( file_name );	return;
	};

	/* RESファイルの強制削除 */
	if ( DeleteFapxResFileSw == YES ) {
		if (	strcmp( p , ".RES" ) == 0
		||		strcmp( p , ".UP"  ) == 0
		) {
			do_delete_old_file( file_name );
		};
		return;
	};

	/* スイッチのチェック */
	if ( DeleteOldFileSw == NO )					return;

	if ( QuietSw != YES ) {
		color( YELLOW );
		printf("\n\t<%s>を削除しても良いですか？ ",file_name);
		color( WHITE );
		if ( get_yesno_mes() == NO )	return;
	};

	/************************/
	/* ファイルを消すよ〜〜 */
	/************************/
	remove( file_name );
}

#ifdef	TURBO_C
static	int	dos_time_to_int( struct ffblk *ffblk )
{
	int	year,month,date,hour,minut;

	year =	( ffblk->ff_fdate & 0xfe00 ) >>  9;
	month =	( ffblk->ff_fdate & 0x01e0 ) >>  5;
	date =	( ffblk->ff_fdate & 0x001f )      ;
	hour =	( ffblk->ff_ftime & 0xf800 ) >> 11;
	minut =	( ffblk->ff_ftime & 0x03e0 ) >>  5;

	return(	year	* 100000000	+
			month	* 1000000	+
			date	* 10000		+
			hour	* 100		+
			minut
	);
}
#endif	/* TURBO_C */

static	void	UpdateLzhFile_sub(
	const	char	*dir_name ,
	const	char	*sub_dir ,
	const	char	*attr
) {
			int		done , cnt;
	struct	ffblk	ffblk;
	struct	file_name { char name[16]; } *file;
			char	sub[ 16 ] , *p;

	/* FAPX が作ったファイルの数をかぞえる */
	strcpy( file_name , dir_name );		strcat( file_name , attr );
	cnt = 0;		done = findfirst( file_name , &ffblk , 0 );
	while ( ! done ) {
		/* FAPX風のファイル名のみ数える */
		if ( isFAPXfile( ffblk.ff_name ) == TRUE ) cnt++;
		done = findnext( &ffblk );
	};
	if ( cnt == 0 ) {

#ifdef	TEST
	printf("\n<%s>で圧縮するファイル<%s>がありませんでした。",dir_name,attr);
	get_yesno();
#endif

		return;	/* ファイルがないので終了 */
	};

	/* ファイルの名前を入れる領域を確保する */
	file=(struct file_name *)malloc( sizeof(struct file_name) * cnt );
	if ( file == NULL ) {
		UpdateLzhFileSw = NO;
		DeleteOldFileSw = NO;		/* 今日より古いﾌｧｲﾙの削除 OFF */
		ForcedDeleteOldFileSw = NO;	/* 今日より古いﾌｧｲﾙの強制削除 OFF */
		strcpy(str,"メモリーが足りないので圧縮は実行できません。");
		error_return( str );	return;
	};

	/* ファイルの名前（年月だけ）を入れる */
	strcpy( file_name , dir_name );		strcat( file_name , attr );
	cnt = 0;		done = findfirst( file_name , &ffblk , 0 );
	while ( ! done ) {
		/* FAPX風のファイル名のみ数える */
		if ( isFAPXfile( ffblk.ff_name ) == TRUE ) {
			strcpy( str , ffblk.ff_name );
			p = (char *)last_comma( str );
			if ( p != str ) *p = '\0';
			/*
				圧縮なしのモードならば、ファイル名の上４文字だけを取る
				圧縮ありのモードならば、ファイル名の上１文字だけを取る
				それ以外は、全ての名前を取る
			*/
			if ( FapxLogMode == 1 ) {			str[4]='\0';	/* 圧縮なし */
			} else if ( FapxLogMode == 2 ) {	str[1] = '\0';	/* 圧縮あり */
			};
			strcpy( file[ cnt ].name , str );
			cnt++;
		};
		done = findnext( &ffblk );
	};

	/* ファイルの名前をソートする */
	qsort( (char *)file, cnt, sizeof( struct file_name ),
								(int (*)(const void *, const void *))strcmp );

	/* 同じファイル名を除く */
	/* 残ったファイル名に対して LHA.EXE を起動する */
	for ( done = 0 ; done < cnt ; done ++ ) {
		SpawnTree( "u" );
		strcpy( str, dir_name );			/* /log/ */
		if ( FapxLogMode == 2 ) {					/* 圧縮あり */
			strcpy( sub , today );
			sub[ 2 ] = '\0';	/* 年だけ入れる */
			strcat( str, sub );
		};
		strcat( str, file[done].name );		/* /log/9208 */
		SpawnTree( str );			/* lha u /log/ */

		strcpy( str, dir_name );			/* /log/ */
		strcat( str, file[done].name );		/* /log/9208 */
		strcat( str, attr );				/* /log/9208/???.log */
		SpawnTree( str );
		collect_system( "lha.exe" );
		while(strcmp(file[done].name,file[done+1].name)==0) done++;
	};

	/* 確保した領域を解放する */
	free( file );
}

static	void	UpdateLzhFile( const char *dir_name , const char *sub_dir )
{
	char	attr[ 8 ];

	if ( FapxLogMode == 2 ) {
		/************************************/
		/* FAPX のログ保存モードは 圧縮あり */
		/************************************/
		strcpy( attr , "*.eml" );						/* /log/9208*.eml */
		UpdateLzhFile_sub( dir_name , sub_dir , attr );
		strcpy( attr , "*.up" );						/* /log/9208*.up */
		UpdateLzhFile_sub( dir_name , sub_dir , attr );
		strcpy( attr , "*.res" );						/* /log/9208*.res */
		UpdateLzhFile_sub( dir_name , sub_dir , attr );
		strcpy( attr , "*.npb" );						/* /log/9208*.npb */
		UpdateLzhFile_sub( dir_name , sub_dir , attr );
		strcpy( attr , "*.log" );						/* /log/9208*.log */
		UpdateLzhFile_sub( dir_name , sub_dir , attr );
		return;
	};

	/******************************************/
	/* FAPX のログ保存モードは 圧縮なしモード */
	/******************************************/
	if (	strcmp( sub_dir , "NIFMAIL" ) == 0
	||		strcmp( sub_dir , "SENDMAIL" ) == 0
	) {
		strcpy( attr , "*.eml" );						/* /log/9208*.eml */
	} else if ( strcmp( sub_dir , "NAPMAIL" ) == 0 ) {
		strcpy( attr , "*.npb" );						/* /log/9208*.npb */
	} else if ( strcmp( sub_dir , "WEATHER" ) == 0 ) {
		strcpy( attr , "*.npb" );						/* /log/9208*.npb */
	} else {
		strcpy( attr , "*.up" );						/* /log/9208*.up */
		UpdateLzhFile_sub( dir_name , sub_dir , attr );
		strcpy( attr , "*.res" );						/* /log/9208*.res */
		UpdateLzhFile_sub( dir_name , sub_dir , attr );
		strcpy( attr , "*.log" );						/* /log/9208*.log */
	};
	UpdateLzhFile_sub( dir_name , sub_dir , attr );
}

/***************************************************************************/
/* フォーラム名を決める                                                    */
/*   ファイル名が ｢F｣で始まる場合 ･･････ ファイル名をフォーラム名とする    */
/*   ｻﾌﾞ･ﾃﾞｨﾚｸﾄﾘが｢F｣で始まる場合 ･･････ ｻﾌﾞ･ﾃﾞｨﾚｸﾄﾘ名をフォーラム名とする */
/***************************************************************************/
static	void
set_forum_name( char *forumName , const char *sub_dir , const char *f_name )
{
	char	*p;

	strcpy( forumName , f_name );
	if (	*f_name == 'F'
	||		isIDname( f_name ) == YES
	||		strcmp( f_name , "NIFMAIL" ) == 0
	) {
		/* f_name がフォーラム名 or ＩＤ名の場合 */
		/* そのままとする */
		;
	} else {
		if (	*sub_dir == 'F'
		||		isIDname( sub_dir ) == YES
		||		strcmp( sub_dir , "NIFMAIL" ) == 0
		) {
			/* sub_dir がフォーラム名 or ＩＤ名の場合 */
			strcpy( forumName , sub_dir );
		};
	};

	p = forumName + strlen( forumName ) - 1;
	if ( *p == '\\' )	*p = '\0';
}

/************************************/
/* １つのファイルから発言を切り出す */
/************************************/
static	void
collect_loop_sub(
	const	char	*f_name ,
	const	char	*sub_dir ,
			size_t	fsize,
	const	char	*whereabouts
) {
	unsigned	long	ftime;
				char	forumName[ 24 ];
				char	f_name_s[ 128 ];

	/* これまでに file_name[] を設定しておくこと */

	/**********************/
	/* 処理済のファイル？ */
	/**********************/
	strcpy( f_name_s , file_name );
	ftime = _get_file_time( f_name_s );
	if ( is_done_file( whereabouts , ftime ) == TRUE )	return;

	/*************************************************************************/
	/* tmp drive の残り容量と処理するファイルの大きさから divide_main を呼ぶ */
	/*************************************************************************/
	check_drive_space( _get_file_size( f_name_s ) );

	/**************************************************************/
	/* ディレトクリ名、ファイル名からわかる場合のフォーラム名の決定 */
	/**************************************************************/
	set_forum_name( forumName , sub_dir , f_name );

	disp_start_check_file( f_name , fsize );

	strcpy( file_name , f_name_s );
	/* これまでに file_name[] を設定しておくこと */
	/* fsize が 0 のファイルは処理しない */
	if ( fsize != 0 ) {
		check_main( fsize , forumName , whereabouts );	/* check.c */
		if ( hatugen_su != 0 ) fflush( catlog_fpo );
	};

	fsize = ftell( catlog_fpo );

	disp_end_check_file( fsize );

	/********************************/
	/* 処理したファイル名を登録する */
	/********************************/
	append_done_file( whereabouts , ftime );

	/* tmp file の大きさが max_tmp0_size を超えると分割する */
	if ( fsize >= max_tmp0_size * 1024 ) call_divide_main();
}

static	void
collect_loop( const char * , const char * , const int , const char * );

/************************/
/* 普通のファイルの場合 */
/************************/
static	void	collect_loop_file(
	const	char	*f_name ,		/* ファイルの名前 */
	const	size_t	fsize ,			/* ファイルのサイズ */
	const	char	*dir_name ,		/* 検索するﾃﾞｨﾚｸﾄﾘ */
	const	char	*sub_dir ,		/* そのﾃﾞｨﾚｸﾄﾘの名 */
	const	char	*lzh_file		/* ｢*****log整理｣に書く行 */
) {
	char	whereabouts[ 256 ];

	/**************************/
	/* 普通のファイル名の場合 */
	/**************************/
	strcpy( file_name , dir_name );
	strcat( file_name , f_name );
	strcpy( whereabouts , lzh_file );
	strcat( whereabouts , f_name );
	collect_loop_sub( f_name , sub_dir , fsize , whereabouts );
}

/**********************/
/* 書庫ファイルの場合 */
/**********************/
static	void	collect_loop_lzh(
	const	char	*f_name ,		/* 書庫ファイルの名前 */
	const	char	*dir_name ,		/* 検索するﾃﾞｨﾚｸﾄﾘ */
	const	char	*sub_dir ,		/* そのﾃﾞｨﾚｸﾄﾘの名 */
	const	int		lzh_sw ,		/* LZH の解凍であるかのスイッチ */
	const	char	*lzh_file		/* ｢*****log整理｣に書く行 */
) {
			int		ftime;
			char	dir[ 128 ] , lzh[ 256 ] , path[ 256 ];
			char	*p;

	if ( lzh_sw == YES ) {		strcpy( lzh , lzh_file );
	} else {					strcpy( lzh , dir_name );
	};
	strcat( lzh , f_name );	strcat( lzh , "\\" );

	strcpy( path , dir_name );
	strcat( path , f_name );		/* 書庫ファイルの名前 */
	ftime = _get_file_time( path );	/* 書庫ファイルの時刻 */

	if ( is_done_file( lzh , ftime ) == TRUE )	return;	/* 処理済み */

	/********************************/
	/* 解凍の前に LZH ﾃﾞｨﾚｸﾄﾘを作る */
	/********************************/
	if ( lzh_sw == YES ) {	strcpy( dir,dir_name );
	} else {				strcpy( dir,TmpDir );
	};
	strcat( dir , "LZH\\" );		/* 解凍するﾃﾞｨﾚｸﾄﾘ */
	check_and_make_output_path( dir );

	/************************************/
	/* 解凍のコマンドを作成し、実行する */
	/************************************/
	SpawnTree( "x" );
	SpawnTree( path );
	SpawnTree( dir );
	collect_system( "lha.exe" );

	strcpy( str , f_name );		/* 書庫ファイルの名前 */
	p = (char *)last_comma( str );		if ( str != p )	*p = '\0';
	set_forum_name( path , sub_dir , str );

	collect_loop( dir , path , YES , lzh );

	/*************************/
	/* LZH ﾃﾞｨﾚｸﾄﾘを削除する */
	/*************************/
	if ( lzh_sw == YES ) {	strcpy( dir , dir_name );
	} else {				strcpy( dir , TmpDir );
	};
	strcat( dir , "LZH" );		/* 解凍するﾃﾞｨﾚｸﾄﾘ */
	rmdir( dir );
}

static	int		delete_old_file_check_sw;

static	void
delete_old_file_check_sub( const char *file , const char *ff_name )
{
	if ( is_delete_old_file( ff_name ) == YES ) {
		delete_old_file_check_sw = YES;
	};
}

static	void	delete_old_file_check(
	const	char	*dir_name ,		/* 検索するﾃﾞｨﾚｸﾄﾘ */
	const	int		lzh_sw 			/* LZH の解凍であるかのスイッチ */
) {
			int		sw , sw0 , sw1;

	if ( lzh_sw == YES )			return;		/* 圧縮ﾌｧｲﾙではなにもしない */
	if (	DeleteOldFileSw == NO
	&&		ForcedDeleteOldFileSw == NO
	)								return;		/* 削除しなければ必要ない */
	if ( UpdateLzhFileSw == YES )	return;	/* 圧縮指定があれば必要ない */

	delete_old_file_check_sw = NO;
	sw0 = catlog_findfirst_mes_sw;
	sw1 = catlog_findfirst_no_subdir_sw;
	catlog_findfirst_no_subdir_sw = YES;
	catlog_findfirst_mes_sw = NO;
	catlog_findfirst( dir_name, delete_old_file_check_sub, YES, YES );
	catlog_findfirst_mes_sw = sw0;
	catlog_findfirst_no_subdir_sw = sw1;

	if ( delete_old_file_check_sw == NO )	return;

	sw = answer_all_sw;
	answer_all_sw = NO;
	beep();		color( YELLOW );
	puts(	"\n\n　今日より古いファイルの削除が指定されていますが、"
			"ログを凍結しながら実行するスイッチがＯＮになっていませ"
			"ん。\n　この場合、今日より古いファイルはディスク上から"
			"なくなってしまいますが、\nそれでもいいですか？");
	color( WHITE );
	if ( get_yesno_mes() == NO ) {
		puts(	"\nログを凍結しながら実行するスイッチをＯＮにしてよ"
				"ろしいですか？");
		if ( get_yesno_mes() == YES ) {
				UpdateLzhFileSw = YES;
		} else {
			puts(	"今日より古いファイルの削除をＯＦＦにしてよろし"
					"いですか？");
			if ( get_yesno_mes() == YES ) {
				DeleteOldFileSw = NO;
			} else {
				puts("\n\n処理を中断します");
				return;
			};
		};
	};
	answer_all_sw = sw;
}

static	void	collect_loop(
	const	char	*dir_name ,		/* 検索するﾃﾞｨﾚｸﾄﾘ */
	const	char	*sub_dir ,		/* そのﾃﾞｨﾚｸﾄﾘの名 */
	const	int		lzh_sw ,		/* LZH の解凍であるかのスイッチ */
	const	char	*lzh_file		/* ｢*****log整理｣に書く行 */
) {
			int		done;
			size_t	fsize;
	struct	ffblk	ffblk;
			char	forumName[ 24 ] , *p;
			char	lzh[ 128 ];
			char	path[ 256 ];

	if ( QuietSw != YES ) printf("\n<%s>のファイルを処理します。", lzh_file );

	/*****************************************************/
	/********** そのﾃﾞｨﾚｸﾄﾘでのﾌｧｲﾙの処理を行う **********/
	/*****************************************************/
	delete_old_file_check( dir_name , lzh_sw );

	if ( UpdateLzhFileSw == YES && lzh_sw == NO ) {
		 UpdateLzhFile( dir_name , sub_dir );
	};

	strcpy( path , dir_name );	strcat( path , "*.*" );

	done = findfirst( path , &ffblk , FA_DIREC );	/* Directory を指定 */
	while ( ! done ) {
		if ( ffblk.ff_attrib == FA_DIREC ) {
			/************************/
			/* ディレトクリ名の場合 */
			/************************/
			if (	strcmp( ffblk.ff_name , "." ) != 0
			&&		strcmp( ffblk.ff_name , ".." ) != 0
			&&		( lzh_sw == YES || NotSearchSubDirSw != YES )
			) {
				/*************************************************/
				/********** より深いﾃﾞｨﾚｸﾄﾘの検索を行う **********/
				/*************************************************/
				sprintf( path, "%s%s\\",dir_name,ffblk.ff_name );
				sprintf( lzh , "%s%s\\",lzh_file,ffblk.ff_name );
				strcpy( str , ffblk.ff_name );
					p = (char *)last_comma( str );
					if ( str != p )	*p = '\0';
				set_forum_name( forumName , sub_dir , str );
				if ( isWithoutSearchDir( dir_name, ffblk.ff_name)== FALSE) {
					collect_loop(path,forumName,lzh_sw,lzh );
				};
				if ( lzh_sw == YES ) {
					strcpy( path , dir_name );	strcat( path , ffblk.ff_name );
					rmdir( path );
				};
			};
		} else {
			/********************/
			/* ファイル名の場合 */
			/********************/
			if (	strcmp( last_comma( ffblk.ff_name ) , ".LZH" ) == 0
			&&		ExtractLzhFileSw == YES
			) {
				/**********************/
				/* 書庫ファイルの場合 */
				/**********************/
				collect_loop_lzh(
					ffblk.ff_name , dir_name , sub_dir , lzh_sw , lzh_file
				);
			} else if (	isTmpFile( ffblk.ff_name ) != YES
			&&			isSearchFile( ffblk.ff_name ) == TRUE
			) {
				fsize = ( ( size_t )( ffblk.ff_fsize.high ) ) << 16 |
						( ( size_t )ffblk.ff_fsize.low & 0xffff );
				collect_loop_file(
					ffblk.ff_name,		/* ファイルの名前 */
					fsize,				/* ファイルのサイズ */
					dir_name,			/* 検索するﾃﾞｨﾚｸﾄﾘ */
					sub_dir,			/* そのﾃﾞｨﾚｸﾄﾘの名 */
					lzh_file			/* ｢*****log整理｣に書く行 */
				);
				/* 1994.2.12 修正 検索したファイルのみを削除の対象とする */
				delete_old_file( ffblk.ff_name );
			};
			strcpy( file_name , dir_name );
			strcat( file_name , ffblk.ff_name );
			if ( lzh_sw == YES ) {
				remove( file_name );	/* delete file */
			};
		};
		done = findnext( &ffblk );
	};
}

static	void	delete_lzh_dir_sub( const char *file , const char *ff_name )
{
	remove( file );
}

int		collect_main()
{
	int		i;
	char	dir_name[ 128 ] , *p1 , *p2;

	AllHatsugenSu = CollectFileSize = CollectFileNumber = 0;
	strcpy( dir_name , TmpDir );	strcat( dir_name , "LZH\\" );
	catlog_findfirst_mes_sw = NO;
	catlog_findfirst( dir_name, delete_lzh_dir_sub, YES, YES );

	open_append_tmp0_file();	/* file.c */
	if ( _get_file_size( file_name ) > 100 )	call_divide_main();

	catlog_findfirst_mes_sw = YES;
	for ( i=0 ; i<maxInPutPath ; i++ ) {
		strcpy( input_path_name , InDir[ i ] );

		/* ﾄﾞﾗｲﾌﾞ名を除いた部分を抽出する */
		if ( InDir[i][1] == ':' ) {		strcpy(dir_name,InDir[i]+2);
		} else {							strcpy(dir_name,InDir[i]  );
		};
		/* 末尾の \ を消す */
		p1 = last_yen( dir_name );	if ( p1 != dir_name ) *p1 = '\0';
		/* 最後のディレトクリ名を抽出する */
		p1 = last_yen( dir_name );
		if ( p1 != dir_name || *p1 == '\\' ) {
			p1++;	p2 = dir_name;	while( *p1 )	*p2++ = *p1++;
			*p2 = '\0';
		};
		if ( last_yen( dir_name ) != dir_name ) {
			error_bug( "collect_main で入力ディレトクリの処理" );
		};
		if ( strlen( dir_name ) == 0 ) strcpy( dir_name , "UN_KNOWN" );
		collect_loop( InDir[i] , dir_name , NO , InDir[i] );
	};

	mess_check {
		color( WHITE );
		if ( AllHatsugenSu == 0 ) {
			printf("\n発言を見つけられませんでした。");
		} else {
			printf("\n全部で %d 個の発言がありました。", AllHatsugenSu );
		};
	};

	/* 巨大なファイルの大きさ */
	Tmp0FileSize = ftell( catlog_fpo );

	fclose( catlog_fpo );		/* tmp file */

	if ( AllHatsugenSu == 0 ) delete_tmp0_file();		/* 巨大なﾌｧｲﾙの削除 */

	return( AllHatsugenSu );
}

/* DIVIDE_END */