/* OpenWebSpider
 *
 *  Authors:     Stefano Alimonti AND Stefano Fantin
 *  Version:     0.8
 *  E-Mails:     shen139 [at] openwebspider (dot) org AND stefanofantinguz@yahoo.it
 *
 *
 * This file is part of OpenWebSpider
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

#ifndef __STRFNCT
#define __STRFNCT

#define TOKENS             " ,.;:|+*-_\"'\t\r\n\\/<>()[]{}|!&=@#"


/* atoupper
 * in -> out <- maxout ->
 * in = "HellO" => out = "HELLO"
 */
int atoupper(char* in, char* out, int maxout)
{
	if(!in || !out || maxout<=0)
		return 0;

	memset(out,0,maxout);
	strncpy(out,in,maxout-1);
	out[maxout-1]=0;
	_strupr(out);
return 1;
}


/* UnToken
 *str -> Tokens -> out <- len ->
 * str = "test1\n2\r3;!4"	Tokens = "\n\r;" ==> out = "test123!4"
 */
int UnToken(char* str,char* Tokens,char* out,int len)
{
int c,i,x=0,tokenfound,y;

y=MIN(len,(signed)strlen(str));

	for(c=0;c<y;c++)
	{
		tokenfound=0;
		for(i=0;i<(signed)strlen(Tokens);i++)
			if(str[c]==Tokens[i])
				tokenfound=1;
		if(tokenfound==0)
			out[x++]=str[c];
	}
	out[x]=0;
return 1;
}

/* bTokenIn
 * str -> Tokens -> len -> 1|0 <-
 * str = "test1\n2\r3;!4"	Tokens = "\n\r;" ==> 1
 */
int bTokenIn(char* str,char* Tokens,int len)
{
int c,i,y;

y=MIN(len,(signed)strlen(str));

	for(c=0;c<y;c++)
		for(i=0;i<(signed)strlen(Tokens);i++)
			if(str[c]==Tokens[i])
				return 1;

return 0;
}

/* OnlyOneSpace
 * str -> out <- len ->
 * str = "test1 2  4    4" out = "test1 2 4 4"
 */
int OnlyOneSpace(char* str,char* out,int len)
{
int c,x=0;

	if(len<=0)
		return 0;

	for(c=0;c<(signed)strlen(str);c++)
	{
		if(x && out[x-1]==' ' && str[c]==' ')	//if x>0 and last char is space and current char is space -> don't add this char
			continue;
		else
		{
			if(x>=len-1)
				break;
			out[x++]=str[c];
		}

	}
	out[x]=0;

return 1;
}


/* ReplaceChr
 * replaces all occourences of a char(bus) with sub
 * string = "test" bus='s' sub='x' => "text"
 */
int ReplaceChr(char* string, char bus, char sub)
{
int i;
	for(i=0;i<(signed)strlen(string);i++)
	{
		if(string[i]==bus)
			string[i]=sub;
	}

return 1;
}

/* ReplaceStr
 * replaces all occurrences of a string(bus) with sub
 */
int ReplaceStr(char* string,char* strOut, char* bus, char* sub)
{
int x=0,y=0;
	strOut[0]=0;
	for(x=0;x<(signed)strlen(string);x++)
	{
		if(strnicmp(string+x,bus,strlen(bus))==0)
		{
			strcat(strOut,sub);
			x+=strlen(bus)-1;
			y+=strlen(sub);
			continue;
		}

		strOut[y++]=string[x];
		strOut[y]=0;
			
	}

return 1;
}

/* RemoveShit
 * converts all unwanted chars in a string to ' '
 */
void RemoveShit(char* text)
{
int i;
unsigned char curC;

	for(i=0;i<(signed)strlen(text);i++)
	{
		curC=text[i];

		/*                  UnHtml()                      */
		if( /*!( (curC>=32 && curC<=125) || (curC>=192 && curC<=255) ) ||*/ curC=='\'' || curC=='\"' || curC=='\\')
			text[i]=' ';
	}
}


/* strtrim
 * removes starting and ending spaces
 */
char* strtrim(char* in,char* out)
{
int y,i;
char* tmp;
	
	y=strlen(in);

	tmp = malloc(y+1);

	if(tmp==NULL)
		MemoryCorruptedHandler("strtrim");

	tmp[0]=0;

	for(i=0;i<y;i++)
	{
		if(in[i]!=' ')
		{
			strcpy(tmp,in+i);
			break;
		}
	}

	y=strlen(tmp);

	for(i=y-1;i>=0;i--)
	{
		if(tmp[i]!=' ')
		{
			tmp[i+1]=0;
			break;
		}
	}

	strcpy(out,tmp);
	FREE(tmp);

return out;
}


/* strWord
 * where -> word -> pos <-
 * strWord("web spider","spider") -> (char*) "spider"
 * strWord("webspider","spider") -> (char*) NULL
 */
