汉字行编辑程序

我写了一个汉字行编辑程序，请各位多多指教，找出本程序的不足，以提高本程序的功能，！

程序如下：

#include "stdio.h"
#include "stdlib.h"
#include "string.h"
#include "conio.h"
#define len 4
#define LINESIZE 80   /*每行长度为80个字符*/
struct TEXT
{
 struct TEXT *prior;
 char str[LINESIZE+1];  /*包括 '\0' 在内，设置长度为LINESIZE+1*/
 struct TEXT *next;
};
struct TEXT *TPTR,*BPTR,*KPTR,*QPTR,*SPTR,*YPTR,*XPTR,*FPTR;
struct TEXT *ptr,*work;
int CHG,ERR,CMP,IND,CTR,i,NUM;
char ch,BUF;
char IN[LINESIZE+1],NUMD[len],MAT[LINESIZE],REP[LINESIZE],temp[LINESIZE];
void main()  /*#1 主要起调度作用*/
{
 void INIT();
 void READ_LINE();
 void INPUT();
 void TOP();
 void UP();
 void NEXT();
 void ENTER();
 void LIST();
 void DELETE();
 void REPLACE();
 void FIND();
 void INSERT();
 void COPY();
 void STORE();
 void WRITE_LINE();
 clrscr();
 INIT();
 while(1)
 {
  if(IND==0)
   printf("\n-");  /*命令提示符*/
  READ_LINE();
  i=0;
  if(IND!=0)
   INPUT();
  else
  {
   ch=IN[0];
   if(ch=='T'||ch=='t')
    TOP();
   else if(ch=='U'||ch=='u')
    UP();
   else if(ch=='N'||ch=='n')
    NEXT();
   else if(ch=='E'||ch=='e')
    ENTER();
   else if(ch=='L'||ch=='l')
    LIST();
   else if(ch=='D'||ch=='d')
    DELETE();
   else if(ch=='R'||ch=='r')
    REPLACE();
   else if(ch=='F'||ch=='f')
    FIND();
   else if(ch=='I'||ch=='i')
    INSERT();
   else if(ch=='C'||ch=='c')
    COPY();
   else if(ch=='S'||ch=='s')
    STORE();
   else if(ch=='Q'||ch=='q')
    exit(0);
   else
   {
    strcpy(IN,"?!\0");  /*不正确的编辑命令响应*/
    WRITE_LINE();
   }
  }
 }
}
void INIT()  /*#2 初始化正文编辑程序*/
{
 void WRITE_LINE();
 printf("\n         ________________________________________");
 printf("\n        |       program for edit                |");
 printf("\n        |T:TOP  U N:UP N N:NEXT                 |");
 printf("\n        |E:ENTER L N:LIST D N:DELETE |");
 printf("\n        |R /STR1/STR2/ N:REPLACE F /SFTR1/:FIND |");
 printf("\n        |C N:COPY   S N:STORE    I:INSERT       |");
 printf("\n        |Q:QUIT     -: the sing of order        |");
 printf("\n        -----------------------------------------");
 FPTR=(struct TEXT*)malloc(sizeof(struct TEXT));
 FPTR->prior=0;
 FPTR->next=0;
 CMP=CHG=ERR=0;
 IND=0;
 BPTR=TPTR=0;  /*无正文链*/
 KPTR=QPTR=0;  /*无工作链*/
 strcpy(IN,"EDIT!\0");
 WRITE_LINE();
}
void READ_LINE()  /*#3 从终端接收一行正文并且把它存到缓冲器IN中 */
{
 i=0;
 BUF=getchar();
 while(i<LINESIZE && BUF!='\n')
 {
  if(BUF=='@')
  {
   if(i!=0)
   {
    if(IN[i-1]<0)
    {
     IN[--i]=' ';  /*是汉字删掉两个字节*/
     IN[--i]=' ';
    }
    else
     IN[--i]=' ';  /*不是汉字删掉一个字节*/
   }
  }
  if(BUF=='#')
   i=0;
  if(BUF<0)
  {
   IN[i++]=BUF;
   IN[i++]=getchar();
  }
  else
   if(BUF!='@' && BUF!='#')
    IN[i++]=BUF;
  BUF=getchar();
 }
 if(i>=LINESIZE||BUF=='\n')
 {
  if(i==0)
   IN[i++]='\n';
  IN[i]='\0';/*存入字符串结束标志*/
 }
 fflush(stdin);
}
void WRITE_LINE()  /*#4 把IN中的内容输出到终端*/
{
 printf("\n%s",IN);
}
void INPUT()  /*#5 从缓冲器IN取来一行正文放到正文文件中*/
{
 void GO_EDIT();
 void CONNECT();
 void INSERT_CHAIN();
 void WRITE_LINE();
 ch=IN[0];
 if(IND==1)  /*尚未接收到正文*/
 {
  if(ch=='\n')
     GO_EDIT();  /*转到编辑模式*/
  else
  {
   if(FPTR==0)
   {
    strcpy(IN,"NOFREE!\0");
    WRITE_LINE();
   }
   else
   {
    ptr=FPTR;  /*YPRT在此模块内主要起链接串之用*/
    XPTR=FPTR;
    strcpy(XPTR->str,IN);
    IND=2;
   }
  }
 }
 else
 {
  if(ch=='\n')  /*空行，从自由链把正文移到正文链并转到编辑模式*/
  {
   CONNECT();
   INSERT_CHAIN();
   GO_EDIT();
  }
  else
  {
   XPTR->next=(struct TEXT*)malloc(sizeof(struct TEXT));
   if(XPTR->next==0)
   {
    CONNECT();
    INSERT_CHAIN();
    strcpy(IN,"NOFREE!\0");
    WRITE_LINE();
    GO_EDIT();  /*内存空间不足，自动转到编辑模式*/
   }
   else
   {
    XPTR=XPTR->next;
    XPTR->prior=ptr;
    ptr=XPTR;
    XPTR->next=0;
    strcpy(XPTR->str,IN);
   }
  }
 }
}
void GO_EDIT()  /*#6  转到编辑模式*/
{
 void WRITE_LINE();
 IND=0;
 strcpy(IN,"EDIT!\0");
 WRITE_LINE();
}
void CONNECT()  /*#7  分离后，只需让TPTR,BPTR指向自由链，但是要让FPTR指向一个新的结点，否则将失去指向*/
{
 YPTR=FPTR;
 FPTR=(struct TEXT*)malloc(sizeof(struct TEXT));
 if(FPTR!=0)
 {
  FPTR->prior=0;
  FPTR->next=0;
 }
}
void INSERT_CHAIN()  /*#8  把新输入的正文加到正文链中，紧接在当前行的后面。开始时YPTR指向输入正文的第一行,*/
{                    /*    XPTR指向最后一行。指针把原有的正文分成两部分，分别为前半和后半。*/
 if(BPTR==0)
 {
  if(TPTR==0)  /*原来没有正文链*/
  {
   TPTR=YPTR;  /*使分离出的自由链的第一行为新的正文链的第一行，自由链的最后一行为新的正文链的最后一行*/
   BPTR=XPTR;
  }
  else
  {
   XPTR->next=TPTR;
   TPTR->prior=XPTR;
   TPTR=YPTR;
   BPTR=XPTR;
   }
 }
 else  /*当前行不是虚拟行*/
 {
  if(BPTR->next==0)  /*当前行指针BPTR指向正文链中最后一行*/
  {
   BPTR->next=YPTR;
   YPTR->prior=BPTR;
   BPTR=XPTR;
  }
  else  /*BPTR指向正文链的中间某个结点*/
  {
   SPTR=BPTR->next;
   BPTR->next=YPTR;
   YPTR->prior=BPTR;
   XPTR->next=SPTR;
   SPTR->prior=XPTR;
   BPTR=XPTR;
  }
 }
}
void TOP()  /*#9  使BPTR指向虚拟行*/
{
 BPTR=0;
 printf("\nMove to virtual line successfully!");
}
void ENTER()  /*#10  进入输入模式*/
{
 void WRITE_LINE();
 IND=1;
 strcpy(IN,"INPUT!\n\0");
 WRITE_LINE();
}
void UP()  /*#11  使指针BPTR从当前行往上移N行，并且打印新的当前行*/
{
 int GET_NUMBER();
 void WRITE_LINE();
 if(GET_NUMBER()==1)  /*不成功返回*/
  return;
 CTR=NUM;  /*调用GET_NUMBER()得到的数在NUM中*/
 if(TPTR==0)
 {
  strcpy(IN,"NOTEXT!\0");
  WRITE_LINE();
  return;
 }
 if(BPTR==0)
 {
  strcpy(IN,"TOF!\0");
  WRITE_LINE();
  return;
 }
 while(CTR>0)
 {
  BPTR=BPTR->prior;
  CTR--;
  if(BPTR==0)
  {
   strcpy(IN,"TOF!\0");
   WRITE_LINE();
   return;
  }
 }
 strcpy(IN,BPTR->str);  /*打印当前行*/
 WRITE_LINE();
}
int GET_NUMBER()  /*#12  从编辑命令中取来数N,把它存在缓冲器NUMD中。假如N是空格，则在CONVERT()中把补缺值置 1*/
{
 int l=0,xb,flag=0;
 void CONVERT(int l);
 void WRITE_LINE();
 ERR=0;
 if(IN[++i]!=' ')
 {
  strcpy(IN,"?!\0");
  WRITE_LINE();
  return(1);
 }
 xb=++i;
 while(IN[xb]!='\0')  /*计算正确命令从空格后第一个字符起到最后的字符长度l*/
 {
  xb++;
  l++;
 }
 if(l>len)  /*当字符长度l>4时，即输入的数字个数>4,认为命令出错*/
 {
  strcpy(IN,"?!\0");
  WRITE_LINE();
  return(1);
 }
 xb=i;
 while(IN[xb]!='\0')
 {
  if((IN[xb]<48||IN[xb]>57)&&IN[xb]!=' ')  /*此命令输入的N中一旦出现既不是数字又不是空格的字符认为出错*/
  {
   strcpy(IN,"?!\0");
   WRITE_LINE();
   return(1);
  }
  xb++;
 }
 xb=i;
 while(IN[xb]!='\0')  /*经过上面两个判定，N中为只包含数字和空格且长度<=4的字符，这里用来判定N中是否全为空格*/
 {
  if(IN[xb]!=' ')
  {
   flag=1;
   break;
  }
  xb++;
 }
 if(!flag)  /*全为空格，缺省值为*/
 {
  NUM=1;
  return(0);
 }
 else
 {
  l=0;
  while(IN[xb]!='\0')
  {
   if(IN[xb]>=48 && IN[xb]<=57)
    NUMD[l++]=IN[xb];
   else  /*一旦出现数字，就要求N中一直到最后必须全为数字，否则认为出错*/
   {
      strcpy(IN,"?!\0");
      WRITE_LINE();
      return(1);
   }
   xb++;
  }
  CONVERT(l);
 }
 if(ERR==1)  /*ERR=1表示命令有错，发现错误后重置ERR=0,备以后判定*/
 {
  ERR=0;
  strcpy(IN,"?!\0");
  WRITE_LINE();
  return(1);
 }
 else
  return(0);  /*成功返回*/
}
void CONVERT(int l)  /*#13  此模块把数组NUMD中用字符形式表示的十进制数转变成十进制数的内部表示形式，并存放到NUMD中*/
{                    /*若NUMD中全是空格，则NUM中放1.假如NUM值为0，则把ERR置1以示错误，否则置0，表明转变成功*/
 int m=0,dig;
 NUM=0;
 while(m<l)
 {
    dig=NUMD[m]-'0';
    NUM=NUM*10+dig;
    m++;
 }
 if(NUM==0)
  ERR=1;
}
void NEXT()  /*14  把指针BPTR从当前行往下移N行*/
{
 int GET_NUMBER();
 void WRITE_LINE();
 if(GET_NUMBER()==1)
  return;
 CTR=NUM;
 if(BPTR==0)  /*在虚拟行*/
 {
  if(TPTR==0)  /*原来没有正文链*/
  {
   strcpy(IN,"NOTEXT!\0");
   WRITE_LINE();
   return;
  }
  else
  {
   BPTR=TPTR;
   CTR--;
  }
 }
 while(CTR>0)
 {
  if(BPTR->next==0)
  {
   strcpy(IN,"EOF!\0");
   WRITE_LINE();
   return;
  }
  BPTR=BPTR->next;
  CTR--;
 }
 strcpy(IN,BPTR->str);
 WRITE_LINE();
}
void LIST()  /*#15  输出正文链中从当前行开始的N行正文*/
{
 int GET_NUMBER();
 void WRITE_LINE();
 if(GET_NUMBER()==1)
  return;
 CTR=NUM;  /*调用GET_NUMBER()得到的数在NUM中*/
 if(BPTR==0)  /*在虚拟行*/
 {
  if(TPTR==0)  /*原来没有正文链*/
  {
   strcpy(IN,"NOTEXT!\0");
   WRITE_LINE();
   return;
  }
  else
   BPTR=TPTR;  /*第一行作为当前行*/
 }
 strcpy(IN,BPTR->str);
 CTR--;
 WRITE_LINE();
 while(CTR>0)
 {
  if(BPTR->next==0)
  {
   strcpy(IN,"EOF!\0");
   WRITE_LINE();
   return;
  }
  BPTR=BPTR->next;
  strcpy(IN,BPTR->str);
  CTR--;
  WRITE_LINE();
 }
}
void DELETE()  /*#16  删掉正文链中从当前行开始的N行正文，并且释放后占的存贮空间，假如N是空格，则补缺值为1*/
{
  int GET_NUMBER();
  void WRITE_LINE();
  void DELETE_LINK();
  if(GET_NUMBER()==1)
   return;
  CTR=NUM;
  if(BPTR==0)
  {
   if(TPTR==0)
   {
    strcpy(IN,"NOTEXT!\0");
    WRITE_LINE();
    return;
   }
   else
    BPTR=TPTR;
  }
  DELETE_LINK();
  while(YPTR!=XPTR)  /*释放后占空间*/
  {
   YPTR=YPTR->next;
   free(YPTR->prior);
  }
  free(XPTR);
  printf("\ndelete successfully!");
}
void DELETE_LINK()  /*#17  从正文链中把要删掉的那些行分离下来。使YPTR和XPTR分别指向要被删掉的第一行和最后一行*/
{
 void WRITE_LINE();
 YPTR=BPTR;
 XPTR=BPTR;
 CTR--;
 while(CTR>0 && XPTR->next!=0)
 {
  XPTR=XPTR->next;
  CTR--;
 }
 if(XPTR->next==0)  /*已删到正文链末尾*/
 {
  if(CTR>0)  /*要求删掉的行比能删掉的行多*/
  {
   strcpy(IN,"EOF!\0");
   WRITE_LINE();
  }
  if(YPTR->prior==0)  /*从第一行开始删除*/
  {
   BPTR=0;
   TPTR=0;
  }
  else  /*还有正文链*/
  {
   BPTR=YPTR->prior;
   BPTR->next=0;
  }
 }
 else  /*没有删到正文链末尾*/
 {
  BPTR=XPTR->next;  /*BPTR指向被删掉的后面第一行，作为新的当前行*/
  if(YPTR->prior==0)/*从第一行开始删*/
  {
   TPTR=BPTR;
   TPTR->prior=0;
  }
  else  /*从正文链的中间某个结点删，但是没有删到正文链末尾*/
  {
   SPTR=YPTR->prior;
   SPTR->next=BPTR;
   BPTR->prior=SPTR;
  }
 }
}
void COPY()  /*#18  把正文链从当行开始的N行正文复制到工作链，这N行正文并不从正文链删除*/
{
 int GET_NUMBER();  /*思路：直接从正文链复制到工作链，当工作链空间不够用时提示用户输入了多少行*/
 void WRITE_LINE(); /*当复制的行数>可得到的行数,印出信息EOF*/
 int line=0;
 if(GET_NUMBER()==1)
  return;
 CTR=NUM;
 if(BPTR==0)   /*在虚拟行*/
 {
  if(TPTR==0) /*无正文链*/
  {
   strcpy(IN,"NOTEXT!\0");
   WRITE_LINE();
   return;
  }
  else
   BPTR=TPTR; /*正文链第一行作为虚拟行*/
 }
 XPTR=BPTR;
 while(CTR>0 && XPTR->next!=0)
 {
  if(KPTR==0)  /*原来没有工作链*/
  {
   KPTR=(struct TEXT*)malloc(sizeof(struct TEXT));
   if(!KPTR)
   {
    printf("\nThere is no free space!");
    return;
   }
   work=KPTR;
   KPTR->prior=0;
   KPTR->next=0;
   QPTR=KPTR;
   strcpy(QPTR->str,XPTR->str);
   XPTR=XPTR->next;
   CTR--;
   line++;
  }
  else   /*已存在工作链*/
  {
   QPTR->next=(struct TEXT*)malloc(sizeof(struct TEXT));
   if(!QPTR->next)
   {
    printf("\nNo free space,only copied %d lines!",line);
    BPTR=XPTR;
    return;
   }
   QPTR=QPTR->next;
   QPTR->prior=work;
   work=QPTR;
   QPTR->next=0;
   strcpy(QPTR->str,XPTR->str);
   CTR--;
   XPTR=XPTR->next;
   line++;
  }
 }
 if(XPTR->next==0)
 {
  if(CTR>0) /*退出上面的循环时最后一行尚未复制*/
  {
   BPTR=XPTR;
   strcpy(IN,"EOF!\0");
   WRITE_LINE();
                        QPTR->next=(struct TEXT*)malloc(sizeof(struct TEXT));
   if(!QPTR->next)
   {
    printf("\nNo free space,only copied %d lines!",line);
    return;
   }
   QPTR=QPTR->next;
   QPTR->prior=work;
   work=QPTR;
   QPTR->next=0;
   strcpy(QPTR->str,XPTR->str);
   CTR--;
   XPTR=XPTR->next;
  }
  else
   BPTR=XPTR;
 }
 else
  BPTR=XPTR;
}
void STORE()  /*#19  把正文链中从当前行开始的N行正文同其他正文分离开，然后把他们移到工作链的尾部。*/
{              /*    调用Delete_Link（）后，YPTR，XPTR分别指向要分离正文的第一行和最后一行。*/
 void WRITE_LINE();
 void DELETE_LINK();
 int GET_NUMBER();
 if(GET_NUMBER()== 1)
  return;
  CTR=NUM;
  if(BPTR==0) /*在虚拟行*/
  {
   if(TPTR==0)  /*原来没有正文链*/
   {
    strcpy(IN,"NOTEXT!\0");
    WRITE_LINE();
    return;
   }
   else
    BPTR=TPTR;  /*第一行作为当前行*/
  }
  DELETE_LINK();
  if(KPTR==0)
  {
   KPTR=YPTR;
   KPTR->prior=0;
  }
  else
  {
   QPTR->next=YPTR;
   YPTR->prior=QPTR;
  }
  QPTR=XPTR;
  work=QPTR;
  QPTR->next=0;
}
void INSERT()  /*#20 把工作链中的全部正文都插到正文链中，紧接在当前行后面*/
{
 void INSERT_CHAIN();
 if(KPTR==0)
 {
  printf("\nThere is no text in workspace!");
  return;
 }
 printf("\nINSERT SUCCESSFULLY!");
 YPTR=KPTR;
 XPTR=QPTR;
 KPTR=0;
 QPTR=0;
 INSERT_CHAIN();
}
int GET_STRING1()  /*#21  从命令中取得第一个字符串，并且把它存到缓冲器MAT中*/
{
 int j=0;
 void WRITE_LINE();
 if(IN[++i]!=' ')  /*缓冲器IN中的第二个字符不是空格，命令形式错*/
 {
  strcpy(IN,"?!\0");
  WRITE_LINE();
  return(1);
 }
 if(IN[++i]!='/')  /*缓冲器IN中的第三个字符不是斜线，命令形式错*/
 {
  strcpy(IN,"?!\0");
  WRITE_LINE();
  return(1);
 }
 if(IN[++i]=='/')  /*空字符串，命令形式错*/
 {
  strcpy(IN,"?!\0");
  WRITE_LINE();
  return(1);
 }
 while(IN[i]!='\0' && IN[i]!='/')  /*找到第二条斜线*/
  MAT[j++]=IN[i++];
 if(IN[i]=='\0')  /*缺第二条斜线，命令形式错*/
 {
  strcpy(IN,"?!\0");
  WRITE_LINE();
  return(1);
 }
 i++;  /*i指向第二条斜线后的第一个字符*/
 MAT[j]='\0';
 return(0);
}
void COMP()  /*#22  这个模块比较缓冲器IN中从第I个字符开始的子字符串和缓冲器MAT中的字符串，开关CMP指示比较结果*/
{            /*     1表示匹配，0表示不匹配*/
 int l,xb=0,up=0;
 while(strlen(IN)-up>=strlen(MAT))  /*IN中剩余字符串的长度>MAT中的字符串长度，继续寻找*/
 {
  for(l=0;l<strlen(MAT);l++)
   temp[l]=IN[xb++];  /*temp是临时数组，存放IN中从第xb个字符起长度为strlen(MAT)的子串*/
  temp[l]='\0';
  if(strcmp(temp,MAT)==0)    /*字符串匹配，CMP置1，返回*/
  {
   CMP=1;
   return;
  }
  up++;
  xb=up;
 }
}
void FIND()  /*#23  从当前行下面一行开始扫描正文链，使当前行指针指向第一次出现字符串STRING1的那一行*/
{
 int GET_STRING1();
 void COMP();
 void WRITE_LINE();
 if(GET_STRING1()==1)  /*不成功返回*/
  return;
 if(TPTR==0)  /*没有正文*/
 {
  strcpy(IN,"NOTEXT!\0");
  WRITE_LINE();
  return;
 }
 if(BPTR==0)
    BPTR=TPTR;
 else
 {
  if(BPTR->next!=0)  /*当前行不是正文链最后一行，从下一行开始扫描*/
   BPTR=BPTR->next;
  else
  {
   strcpy(IN,"EOF!\0");
   WRITE_LINE();
   return;
  }
 }
 while(BPTR->next!=0)  /*逐行扫描*/
 {
  strcpy(IN,BPTR->str);
  COMP();
  if(CMP==1)
  {
   CMP=0;
   WRITE_LINE();
   return;
  }
  BPTR=BPTR->next;
 }
 strcpy(IN,BPTR->str);  /*退出循环后，最后一行还没有扫描*/
 COMP();
 if(CMP==1)
 {
  CMP=0;
  WRITE_LINE();
 }
 else
 {
    strcpy(IN,"EOF!\0");
    WRITE_LINE();
 }
}
int GET_STRING2()  /*#24  从编辑命令中取第二个字符串STRING2，开始时指针i指向第二条斜线的后的第一个字符。取得的字符串放在*/
{                  /*     缓冲器REP中   */
 int k=0;
 void WRITE_LINE();
 if(IN[i]=='\0'  || IN[i]=='/')  /*缺第三条斜线或第二个字符串为空串*/
 {
  strcpy(IN,"?!\0");
  WRITE_LINE();
  return(1);
 }
 while(IN[i]!='/' && IN[i]!='\0')
  REP[k++]=IN[i++];
 if(IN[i]=='\0')  /*IN中总是以\0结束，假如以此条件退出循环，说明肯定没有第三条斜线，命令形式错*/
 {
  strcpy(IN,"?!\0");
  WRITE_LINE();
  return(1);
 }
 REP[k]='\0';  /*成功找到第二个字符串*/
 return(0);
}
void REPLACE()  /*#25 在从当前行开始的N行正文中，每出现一个字符串STRING1,就用字符串STRING2来代替*/
{
 int xhbl,xj=0,sj=0;
 struct TEXT *pre;  /*PRE总是指向BPTR的前一个结点*/
 int GET_STRING1();
 int GET_STRING2();
 int GET_NUMBER();
 void WRITE_LINE();
 void BACK(int up,int xb);
 if(GET_STRING1()==1)
 {
  strcpy(IN,"?!\0");
  WRITE_LINE();
  return;
 }
 if(GET_STRING2()==1)
 {
  strcpy(IN,"?!\0");
  WRITE_LINE();
  return;
 }
 if(GET_NUMBER()==1)
 {
  strcpy(IN,"?!\0");
  WRITE_LINE();
  return;
 }
 if(BPTR==0)  /*在虚拟行*/
 {
  if(TPTR==0)  /*原来没有正文链*/
  {
   strcpy(IN,"NOTEXT!\0");
   WRITE_LINE();
   return;
  }
  else
   BPTR=TPTR;
 }
 CTR=NUM;
 CHG=0;
 while(CTR>0 && BPTR!=0)
 {
  strcpy(IN,BPTR->str);
  while(strlen(IN)-xj>=strlen(MAT))/*检查机制：从IN第一个字符起，取长度为strlen(MAT)的子串放到temp中，和*/
  {                                /*MAT比较之后，再从IN第二个字符起，取长度为strlen(MAT)的子串放到temp中*/
     for(xhbl=0;xhbl<strlen(MAT);xhbl++)/*MAT比较，依次类推，直到IN从第i个字符起到最后一个字符的长度<strlen(MAT)为止*/
     temp[xhbl]=IN[sj++];
     temp[xhbl]='\0';
     if(strcmp(temp,MAT)==0)
     {
     CHG=1;
     BACK(xj,sj);
     sj+=strlen(REP)-strlen(MAT); /*替换后，从替换后的下一个字符起检查串有无其它和MAT相同的子中*/
     xj=sj;
     continue;
     }
     xj++;
     sj=xj;
  }
  if(CHG==1)
  {
   CHG=0;
   strcpy(BPTR->str,IN);
   WRITE_LINE();
  }
  pre=BPTR;
  BPTR=BPTR->next;
  CTR--;
  xj=0;  /*sj,xj重置初值，扫描下一行*/
  sj=0;
 }
 if(BPTR==0)  /*若出现要求代替的行数多于能得到的行数，显示信息EOF!*/
  if(CTR>0)
  {
   strcpy(IN,"EOF!\0");
   WRITE_LINE();
  }
  BPTR=pre;
}
void BACK(int up,int xb)  /*#26  此模块用来完成替换*/
{                         /*up指向IN中一子串的首地址，此子串与MAT匹配，xb指向此子串的后面的第一个字符*/
 int sub,len1,len2,leftspa,j=0,l;
 len1=strlen(MAT);
 len2=strlen(REP);
 sub=len2-len1;  /*求出用REP中替换IN中的子串后增加了几个字符,可能为负数*/
 leftspa=LINESIZE-strlen(IN);  /*求IN中的剩余空间*/
 if(len1==len2)                /*要替换的串与被替换的串长度相等*/
  for(l=1;l<=len2;l++)
   IN[up++]=REP[j++];  /*从up位置起逐个替换原子串*/
 if(len1>len2) 
 {
  for(l=1;l<=len2;l++)
   IN[up++]=REP[j++];
   up=xb-up;  /*求xb到up之间用几个字符*/
   while(IN[xb]!='\0')
   {
    IN[xb-up]=IN[xb];  /*从xb位置起逐个后移字符,位移量为up*/
    xb++;
   }
   IN[xb-up]='\0';
 }
 if(len1<len2)  /*此时替换需要考虑替换后IN中空间是否够用的问题，若不够用需截尾*/
 {
  if(leftspa>=sub)  /*IN中剩余空间大于等于要增加的字符，此时空间够用*/
  {
   for(l=strlen(IN); l>=xb;l--)
    IN[l+sub]=IN[l];  /*从\0起逐个后移字符，腾出空间*/
   for(l=1;l<=len2;l++)
    IN[up++]=REP[j++];  /*空间已腾出，逐个替换即可*/
  }
  else  /*IN中空间小于要增加的字符数，需进行截尾操作*/
  {
   for(l=strlen(IN)-(sub-leftspa)-1;l>=xb;l--)  /*算出需截掉的字符个数为sub-leftspa,
    IN[l+sub]=IN[l];                     /*只需从strlen(IN)-(sub-leftspa)-1开始逐个后移字符*/
    IN[LINESIZE]='\0';
   for(l=1;l<=len2 && l<LINESIZE-up;l++)  /*逐个替换需保证循环次数，只能从up到\0之间*/
      IN[up++]=REP[j++];
  }
 }
}