tool_str.c

sco unix下c语言开发工具库

/*
 *  tool_str.c
 *  字符串处理工具函数集
 *
 *  Copyright (c) 2001  adtec
 *  1 chedaogou haidian
 *  Beijing, CHN 100102
 *
 *  ALL RIGHTS RESERVED.
 *
 *  sunrise    Version 1.0
 *  create     May, 20 2000     Sjg
 *  modify     Apr, 12 2002     MDJ
 *
 *  Unauthorized distribution, adaptation or use may be
 *  subject to civil and criminal penalties.
 *
 */

#include <stdio.h>
#include <stdlib.h>
#include <curses.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <time.h>
#include <sys/stat.h>

#define _TOOL_STR_C
#include "fireball.h"

/*
 * 将字符串左对齐到长度为width的串中
 */
char * LeftAdjust( char * s, int width, char fill )  
{
    int     len;
    char  * p;

    len = strlen( s ); 
    p = ( char * ) malloc( (width+1) * sizeof(char) );

    if ( fill == 0x0 )
        fill = ' ';
    memset( p, fill, width * sizeof(char) );
    p[width] = 0;

    memcpy( p, s, Min( width, len ) );

    return (p);
}
    

/*
 * 将字符串右对齐到长度为width的串中
 */

char * RightAdjust( char * s, int width, char fill ) 
{
    int     len;
    char    * p;

    len = strlen(s);
    p = ( char * ) malloc( width + 1 );
    if ( fill == 0x0 )
        fill = ' ';
    memset( p, fill, width );
    p[width] = '\0';

    if (len >= width)
        memcpy( p, s+len-width, width );
    else
        memcpy( p + (width-len), s, len );

    return (p);
}

/*
 * 将字符串居中放到长度为wid的串中
 */
char * MiddleAdjust( char * t, int width, char fill ) 
{
    int    len;
    char * p;

    len = strlen( t ); 
    p = ( char * ) malloc( width + 1 );
    if ( fill == 0x0 )
        fill = ' ';
    memset( p, fill, width );
    p[width] = '\0';

    if ( len >= width )
        memcpy( p, t, width );
    else
        memcpy( p + (width-len)/2, t, len );

    return (p);
}

char * StringAdjust( int type, char * s, int width, char fill )
{
    if ( s == NULL )
        return ( NULL );

    if ( type == 0 )
        return ( LeftAdjust( s, width, fill ) );
    else if ( type == 1 )
        return ( RightAdjust( s, width, fill ) );
    else if ( type == 2 )
        return ( MiddleAdjust( s, width, fill ) );
    else
        return ( NULL );
}

/* 
 * 用o替换s中第一次出现的t;
 * 返回值: 找到t并替换成功返回非0值, 没找到t返回0.
 */
int ReplaceStr( char * s, char * t, char * o ) 
{
    char    * ptr, * buffer;
    int       t_len, len;
    
    if ( !( ptr = strstr(s, t) ))
        return ( 0 );

    t_len = strlen( t );
    len = strlen( ptr + t_len );
    buffer = malloc( ( len + 1 ) * sizeof( char ) );
    strcpy( buffer, ptr + t_len );
    *ptr = 0;
    strcat( s, o);
    strcat( s, buffer );
    free( buffer );

    return ( 1 );
}



/*
 * 在字符串中某一位置插入一个字符
 */
char * StrAddCh( char * str, int pos, int ch, int len )
{
    int i;

    if ( pos < 0 || pos > len - 1 )
        return ( NULL );

    for ( i = len - 1; i > pos; i-- )
        str[i] = str[i-1];
    str[i] = ch;

    return ( str );
}

/*
 * 在字符串中某一位置插入一个字符串
 */
