bitstr.c

一个很好的html网页分析工具

//--------------------------------------------
//                 BIT HTML LIB
//
//file:  BitStr.c
//usage: for string
//---------------------------------------------

#include "BitHtml.h"

void BitString_CopyChars(char* aDest,int anDestOffset,char* aSource,int anOffset,int aCount)
{ 

  char*       to   = aDest+anDestOffset;
  const char* first= aSource+anOffset;
  const char* last = first+aCount;

    while(first<last) {
    *to=*first;  
    to++;
    first++;
  }
}

//Bit_String_Mid( &pContext->strBuffer,pStr,pContext->curPosition,i-pContext->curPosition)
int BitString_Mid(char * source,char * dest,int begin,int count)
{
	BitString_CopyChars(dest,0,source,begin,count);
	dest[count]=0;
	return count+1;
}

char *BitString_NewChars(char* aSource)
{
	char *str;
	//str=(char *)malloc(sizeof(char));
	str=(char *)malloc(strlen(aSource));
	BitString_CopyChars(str,0,aSource,0,strlen(aSource));
	
	str[strlen(aSource)]=0;
	return str;
}

char BitString_GetCharAt(char* aDest,int anIndex)
{
  /*
  if(anIndex<(int)strlen(aDest))
  {
		return  aDest[anIndex] ;
  }
  return 0;
  */

  return  aDest[anIndex] ;
}

int BitString_SetCharAt(char * pThis,char aChar,int anIndex)
{
  /*
  int result=FALSE;
  int length=strlen(pThis);
  if(anIndex<length)
  {
    pThis[anIndex]=(char)aChar;
    result=TRUE;
  }
  return result;
  */
  pThis[anIndex]=(char)aChar;
  return TRUE;
}

int BitString_FindChar(char* aDest,int aLength,int anOffset,const char aChar,int aIgnoreCase)
{
  char theCmpChar=(aIgnoreCase ? toupper(aChar) : aChar);
  int  theIndex=0;
  int  theLength=aLength;

  for(theIndex=anOffset;theIndex<theLength;theIndex++)
  {
    char theChar=BitString_GetCharAt(aDest,theIndex);
    if(aIgnoreCase)
      theChar=toupper(theChar);

    if(theChar==theCmpChar)
      return theIndex;
  }
  return -1;
}

int BitString_FindCharInSet(char* aDest,char* aSet,int aIgnoreCase,int anOffset)
{
  int index=anOffset-1;
  int  thePos;
  int mLength=strlen(aSet);
  int length=strlen(aDest);

  while(++index<length)
  {
    char theChar=BitString_GetCharAt(aDest,index);
    thePos=BitString_FindChar(aSet,mLength,0,theChar,aIgnoreCase);
    if(thePos!=-1)
      return index;
  }

  return -1;
}

int BitString_ToInteger(char * pThis,int* anErrorCode,int aRadix)
{

  int result=0;

  char *cp = pThis + strlen(pThis);
  int theMult=1;
  char theChar=0;
  char theDigit=0;

  while(--cp>=pThis)
  {
    char theChar=*cp;

/**/
	if ((theChar >= 'a') && (theChar <= 'z')) 
        theChar = 'A' + (theChar - 'a');
/**/
    if((theChar>='0') && (theChar<='9'))
      theDigit=theChar-'0';

    else if((theChar>='A') && (theChar<='F'))
	{
      if(10==aRadix)
	  {
        result=0;
        break;
      }
      theDigit=(theChar-'A')+10;
    }
    else if('-'==theChar)
	{
      result=-result;
      break;
    }
    else if(('+'==theChar) || (' '==theChar)) 
      break;

    else 
	{
      result=0;
      break;
    }

    result+=theDigit*theMult;
    theMult*=aRadix;
  }

  return result;
}

void ShiftCharsLeft(char* aDest,int aLength,int anOffset,int aCount)
{ 
  int theMax=aLength-anOffset;
  int theLength=(theMax<aCount) ? theMax : aCount;

  char* first= aDest+anOffset+aCount;
  char* last = aDest+aLength;
  char* to   = aDest+anOffset;

  while(first<=last)
  {
    *to=*first;  
    to++;
    first++;
  }
}

void BitString_Cut(char * aDest,int aDestOffset,int aCount)
{
  int mLength=strlen(aDest);

  if(aDestOffset<mLength)
  {

    int theDelta=mLength-aDestOffset;
    int theLength=(theDelta<aCount) ? theDelta : aCount;

    if(aDestOffset+theLength<mLength)
	{
      ShiftCharsLeft(aDest,mLength,aDestOffset,theLength);
      mLength-=theLength;
	  aDest[mLength]=0;
    }
    else if(aDestOffset<mLength)
       aDest[aDestOffset]=0;
  }
}

int Bit_CharISDigit(char item,int bTen)
{
	if( item>='0' && item <='9')
		return TRUE;
	if( !bTen && ( ( item>='a' && item<='f')|| (item>='A' && item<='F')))
		return TRUE;
	return FALSE;
}

int MinInt(int anInt1,int anInt2)
{
  return (anInt1<anInt2) ? anInt1 : anInt2;
}

void BitString_AppendStr(char * aDest,char * aSource,int anOffset,int aCount)
{
  int mLength=strlen(aSource);
  int aDestmLength=strlen(aDest);

  if(anOffset<mLength)
  {
    int theRealLen=(aCount<0) ? mLength : MinInt(aCount,mLength);
    int theLength=(anOffset+theRealLen<mLength) ? theRealLen : (mLength-anOffset);
    if(0<theLength)
	{
      //BitString_GrowCapacity(aDest,aDestmLength+theLength);
      BitString_CopyChars(aDest,aDestmLength,aSource,anOffset,theLength);
      aDestmLength+=theLength;
    }
  }
  aDest[aDestmLength]=0;
}

char * BitString_AppendChar(char * pThis,char aChar) 
{
  char buf[2]={0,0};
  char * temp;
  buf[0]=aChar;

  temp=BitString_NewChars(buf);
  BitString_AppendStr(pThis,temp,0,1);
  return pThis;
}