#include"harulib.h"

/*
/-------------------------------------------/
  タイトル    はるライブラリ
　バージョン  1.5
  公開日      2004/03/13
  制作        ハルーポッター
  Homepage    http://park3.wakwak.com/~harupotter/
  Email       harupotter@ar.wakwak.com
/-------------------------------------------/

★バージョンアップ履歴
ver1.5 2004/03/13 機能がだぶる関数を消す。整理。
ver1.4 2004/03/06 関数名の頭にHaruを付ける。
ver1.3 絶対値関数追加
ver1.2 置換関数追加
ver1.1 ファイル分割、結合関数追加
ver1.0 公開
*/


/********************************************************************************/
/*                                                                              */
/*  ある文字列で分割 HaruSplit(aa<>bb<>cc<>dd,"<>",1,buf) ---> buf = "bb"       */
/*                                                                              */
/********************************************************************************/
//指定の文節が取り出せなかったらFALSEを返す
BOOL HaruSplit(char *line,char *c,int turn,char *a){
	int i,j,k;
	BOOL	search_flag;
	BOOL	find_flag = FALSE;	//発見フラグ
	int count = 0;	//区切り文字のカウント

	k = 0;
	for( i = 0; line[i] != '\0'; i++ ){
		//区切り文字を探す
		if( line[i] == c[0] ){
			search_flag = TRUE;
			for( j=0; c[j] != '\0'; j++ ){
				if( line[i+j] != c[j] ){
					search_flag = FALSE;
					break;
				}
			}
			//区切り文字発見
			if( search_flag ){
				//指定の番号より進んだか
				if( turn == count ){
					//終了
					break;
				}

				//違うかった場合は区切り文字数分飛ばす
				i += strlen(c) - 1;
				count++;
				//格納したバッファクリア
				k = 0;
				a[k] = '\0';
				continue;
			}
		}
		//１文字ずつ格納
		a[k] = line[i];
		k++;
		a[k] = '\0';
	}

	//区切り文字の数より指定番号が大きいとFALSEを返す
	if( turn > count ){
		find_flag = FALSE;
		strcpy( a, "" );
	}else{
		find_flag = TRUE;
	}

	return find_flag;
}

/********************************************************************************/
/*                                                                              */
/*  累乗                                                                        */
/*                                                                              */
/********************************************************************************/
int HaruPow(int a,int b){
	int ans=1;
	int i;

	for(i=0;i<b;i++){
		ans*=a;
	}
	return ans;
}

/********************************************************************************/
/*                                                                              */
/*  文字列16進数を整数型に変換(FF->255,00a->10)                                 */
/*                                                                              */
/********************************************************************************/
int HaruAtoHex(const char *str){
	int i;
	int ans=0;
	int keta;

	keta=0;
	for(i=strlen(str);i>=0;i--){
		if(isxdigit(str[i])){
			if(str[i] >= '0' && str[i] <= '9'){
				ans+=(str[i]-'0')*HaruPow(16,keta);
			}else{
				ans+=(10+tolower(str[i])-'a')*HaruPow(16,keta);
			}
			keta++;
		}
	}
	return ans;
}

/********************************************************************************/
/*                                                                              */
/*  0からd未満の整数乱数を返す                                                  */
/*                                                                              */
/********************************************************************************/
int HaruRand(int d){
/* (int)((double)rand() / ((double)RAND_MAX + 1) * d)  */
	return rand()%d;
}

/********************************************************************************/
/*                                                                              */
/*  strncpy関数に'\0'を付けるver                                                */
/*                                                                              */
/********************************************************************************/
char *HaruStrncpy(char *str,const char *cstr,size_t size){
	strncpy(str,cstr,size);
	str[size]='\0';
	return str;
}

