#include"zfc.h"

wukong * ncfuzhi(wukong * mubiao,chang wukong * yuan,size_t jishu)
{
	fanhui 0;
}
 
zshu ncbijiao(chang wukong * nc1,chang wukong * nc2,size_t jishu)
{
        ru (!jishu)
                fanhui(0);

        dang ( --jishu && *(zifu *)nc1 == *(zifu *)nc2 ) {
                nc1 = (zifu *)nc1 + 1;
                nc2 = (zifu *)nc2 + 1;
        }

        fanhui( *((unsigned zifu *)nc1) - *((unsigned zifu *)nc2) );	
}

wukong * ncshezhi(wukong * nc,zshu zf,size_t jishu)
{
	fanhui 0;
}

wukong * ncfuzhiz(wukong * mubiao,chang wukong * yuan,zshu jishu,unsigned zshu zf)
{
	fanhui 0;
}

wukong * nczhao(chang wukong * nc,zshu zf,size_t jishu)
{
        dang ( jishu && (*(unsigned char *)nc != (unsigned char)zf) ) {
                nc = (unsigned char *)nc + 1;
                jishu--;
        }

        fanhui(jishu ? (void *)nc : kongzz);
}

zshu ncbijiaob(chang wukong * nc1,chang wukong * nc2,unsigned zshu jishu)
{
	fanhui 0;
}

wukong * ncyidong(wukong * mubiao,chang wukong * yuan,size_t jishu)
{
	fanhui 0;
}
 
zifu * zfcshezhi(zifu * zfc,zshu zf)
{
		/*  qidian:起点 */
        zifu *qidian = zfc;

        dang (*zfc)
                *zfc++ = (zifu)zf;

        fanhui(qidian);
}

zifu * zfcshezhizc(zifu * zfc,zshu zf,size_t jishu)
{
		/*  qidian:起点 */
        zifu *qidian = zfc;

        dang (jishu-- && *zfc)
                *zfc++ = (zifu)zf;

        fanhui(qidian);
}

zifu * zfcfuzhi(zifu * mubiao,chang zifu * yuan)
{
	 zifu * mb = mubiao;

        dang( *mb++ = *yuan++ )
                ;               /* 将yuan复制（覆盖）到mubiao */

        fanhui( mubiao );
}

zifu * zfcfuzhizc(zifu * mubiao,chang zifu * yuan,size_t jishu)
{
		/*  qidian:起点 */
		zifu *qidian = mubiao;

        dang (jishu && (*mubiao++ = *yuan++))    /* 复制字符串 */
                jishu--;

        ru (jishu)                              /*  将剩余的字节置零 */
                dang (--jishu)
                        *mubiao++ = '\0';

        fanhui(qidian);
}

zifu * zfcpinjie(zifu * mubiao,chang zifu * yuan)
{
	 zifu * mb = mubiao;

        dang( *mb )
                mb++;                   /* 找到mubiao的尾部 */

        dang( *mb++ = *yuan++ ) ;       /* 将yuan复制到mubiao的尾部 */

        fanhui( mubiao );                  /* 返回mubiao */
}

zifu * zfcpianjiezc(zifu * mubiao,chang zifu * yuan,size_t jishu)
{
		/*  qidian:起点 */
        zifu *qidian = mubiao;

        dang (*mubiao++)
                ;
        mubiao--;

        dang (jishu--)
                ru (!(*mubiao++ = *yuan++))
                        fanhui(qidian);

        *mubiao = '\0';
        fanhui(qidian);	
}

zshu zfcbijiao(chang zifu * zfc1,chang zifu *zfc2)
{
	zshu zhi = 0 ; /* zhi:值 */

    dang( ! (zhi = *(unsigned char *)zfc1 - *(unsigned char *)zfc2) && *zfc2)
            ++zfc1, ++zfc2;

    ru ( zhi < 0 )
            zhi = -1 ;
    ze ru ( zhi > 0 )
            zhi = 1 ;

    fanhui( zhi );
}