char * StrAddStr( char * str, int pos, int  * str2, int size, int len2 )
{
    int i, len, len1;

    if ( str == NULL || str2 == NULL )
         return ( str );

    len1 = strlen( str );

    if ( pos < 0 || pos + len2 >= size || len2 <= 0 || pos > len1 )
        return ( NULL );

    len = len1 + len2;
    if ( len >= size )
        len = size - 1;

    for ( i = len1; i >= pos; i-- )
        str[i+len2] = str[i];
    for ( i = 0; i < len2; i++ )
        str[pos+i] = str2[i];

    return ( str );
}

/*
 * 删除字符串中某一位置的一个字符, 字符串尾部补一个给定字符
 */
char * StrDelCh( char * str, int pos, int n, int ch )  
{
    int         i, n2, len;

    len = strlen( str );

    if ( pos < 0 || pos >= len )
        return ( str );
    if ( pos + n > len )
        n = len - pos;

    for ( i = 0; i < len - n; i++ )
        str[pos+i] = str[pos+n+i];
    for ( i = len - n; i < len; i++ )
        str[i] = ch;

    return ( str );
}

/*
 * 相当于 strcpy ( d, s );
 * 只是当s为空串时d为长度为1的空格串
 */
int spstrcpy( char * d, char * s )  
{
    if ( *s )
        strcpy( d, s );
    else
        strcpy( d, " " );
}

/*
 * 判断字符串是否为空格串,
 * 是返回1, 否返回0
 */
int StrIsBlank( char * str )  
{
    char *p = str;

    if (p)
        while (*p)
            if (!isspace(*p++))
                return(0);

     return(1);
}




/*
 * 去除str中的字符 '.'
 */
char * TrimDot( char * str )  
{
    char     TmpStr[255];
    int      i=0,Len=0;

    memset (TmpStr,0x00,sizeof(TmpStr));
    Len=strlen(str);
    if ( str == NULL )
         return ( NULL );
    while ( *str )
       {
        if ( *str=='\0' || i>Len) break;
        if ( ( *str == ' '  ) || ( *str == '\t' ) || 
             ( *str == '\r' ) || ( *str == '.' ) )
            *str++;
        else {
          TmpStr[i]=*str;i++;*str++;
        }
       }
    TmpStr[i+1]='\0';
    str=TmpStr;
    return ( str );
}



/*
 * 去除str中的空字符
 */
char * Trimall( char * str )  
{
    char     TmpStr[1024];
    int      i=0,Len=0;

    memset (TmpStr,0x00,sizeof(TmpStr));
    Len=strlen(str);
    if ( str == NULL )
         return ( NULL );
    while ( *str )
       {
        if ( *str=='\0' || i>Len) break;
        if ( ( *str == ' '  ) || ( *str == '\t' ) || 
             ( *str == '\r' ) || ( *str == '\n' ) )
            *str++;
        else {
          TmpStr[i++]=*str++;
        }
       }
    TmpStr[i+1]='\0';
    str=TmpStr;
    return ( str );
}


/*
 * 去除str开头处的空字符
 */
char * LTrim( char * str )  
{
    unsigned char * s = ( unsigned char * ) str;

    if ( str == NULL )
         return ( NULL );

    while ( *s )
        if ( ( *s == ' ' ) || ( *s == '\t' ) ||
             ( *s == '\r' ) || ( *s == '\n' ) )
            s++;
        else
            break;

    if ( ( char * ) s > str ) 
        strcpy( str, ( char * ) s ); 

    return ( str );
}


/*
 *  去除str结尾处的空字符
 */
char * RTrim ( char * str ) 
{
    unsigned char * s = ( unsigned char * ) str;

    if ( str == NULL )
         return ( NULL );

    while ( *s )
        s++;

    s--;

    while ( ( char * ) s >= str )
        if ( ( *s == ' ' ) || ( *s == '\t' ) ||
             ( *s == '\r' ) || ( *s == '\n' ) )
            s--;
        else
            break;

    *(s+1) = 0;

    return ( str );
}