/********************************************************************************/
/*                                                                              */
/*  エラーをファイルに出力して終了                                              */
/*      (文字列、モード(0=普通,1=ファイルオープン,2=メモリ確保))                */
/*                                                                              */
/********************************************************************************/
void HaruError(const char *str,const int mode){
	FILE *fout;
	if((fout=fopen("HaruError.txt","w"))==NULL)exit(1);
	if(mode==1){fprintf(fout,"%sが開けません。\n",str);}
	else if(mode==2){fprintf(fout,"%sメモリが確保出来ません。\n",str);}
	else{fputs(str,fout);}
	fclose(fout);
	exit(1);
}

/********************************************************************************/
/*                                                                              */
/*  ファイルが存在しているかチェック(存在->TRUE,NOT存在->FALSE)                 */
/*                                                                              */
/********************************************************************************/
BOOL HaruCheckExistFile(char *filename){
	FILE *fin;
	char str[64];
	if((fin = fopen(filename,"r"))==NULL){
		sprintf(str,"ファイル：%sが存在しません。",filename);
		HaruDump(str,"a");
		return FALSE;
	}
	fclose(fin);
	return TRUE;
}

/********************************************************************************/
/*                                                                              */
/*  画像の横幅取得                                                              */
/*                                                                              */
/********************************************************************************/
int HaruBmpGetWidth(const char *file){
	FILE *fin;
	int width;
	if((fin=fopen(file,"rb"))==NULL)HaruError(file,1);
	fseek(fin,18,0);
	width=fgetc(fin);
	width+=256*fgetc(fin);
	fclose(fin);
	return width;
}

/********************************************************************************/
/*                                                                              */
/*  画像の高さ取得                                                              */
/*                                                                              */
/********************************************************************************/
int HaruBmpGetHeight(const char *file){
	FILE *fin;
	int info,height;
	if((fin=fopen(file,"rb"))==NULL)HaruError(file,1);
	fseek(fin,14,0);
	info=fgetc(fin);
	if(info == 0x28)fseek(fin,22,0);
	else fseek(fin,20,0);
	height=fgetc(fin);
	height+=256*fgetc(fin);
	fclose(fin);
	return height;
}

/********************************************************************************/
/*                                                                              */
/*  二文字の16進数を整数型に変換(0a->10,0A->10)                                 */
/*                                                                              */
/********************************************************************************/
int HaruChangeHex(const char *str){
	int in[2];
	if(str[0]>='a' && str[0]<='f')in[1]=((str[0]-'a')+10)*16;
	else if(str[0]>='A' && str[0]<='F')in[1]=((str[0]-'A')+10)*16;
	else in[1]=(str[0]-'0')*16;

	if(str[1]>='a' && str[1]<='f')in[0]=(str[1]-'a')+10;
	else if(str[1]>='A' && str[1]<='F')in[0]=(str[1]-'A')+10;
	else in[0]=str[1]-'0';
	return in[0]+in[1];
}

/********************************************************************************/
/*                                                                              */
/*  最後の文字を削除                                                           */
/*                                                                              */
/********************************************************************************/
void HaruChop(char *str){
	if(strlen(str)>=1)str[strlen(str)-1]='\0';
}

/********************************************************************************/
/*                                                                              */
/*  改行削除                                                                    */
/*                                                                              */
/********************************************************************************/
void HaruChomp(char *str){
	if(str[strlen(str)-1] == '\n')str[strlen(str)-1]='\0';
}

/********************************************************************************/
/*                                                                              */
/*  大文字小文字を区別しない文字列探索(対象文字列、探索文字列)                  */
/*                                                                              */
/********************************************************************************/
char *HaruStrstr(const char *str,const char *sword){
	int i,j;
	BOOL flag;

	for(i=0;str[i]!='\0';i++){
		/*str[i]とsword[0]を小文字に変換*/
		if(tolower(str[i])==tolower(sword[0])){/*最初の文字が見つかった*/
			flag=TRUE;
			for(j=0;sword[j]!='\0';j++){
				if(tolower(str[i+j])!=tolower(sword[j])){
					flag=FALSE;
				}
			}
			if(flag){return (char *)&str[i];}
		}
	}
	return NULL;
}