char* strWord(char* where,char* word)
{
char* pFound;
char beg;
char end;
int x,y;
int nTokens;

	while(   ( pFound = strstr(where,word) )   )
	{
		
		if(pFound==NULL)
			return NULL;

		if(pFound==where)
			beg=' ';
		else
			beg=(char)pFound[-1];

		end=pFound[strlen(word)];

		if(end==0)
			end=' ';

		nTokens=strlen(TOKENS);

		for(x=0;x<nTokens;x++)/**//**/
		/**/if(beg==TOKENS[x])/**//**/
		/**//**/for(y=0;y<nTokens;y++)
		/**//**//**/if(end==TOKENS[y])
		/**//**//**//**/return pFound;

		where=pFound+1;
	}

return NULL;
}

char * my_stristr(char* s,char* find)
{
char c, sc;
unsigned int len;

    if ((c = *find++) != 0)
    {
        len = strlen(find);
        do
        {
            do
            {
                if ((sc = *s++) == 0)
                    return (char *)0;
            } while (sc != c);
        } while (strnicmp(s, find, len) != 0);
        s--;
    }
return s;
}

/***********************************************************************************************/
/***********************************************************************************************/
/*myCStr*/
/***********************************************************************************************/
#define SSS   200

int myCStrLen(struct __myCStr* myCStr)
{
return myCStr->myStrLen;
}

int myCStrLenUpdate(struct __myCStr* myCStr)
{
	myCStr->myStrLen=strlen(myCStr->myString);
return myCStr->myStrLen;
}

char* myCStrCpy(struct __myCStr* myCStr, char* text)
{
	FREE(myCStr->myString);
	myCStr->myString=(char*)malloc(strlen(text)+SSS);
	if(myCStr->myString==NULL)
		MemoryCorruptedHandler("myCStrCpy");
	strcpy(myCStr->myString,text);
	myCStr->myStrLen=strlen(myCStr->myString);
	return myCStr->myString;
}

char* myCStrnCpy(struct __myCStr* myCStr, char* text, int n)
{
	FREE(myCStr->myString);
	myCStr->myString=(char*)malloc(n+SSS);
	if(myCStr->myString==NULL)
		MemoryCorruptedHandler("myCStrnCpy");
	memset(myCStr->myString,0,n+SSS);
	strncpy(myCStr->myString,text,n);
	myCStr->myStrLen=strlen(myCStr->myString);
	return myCStr->myString;
}

char* myCStrCat(struct __myCStr* myCStr, char* text)
{
	myCStr->myString=(char*)realloc(myCStr->myString,myCStr->myStrLen+strlen(text)+SSS);
	if(myCStr->myString==NULL)
		MemoryCorruptedHandler("myCStrCat");
	strcat(myCStr->myString,text);
	myCStr->myStrLen=strlen(myCStr->myString);
	return myCStr->myString;
}

char* myCStrnCat(struct __myCStr* myCStr, char* text, int n)
{
	myCStr->myString=(char*)realloc(myCStr->myString,myCStr->myStrLen+n+SSS);
	if(myCStr->myString==NULL)
		MemoryCorruptedHandler("myCStrnCat");
	strncat(myCStr->myString,text,n);
	myCStr->myString[myCStr->myStrLen+n]=0;
	myCStr->myStrLen=strlen(myCStr->myString);
	return myCStr->myString;
}

char* myCStrMemCpy(struct __myCStr* myCStr, char* blob, int blobLen)
{
	FREE(myCStr->myString);
	myCStr->myString=(char*)malloc(blobLen+SSS);
	if(myCStr->myString==NULL)
		MemoryCorruptedHandler("myCStrMemCpy");
	memcpy(myCStr->myString,blob,blobLen);
	myCStr->myStrLen=blobLen;
	return myCStr->myString;
}

char* myCStrMemCat(struct __myCStr* myCStr, char* blob, int blobLen)
{
// |myString| + |blob|
// myStrLen = myStrLen + blobLen
	myCStr->myString=(char*)realloc(myCStr->myString,myCStr->myStrLen+blobLen+SSS);
	if(myCStr->myString==NULL)
		MemoryCorruptedHandler("myCStrMemCat");
	memcpy(myCStr->myString+myCStr->myStrLen,blob,blobLen);
	myCStr->myStrLen+=blobLen;
	return myCStr->myString;
}

/**************
{
int i;
MYCSTR test;
test.myString=NULL;

	myCStrCpy(&test, "prova");
	
	for(i=0;i<1000;i++)
		myCStrCat(&test, "XX123XX123XX123XX123XX123XX123XX123XX123|||||||XX123XX123XX123XX123XX123XX123XX123CCCCCCCCCCCCCZZZZZZZZZZZZ>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<");
		
	//printf("%s\n\n",test.myString);
	myCStrMemCpy(&test, "asder",5);
	
	for(i=0;i<1000;i++)
		myCStrMemCat(&test, "123456",6);
		
	myCStrMemCat(&test, "\0",1);
	//printf("%s\n\n",test.myString);
	FREE(test.myString);

return 1;
}
**************/

#endif

/*EOF*/