/*
 * 将字符串转为大写
 */
int UpperStr( char * str )
{
    int i, len;

    if ( str == NULL )
         return ( 0 );

    len = strlen( str );
    for ( i = 0; i < len ; i++ )
        str[i] = toupper( str[i] );

    return ( 0 );
}

/*
 * 将字符串转为小写
 */
int LowerStr( char * str )
{
    int i, len;

    if ( str == NULL )
         return ( 0 );

    len = strlen( str );
    for ( i = 0; i < len ; i++ )
        str[i] = tolower( str[i] );

    return ( 0 );
}

char * Convert8859( char * str )
{
    int i;
    int len = strlen( str );
    unsigned char * p = ( unsigned char * ) str;
    unsigned char * p2 = p;

    do 
    {
        if ( (*p>>7) == 0x01 )
            *p2 = (((*p)<<6)|(*(++p)));
        else
            *p2 = *p;
        p++;
        p2++;
    } while ( ( (char*) p - str + 1 ) <= len );

    *p2 = 0x0;

    return ( str );
}

/*
 * 判断是否为汉字第一字节
 * GB 2312-80 第一字节 0xA1 - 0xFE
 * GBK        第一字节 0x81 - 0xFE
 */
int ischn_fb( int ch )
{
    return ( ch > 0x80 && ch < 0xFF );
}

/*
 * 判断是否为汉字
 *
 *   GBK/1  0xA1A1-0xA9FE
 *   GBK/2  0xB0A1-0xF7FE
 *   GBK/3  0x8140-0xA0FE
 *   GBK/4  0xAA40-0xFEA0
 *   GBK/5  0xA840-0xA9A0
 *   EUDC/1 0xAAA1-0xAFFE
 *   EUDC/2 0xF8A1-0xFEFE
 *   EUDC/3 0xA140-0xA7A0
 *
 *   第一字节  0x81-0xFE
 *   第二字节  0x40-0x7E, 0x80-0xFE
 */
int ischn_2b( int ch1, int ch2 )
{
    return ( ch1 >= 0x81 && ch1 <= 0xFE &&
             ( ch2 >= 0x40 && ch2 <= 0xFE && ch2 != 0x7F ) );
}

/*
 * 判断字符串中pos位置的字符是否为汉字
 * 0 不是
 * 1 是第一字节
 * 2 是第二字节
 */
int ischn_instr( char * str, int len, int pos )
{
    int             i;
    unsigned char * ustr = ( unsigned char * ) str;

    if ( str == NULL )
        return ( 0 );

    if ( pos < 0 || pos >= len )
        return ( 0 );

    if ( ustr[ pos ] < 0x40 )
        return ( 0 );

    i = 0;
    while ( i < pos )
    {
        if ( ischn_2b( ustr[i], ustr[i+1] ) )
        {
            i += 2;
            if ( i > pos )
                return ( 2 );
        }
        else
            i++;
    }
    return ( ischn_fb( ustr[pos] ) );
}

char * ChineseStr( char * str, int len )
{
    int slen = strlen( str );

    if ( str == NULL )
        return ( NULL );

    if ( slen > len )
    {
        if ( ischn_instr( str, slen, len-1 ) == 1 )
            str[ len-1 ] = 0x0;
        else
            str[ len ] = 0x0;
    }
    return ( str );
}

/* 
 * 按分隔符取串中的项 
 * 输入： 源串
 *        分隔符
 *        当前位置
 * 输出： 
 * 返回：
 *        NULL - 没有项数
 *        指针 - 指向项目内容区
 */
char * StrItemGetByDelimit( char * str, char * delimit, int * pos )
{
    char    * p;
    char    * item;
    int     item_len;

    if ( str == NULL || delimit == NULL )
         return ( NULL );

    if ( * pos == strlen( str ) )
        return ( NULL );

    p = strstr( (str+*pos), delimit );

    if (  p != NULL )
    {