/********************************************************************************/
/*                                                                              */
/*  親ディレクトリの名前を得る(c:\aa\bb.lzh -> c:\aa\)                          */
/*                                                                              */
/********************************************************************************/
char *HaruGetParentDirName(char *buf,const char *cmdline){
	int i;
	for(i=(int)strlen(cmdline);i>=0;i--){
		if(cmdline[i] == '\\' || cmdline[i] == '/'){
			HaruStrncpy(buf,cmdline,i+1);
			break;
		}
	}
	return buf;
}

/********************************************************************************/
/*                                                                              */
/*  絶対パスからファイルの名前を得る(c:\aa\bb.lzh -> bb.lzh)                    */
/*                                                                              */
/********************************************************************************/
char *HaruPathToFile(const char *path){
	int i;
	for(i=(int)strlen(path);i>=0;i--){
		if(path[i] == '\\' || path[i] == '/'){return (char *)&path[i+1];}
	}
	return (char *)path;
}

/********************************************************************************/
/*                                                                              */
/*  テキスト連結("aaa","bbb" -> "aaabbb")                                       */
/*                                                                              */
/********************************************************************************/
char *HaruAddText(const char *str1,const char *str2){
	static char *temp;
	if(temp!=NULL)free(temp);
	temp=(char *)malloc(strlen(str1)+strlen(str2)+1);
	printf("temp=%p\n",&temp[0]);
	if(temp==NULL)HaruError("AddText()",2);
	strcpy(temp,str1);
	strcat(temp,str2);
	return temp;
}

/********************************************************************************/
/*                                                                              */
/*  拡張子を得る(c:\aa\bb.lzh -> .lzh)                                          */
/*                                                                              */
/********************************************************************************/
char *HaruGetExpName(const char *file){
	int i;
	for(i=(int)strlen(file);i>=0;i--){
		if(file[i] == '.'){return (char *)&file[i];}
	}
	return NULL;
}

/********************************************************************************/
/*                                                                              */
/*  拡張子を取り除く(c:\aa\bb.lzh -> c:\aa\bb)                                  */
/*                                                                              */
/********************************************************************************/
char *HaruRemoveExp(char *buf,const char *file){
	int i;
	strcpy(buf,file);
	for(i=(int)strlen(file);i>=0;i--){
		if(file[i] == '.'){
			HaruStrncpy(buf,file,i);
			break;
		}
	}
	return buf;
}

/********************************************************************************/
/*                                                                              */
/*  文字列をダンプ(文字列、書き込みモード(w=新規,a=追加))                       */
/*                                                                              */
/********************************************************************************/
void HaruDump(const char *str,const char *mode){
	FILE *fout;
	if(strcmp(mode,"a")==0){fout=fopen("dump.txt","a");}
	else{
		if((fout=fopen("dump.txt","w"))==NULL)HaruError("dump.txt",1);
	}
	fprintf(fout,"%s\n",str);
	fclose(fout);
}

/********************************************************************************/
/*                                                                              */
/*  ファイル分割(ファイル名、分割サイズ、純粋分割か(yes=1,no=0))                */
/*                                                                              */
/********************************************************************************/
void HaruSplitFile(char *file,unsigned long size,int pure){
	unsigned int count=0,num;
	FILE *fin,*fout;
	unsigned char *buf;
	char makefile[FILENAME_MAX];
	char bufs[FILENAME_MAX];

	if((fin=fopen(file,"rb"))==NULL)HaruError(file,1);

	buf=(unsigned char *)malloc(size);
	if(buf==NULL)HaruError("buf",2);

	/*ヘッダ付加*/
	if(pure==0){
		sprintf(makefile,"%s.%.3d",HaruRemoveExp(bufs,file),count);
		if((fout=fopen(makefile,"wb"))==NULL)HaruError(makefile,1);
		fwrite(HaruGetExpName(file),1,strlen(HaruGetExpName(file))+1,fout);
		num=fread(buf,1,size-strlen(HaruGetExpName(file))-1,fin);
		fwrite(buf,1,num,fout);
		fclose(fout);
		count++;
	}

	while(TRUE){
		num=fread(buf,1,size,fin);
		if(num==0)break;

		sprintf(makefile,"%s.%.3d",HaruRemoveExp(bufs,file),count);
		if((fout=fopen(makefile,"wb"))==NULL)HaruError(makefile,1);
		fwrite(buf,1,num,fout);
		fclose(fout);

		if(num!=size)break;
		count++;
	}
	free(buf);
	fclose(fin);
}