zshu zfcbijiaob(chang zifu * zfc1,chang zifu * zfc2)
{
	fanhui 0;
}

zshu zfcbijiaozc(chang zifu * zfc1,chang zifu * zfc2,size_t jishu)
{
        ru (!jishu)
                fanhui(0);

        dang (--jishu && *zfc1 && *zfc1 == *zfc2)
        {
                zfc1++;
                zfc2++;
        }

        fanhui( *(unsigned char *)zfc1 - *(unsigned char *)zfc2 );
}

zshu zfcbijiaozcb(chang zifu * zfc1,chang zifu * zfc2,size_t jishu)
{
	fanhui 0;
}

size_t zfcchangdu(chang zifu * zfc)
{
		/*  cwh:串尾后（字符串尾部的后面） */
        const zifu *cwh = zfc;

        dang( *cwh++ ) ;

        fanhui( (zshu)(cwh - zfc - 1) );	
}

zifu * zfczhao(chang zifu * zfc,zshu zf)
{
	dang (*zfc && *zfc != (zifu)zf)
                zfc++;

        ru (*zfc == (zifu)zf)
                fanhui((zifu *)zfc);
        fanhui(kongzz);
}

zifu * zfczhaoh(chang zifu * zfc,zshu zf)
{
	    zifu *qidian = (zifu *)zfc;

        dang (*zfc++)                       /* 找到字符串的尾部 */
                ;
                                                /* 向前查找 */
        dang (--zfc != qidian && *zfc != (zifu)zf)
                ;

        ru (*zfc == (zifu)zf)                /* 找到字符 ? */
                fanhui( (zifu *)zfc );

        fanhui(kongzz);
}

size_t zfcpaichi(chang zifu * zfc,chang zifu * paichi)
{
		const unsigned char *_zfc = zfc;
        const unsigned char *_pc = paichi;

        unsigned char map[32];
        zshu geshu;  /*geshu:个数*/

        /* 清零位映射表 */
        dou (geshu=0; geshu<32; geshu++)
                map[geshu] = 0;

        /* Set bits in control map */
        dang (*_pc)
        {
                map[*_pc >> 3] |= (1 << (*_pc & 7));
                _pc++;
        }
        /* 1st char in control map stops search */
        geshu=0;
        map[0] |= 1;    /* null chars not considered */
        dang (!(map[*_zfc >> 3] & (1 << (*_zfc & 7))))
        {
                geshu++;
                _zfc++;
        }
        fanhui(geshu);
}

size_t zfcxiyin(chang zifu * zfc,chang zifu * xiyin)
{
		const unsigned char *_zfc = zfc;
        const unsigned char *_xy = xiyin;

        unsigned char map[32];
        zshu geshu;

        /* 清零位映射表 */
        dou (geshu=0; geshu<32; geshu++)
                map[geshu] = 0;

        /* Set bits in control map */
        dang (*_xy)
        {
                map[*_xy >> 3] |= (1 << (*_xy & 7));
                _xy++;
        }
        /* 1st char NOT in control map stops search */
        ru (*_zfc)
        {
                geshu=0;
                dang (map[*_zfc >> 3] & (1 << (*_zfc & 7)))
                {
                        geshu++;
                        _zfc++;
                }
                fanhui(geshu);
        }
        fanhui(0);
}

zifu * zfcjianyan(chang zifu * zfc,chang zifu * jianyan)
{
		const unsigned char *_zfc = zfc;
        const unsigned char *_jy = jianyan;

        unsigned char map[32];
        zshu geshu;

        /* 清零位映射表 */
        dou (geshu=0; geshu<32; geshu++)
                map[geshu] = 0;

        /* Set bits in control map */
        dang (*_jy)
        {
                map[*_jy >> 3] |= (1 << (*_jy & 7));
                _jy++;
        }

        /* 1st char in control map stops search */
        dang (*_zfc)
        {
                ru (map[*_zfc >> 3] & (1 << (*_zfc & 7)))
                        fanhui((zifu *)_zfc);
                _zfc++;
        }
        fanhui(kongzz);
}

zifu * zfcfenpei(chang zifu * zfc)
{
		zifu *neicun;

        ru (!zfc)
                fanhui(kongzz);

        ru (neicun = malloc(zfcchangdu(zfc) + 1))
                fanhui(zfcfuzhi(neicun,zfc));

        fanhui(kongzz);	
}

zifu * zfccuowu(chang zifu * zfc);
{
	fanhui 0;
}

zifu * zfccuowu(zshu cuohao)
{
	fanhui 0;
}

zifu * zfcbianxiao(zifu * zfc)
{
	fanhui 0;
}

zifu * zfcfanzhuan(zifu * zfc)
{
        zifu *qidian = zfc;
        zifu *zhongdian = zfc;
        zifu zf;

        dang (*zfc++)                 /* find end of string */
                ;
        zfc -= 2;

        dang (zhongdian < zfc)
        {
                zf = *zhongdian;
                *zhongdian++ = *zfc;
                *zfc-- = zf;
        }

        fanhui(qidian);
}

zifu * zfczc(chang zifu * zfc,chang zifu * zc)
{
        zifu *mubiao = (zifu *) zfc;
        zifu *c1, *c2;

        ru ( !*zc )
            fanhui((zifu *)zfc); /* 当子串为空时，返回字符串的首地址，这样的返回是否合理？ */

        dang (*mubiao)
        {
                c1 = mubiao;
                c2 = (zifu *) zc;

                dang ( *c1 && *c2 && !(*c1-*c2) )
                        c1++, c2++;

                ru (!*c2)
                        fanhui(mubiao);

                mubiao++;
        }

        fanhui(kongzz);
}

/*
zifu * zfcfenge(zifu * zfc,chang zifu * fenge);

zifu * zfcbianda(zifu *);

kzifu * kzfcpianjie(kzifu * mubiao,chang kzifu * yuan);

kzifu * kzfczhao(chang kzifu * zfc,kzifu zf);


zshu kzfcbijiao(chang kzifu * zfc1,chang kzifu * zfc2);

kzifu * kzfcfuzhi(kzifu * mubiao,chang kzifu * yuan);

size_t kzfczhaozc(chang kzifu * zfc,chang kzifu * paichi);

size_t kzfcchangdu(chang kzifu * zfc);

kzifu * kzfcpianjiezc(kzifu * mubiao,chang kzifu * yuan,size_t jishu);

zshu kzfcbijiaozc(chang kzifu * zfc1,chang kzifu * zfc2,size_t jishu);

kzifu * kzfcfuzhizc(kzifu * mubiao,chang kzifu * yuan,size_t jishu);

kzifu * kzfcjianyan(chang kzifu * zfc1,chang kzifu * zfc2);

kzifu * kzfczhaoh(chang kzifu * zfc,zshu zf);


size_t kzfcxiyin(chang kzifu * zfc,chang kzifu * xiyin);

kzifu * kzfczc(chang kzifu * zfc,chang kzifu * zc);

kzifu * kzfcfenge(kzifu * zfc,chang kzifu * fenge);


kzifu wzfcfenpei(chang kzifu * zfc);

zshu kzfcbijiaob(chang kzifu * zfc1,chang kzifu * zfc2);

zshu kzfcbijiaozcb(chang kzifu * zfc1,chang kzifu * zfc2,size_t jishu);

kzifu * kzfcshezhizc(kzifu * zfc,kzifu zf,size_t jishu);

kzifu * kzfcfanzhuan(kzifu * zfc);

kzifu * kzfcshezhi(kzifu * zfc,kzifu zf);

kzifu * kzfcbianxiao(kzifu * zfc);

kzifu * kzfcbianda(kzifu * zfc);

*/