/********************************************************************************/
/*                                                                              */
/*  ファイル結合(ファイル名、純粋分割か(yes=1,no=0))                            */
/*                                                                              */
/********************************************************************************/
void HaruJoinFile(char *file,int pure){
	unsigned int count=0,num,point,size;
	FILE *fin,*fout;
	unsigned char *buf;
	char loadfile[FILENAME_MAX];
	char bufs[FILENAME_MAX];

	/*ヘッダが付加したファイルの読み込み*/
	sprintf(loadfile,"%s.%.3d",HaruRemoveExp(bufs,file),count);
	if((fin=fopen(loadfile,"rb"))==NULL)HaruError(loadfile,1);

	/*バッファ確保*/
	fseek(fin,0,SEEK_END);
	size=ftell(fin);
	buf=(unsigned char *)malloc(size);
	if(buf==NULL)HaruError("buf",2);
	fseek(fin,0,SEEK_SET);

	/*ヘッダ付加の場合*/
	if(pure==0){
		while(fgetc(fin)!='\0');/*ファイルポインタをヌルまで進める*/
		point=ftell(fin);

		/*拡張子の読み込み*/
		fseek(fin,0,SEEK_SET);
		fread(buf,1,point,fin);

		fout=fopen(HaruAddText(HaruRemoveExp(bufs,file),(const char*)buf),"wb");/*作成ファイル*/

		/*拡張子以降から書き込み*/
		fread(buf,1,size-point,fin);
		fwrite(buf,1,size-point,fout);

		count++;
	}else{
		fout=fopen(HaruRemoveExp(bufs,file),"wb");/*作成ファイル*/
	}
	fclose(fin);

	while(TRUE){
		/*ファイルの読み込み*/
		sprintf(loadfile,"%s.%.3d",HaruRemoveExp(bufs,file),count);
		if((fin=fopen(loadfile,"rb"))==NULL)break;

		num=fread(buf,1,size,fin);
		fwrite(buf,1,num,fout);
		fclose(fin);
		count++;
	}
	fclose(fout);
}

/********************************************************************************/
/*                                                                              */
/*  置換                                                                        */
/*                                                                              */
/********************************************************************************/
void HaruReplace(char *search_word,char *new_word,char *target,char *new_buffer)
{
	int i,j,k;
	BOOL flag;

	k=0;
	for(i=0; target[i] != '\0';i++){
		/*最初の文字が見つかった*/
		if(target[i] == search_word[0]){
			flag = TRUE;
			for(j=0; search_word[j] != '\0'; j++){
				/*限界 or 途中で違った場合*/
				if(target[i + j] == '\0' || search_word[j] != target[i+j]){
					new_buffer[k] = target[i];
					k++;
					flag = FALSE;
					break;
				}
			}

			/*見つかった場合*/
			if(flag){
				/*挿入する*/
				for(j=0; new_word[j] != '\0'; j++){
					new_buffer[k] = new_word[j];
					k++;
				}
				/*iを検索文字数分飛ばす*/
				i += strlen(search_word) - 1;
			}
		}
		/*違う文字のとき*/
		else{
			new_buffer[k] = target[i];
			k++;
		}
	}
	new_buffer[k] = '\0';
}