文本编辑器源代码

/* A Screen Editer Subsystem */

#define TURBOC

#include

#include

#include

#include

#include

#define BUF_SIZE 32000

#define LINE_LEN 79-2

#define MAX_LINES 24-1

#define KILL_BUF_SIZE 4*LINE_LEN

/***********************************************************/

char buf[BUF_SIZE];

char *curloc,*endloc;

int scrnx,scrny;

char killbuf[KILL_BUF_SIZE];

char *helpline="F1:save F2:load F3:find F4:replace ^K:kill line ^Y:Yank ^Z:qiut"; /*************************************************************/ void edit(char *fname),help(void);

void gotoxy(int x,int y),clrline(int y);

void edit_clr_col(int x,int y),clrscr(void);

void printline(char *p),delete_char(void);

void search(void),kill_line(void);

void scrolldn(int x,int y);

void scrollup(int topx,int topy,int endx,int endy);

void upline(void);

void downline(void),left(void),right(void);

void display_scrn(int x,int y,char *p);

void pagedown(void),pageup(void),replace(void);

void home(void),gotoend(void),yank(void);

int load(char *fname),save(char *fname);

void edit_gets(char *str);

void draw_border(int,int,int,int,int);

/***************************************************/

main(int argc,char *argv[])

{

union REGS r;

char fname[80];

if(argc<2)

{

draw_border(0,0,78,24,0x1f);

draw_border(20,12,60,14,0x2f);

gotoxy(20,11);

printf("\7FILE NAME:");

gotoxy(21,13);

gets(fname);

edit(fname);

}

if(argc==2)

{

strupr(argv[1]);

if(strstr(argv[1],".EXE")||strstr(argv[1],".COM")||\

strstr(argv[1],".OBJ")||strstr(argv[1],".LIB"))

{

printf("\7Can't edit file :%s",argv[1]);

exit(1);

}

else edit(argv[1]);

}

r.h.ah=6;

r.h.al=0;

r.h.ch=0;

r.h.cl=0;

r.h.dh=24;

r.h.dl=79;

r.h.bh=7;

int86(0x10,&r,&r);

gotoxy(1,1);

}

/******************************************************************/ void edit(char *fname)

{

union k

{

char ch[2];

unsigned i;

}key;

char name[80];

/* try to load the file */

if(!load(fname))curloc=endloc=buf;

strcpy(name,fname);

/* set initial values to X,Y coordinate vars */

scrnx=scrny=0;

display_scrn(0,0,curloc);

help();

gotoxy(1,1);

/* editer main loop . */

do{

#ifdef TURBOC

key.i=bioskey(0);

#endif

if(!key.ch[0])

{

switch(key.ch[1])

{

case 59: /*F1 :save file */

save(name);

break;

case 60: /*F2: load file */

clrline(MAX_LINES);

gotoxy(1,MAX_LINES);

printf("Enter filename :");

edit_gets(name);

strupr(name);

if(strstr(name,".EXE")||strstr(name,".COM")||\

strstr(name,".OBJ")||strstr(name,".LIB"))

{

gotoxy(1,MAX_LINES);

printf("\7Can't edit file: %s",name);

getch();

help();

break;

}

if( * name) load(name);

help();

display_scrn(0,0,curloc);

scrnx=scrny=0;

break;

case 61:

search();

break;

case 62:

replace();

break;

case 71:

home();

break;

case 79:

gotoend();

break;

case 75: /*left*/

left();

break;

case 77:

right();

break;

case 72:

upline();

break;

case 80:

downline();

break;

case 73:

pageup();

break;

case 81:

pagedown();

break;

case 83: /*Del*/

if(curloc

break;

}

if(curloc

{

scrnx=scrny=0;

curloc=buf;

}

gotoxy(scrnx+1,scrny+1); /*postion cursor */ }

else

{

switch(key.ch[0])

{

case '\r':

/*see if buffer is full */

if(endloc==buf+BUF_SIZE-2) break;

/* move contents of file below current location down one byte to make room for the RETURN.*/ memmove(curloc+1,curloc,endloc-curloc+1);

*curloc=key.ch[0]; /*put RETURN in file */

/*clear rest of line */

edit_clr_col(scrnx,scrny);

scrnx=0;

scrny++;

/*move text on screen down */

if(scrny==MAX_LINES-1)

{

/*at bottom of page */

scrny=MAX_LINES-2;

scrollup(1,1,LINE_LEN,scrny+1);

}

else scrolldn(scrnx+1,scrny+1);

gotoxy(scrnx+1,scrny+1);

printline(curloc);

endloc++;

/* advance the end of file pointer */ break;

case '\b':

if(curloc==buf) break;

left();

delete_char();

break;

case 11:

kill_line();

break;

case 25:

yank();

break;

case 26:

clrline(MAX_LINES);

gotoxy(1,MAX_LINES);

printf("If saved file,press[Y]exit\7");

if(tolower(getch())=='y') goto end;

help();

break;

default: /* enter keystroke into file */

/*see if buf is full */

if(endloc==buf+BUF_SIZE-2) break;

/*can't type past end of line */

if(scrnx==LINE_LEN) break;

memmove(curloc+1,curloc,endloc-curloc+1); *curloc=key.ch[0];

putch(*curloc);

gotoxy(scrnx+1,scrny+1);

printline(curloc+1);

curloc++;

endloc++;

}

gotoxy(scrnx+1,scrny+1);

}

}while(1);

end:

printf("\n");

}

/**************************************************************************** Display a line pointed to by p.

****************************************************************************/ void printline(register char *p)

{

register int i;

i=scrnx+1;

while(*p!='\r'&&*p&&i

{

putch(*p);

p++;

i++;

}

}

/**************************************************************************** Insert previously killled line.

****************************************************************************/ void yank(void)

{

char *p;

p=killbuf;

while(*p)

{

memmove(curloc+1,curloc,endloc-curloc+1);

*curloc=*p;

if(scrnx

{

putch(*curloc);

scrnx++;

}

endloc++;

p++;

}

}

/*******************************************************/

/* Delete the line at the current location */

void kill_line(void)

{

register int i;

char *p,*killbufptr;

if(*curloc=='\r')

{

delete_char();

return;

}

edit_clr_col(scrnx,scrny); /*clear to CR */

/* find out hoe many characters are in the line */

p=curloc;

i=0;

killbufptr=killbuf;

while(*p!='r'&&p

{

i++;

*killbufptr=*p;

p++;

if(killbufptr

}

*killbufptr='\0';

/* remove the line */

memmove(curloc,curloc+i,endloc-curloc);

endloc-=i;

}

/*********************************************************************** Global search and replace

***********************************************************************/ void replace(void)

{

register int len1;

char str1[80],str2[80];

char *p,*p2;

clrline(MAX_LINES);

gotoxy(1,MAX_LINES);

printf("enter string to replace :");

edit_gets(str1);

clrline(MAX_LINES);

gotoxy(1,MAX_LINES);

printf("enter replacement:");

edit_gets(str2);

p=curloc;

len1=strlen(str1);

while(*str1)

{

/*search for the string */

while(*p && strncmp(str1,p,len1)) p++; if(!*p)

{

clrline(MAX_LINES);

gotoxy(1,MAX_LINES);

printf("No found string %s",str1); getch();

help();

break;

} /* not found */

/* remove old string */

memmove(p,p+len1,endloc-p);

endloc-=len1;

/*insert new string */

p2=str2;

while(*p2)

{

memmove(p+1,p,endloc-p+1);

*p=*p2;

p++;

endloc++;

p2++;

}

}

clrscr();

/* find location of top screen */

p=curloc;

for(len1=scrny;len1>=0&&p

{

p--;

if(*p=='r') len1--;

}

if(*p=='r') p++;

/* redisplay current screen */

display_scrn(0,0,p);

help();

}

void delete_char(void)

{

gotoxy(scrnx+1,scrny+1);

if(*curloc=='r')

{

scrollup(1,scrny+1+1,LINE_LEN,MAX_LINES-1);

memmove(curloc,curloc+1,endloc-curloc);

endloc--;

display_scrn(scrnx,scrny,curloc);

help();

}

else

{

memmove(curloc,curloc+1,endloc-curloc);

endloc--;

printline(curloc);

printf("");

}

}

/************************************************************************* Display help line.

*************************************************************************/ void help(void)

{

gotoxy(1,MAX_LINES);

printf(helpline);

}

/************************************************************************* Move cuuren location left

*************************************************************************/ void left(void)

{

if(curloc==buf) return;

scrnx--;

if(scrnx<0)

{

scrnx=0;

upline(); /*go up to next line */

/* find end of line */

while(*curloc!='r')

{

curloc++;

scrnx++;

}

}

else curloc--;

}

/********************************************************************** Move current position right.

**********************************************************************/ void right(void)

{

if(curloc+1>endloc) return;

scrnx++;

/* if at the end of line,go to the next one. */

if(scrnx>LINE_LEN||*curloc=='\r')

{

scrnx=0;

scrny++;

if(scrny==MAX_LINES-1) /* at end of screen */

{

scrny=MAX_LINES-2;

downline();

/* move cursor and current loc to start of new line */

curloc--;

while(*curloc!='\r') curloc--;

curloc++;

scrnx=0;

}

else curloc++;

}

else curloc++;

}

/**********************************************************************/ void search(void)

{

char str[80];

register char *p;

int len,i;

clrline(MAX_LINES);

gotoxy(1,MAX_LINES);

printf("search string :");

edit_gets(str);

if(! *str)

{

help();

return;

}

p=curloc;

len=strlen(str);

while(*p&&strncmp(str,p,len)) p++;

if(! *p)

{

gotoxy(1,MAX_LINES);

printf("\7No found string %s!",str);

getch();

help();

return;

} /* not found */

i=0;

while(p>buf&&*p!='\r')

{

p--;

i++;

}

p++;

i--;

/* reposition curren location to start of match */

curloc=p+i;

scrnx=i;

scrny=0;

clrscr();

display_scrn(0,0,p);

help();

}

/***************************************************************************** Move up a line.

*****************************************************************************/ void upline(void)

{

register int i;

char *p;

if(curloc==buf)return;

p=curloc;

if(*p=='\r') p--;

for(;*p!='\r'&&p

if(*p=='\r')return;

curloc=p;

curloc--;

i=scrnx; /* save X coordinate */

/* find start of next line */

while(*curloc!='\r'&&curloc>buf) curloc--;

scrny--;

scrnx=0;

curloc++;

/* if at top of screen ,must stop */

if(scrny<0)

{

scrolldn(1,1);

scrny=0;

gotoxy(1,1);

printline(curloc);

}

while(i&&*curloc!='\r')

{

curloc++;

scrnx++;

i--;

}

}

/*************************************************************************** Move down one line,keep previous scrnx location if possible

**************************************************************************/ void downline(void)

{

register int i;

char *p;

i=scrnx;

p=curloc;

while(*p!='\r'&&p

if(p==endloc) return;

p++;

curloc=p;

scrny++;

scrnx=0;

if(scrny==MAX_LINES-1)

{

scrny=MAX_LINES-2;

scrollup(1,1,LINE_LEN,MAX_LINES-1);

gotoxy(scrnx+1,scrny+1);

printline(curloc);

}

while(i&& *curloc!='\r' && curloc

{

curloc++;

scrnx++;

i--;

}

}

/**************************************************************************** Display a screen full of text (up to 24 lines)

***************************************************************************/ void display_scrn(int x,int y,char *p)

{

register int i,j;

gotoxy(x+1,y+1);

textcolor(WHITE);

textbackground(BLUE);

i=0;

while(y

{

switch(*p)

{

case '\r': printf("\n");

y++;

gotoxy(1,y+1);

i=0;

break;

case '\x09':

for(j=0;j<8;j++)

{

printf(" ");

i++;

}

default:

if(i

i++;

}

p++;

}

}

/**************************************************************************** Page down MAX_LINES lines

*****************************************************************************/ void pagedown(void)

{

register int i;

clrscr();

for(i=0;i

{

if(*curloc=='\r') i++;

curloc++;

}

help();

scrnx=0;

scrny=0;

display_scrn(0,0,curloc);

}

/*************************************************************************** Page up MAX_LINES line

***************************************************************************/ void pageup(void)

{

register int i;

clrscr();

for(i=0;ibuf;)

{

if(*curloc=='\r') i++;

curloc--;

}

scrnx=scrny=0;

display_scrn(0,0,curloc);

help();

}

/************************************************************************** Go to the end of the file

**************************************************************************/ void gotoend(void)

{

int i;

char *p;

p=curloc;

for(i=scrnx;*p!='\r'&&p

{

scrnx++;

p++;

i++;

}

gotoxy(scrnx+1,scrny+1);

curloc=p;

}

/**************************************************************************** Load a file

****************************************************************************/ int load(char *fname)

{

FILE *fp;

char ch,*p;

int i;

draw_border(0,0,78,24,0x2f);

clrscr();

if((fp=fopen(fname,"rb"))==NULL) return 0;

gotoxy(1,1);

p=buf;

while(!feof(fp)&&p!=buf+BUF_SIZE-2)

{

ch=getc(fp);

if(ch=='\x09')

for(i=0;i<8;i++,p++) *p='\x20';

else if(ch!='\n'&&ch!=EOF)

{

*p=ch;

p++;

}

}

*p='\0';

fclose(fp);

curloc=endloc=p;

clrscr();

curloc=buf;

help();

scrnx=scrny=0;

display_scrn(0,0,curloc);

}

/****************************************************************************** ***

Go to top the file

******************************************************************************/ void home(void)

{

curloc-=scrnx;

scrnx=0;

gotoxy(scrnx+1,scrny);

}

/****************************************************************************** Save a file

*****************************************************************************/ int save(char *fname)

{

int i;

FILE *fp;

char *p,name[80];

if(!*fname)

{

clrline(MAX_LINES);

gotoxy(1,MAX_LINES);

printf("filename:");

gets(name);

}

else strcpy(name,fname);

if((fp=fopen(name,"wb"))==NULL) return 0;

p=buf;

while(p!=endloc)

{

if(*p!='\r')

putc(*p,fp);

else

{

putc('\r',fp);

putc('\n',fp);

}

p++;

}

fclose(fp);

clrline(MAX_LINES);

printf("file %s already saved.",name);

help();

return 1;

}

/****************************************************************************** Read a string from the keyboard

*****************************************************************************/ void edit_gets(char *str)

{

char *p;

p=str;

for(;;)

{

*str=getch();

if(*str=='\r')

{

*str='\0';

return;

}

if(*str=='\b')

{

if(str>p)

{

str--;

putch('\b');

putch(' ');

putch('\b');

}

}

else

{

putch(*str);

str++;

}

}

}

/****************************************************************************** *

Read and save cursor coordinates

******************************************************************************/ void cursor_pos(void)

{

union REGS i,o;

i.h.ah=3;

int86(16,&i,&o);

}

/****************************************************************************** **

Send cursor to specified X,Y(0,0 is upper left corner).

*****************************************************************************/ void gotoxy(int x,int y)

{

union REGS i;

i.h.dh=y;

i.h.dl=x;

i.h.ah=2;

i.h.bh=0;

int86(16,&i,&i);

}

/***************************************************************************** Clear entire line given its Y coordinate

*****************************************************************************/ void clrline(int y)

{

register int i;

gotoxy(1,y);

for(i=0;i

textcolor(WHITE);

textbackground(BLUE);

}

/**************************************************************************** Clear to end of specified line.

****************************************************************************/ void edit_clr_col(int x,int y)

{

char *p;

p=curloc;

gotoxy(x+1,y+1);

for(;x

{

printf(" ");

}

}

/**************************************************************************** Clear the screen.

****************************************************************************/ void clrscr(void)

{

union REGS r;

r.h.ah=6;

r.h.al=0;

r.h.ch=1;

r.h.cl=1;

r.h.dh=MAX_LINES-1;

r.h.dl=LINE_LEN;

r.h.bh=0x1f;

int86(0x10,&r,&r);

}

/*************************************************************************** Scroll down the screen.

***************************************************************************/ void scrolldn(int x,int y)

{

union REGS r;

r.h.ah=7;

r.h.al=1;

r.h.ch=y;

r.h.cl=x;

r.h.dh=MAX_LINES-1;

r.h.dl=LINE_LEN;

r.h.bh=0x1f;

int86(0x10,&r,&r);

}

/**************************************************************************** Srcoll up the screen.

****************************************************************************/ void scrollup(int topx,int topy,int endx,int endy)

{

union REGS r;

r.h.ah=6;

r.h.al=1;

r.h.ch=topy;

r.h.cl=topx;

r.h.dh=endy;

r.h.dl=endx;

r.h.bh=0x1f;

int86(0x10,&r,&r);

}

/**************************************************************************/ void draw_border(int beginx,int beginy,int endx,int endy,int attr)

{

int i;

union REGS r;

r.h.ah=6;

r.h.al=0;

r.h.ch=beginy;

r.h.cl=beginx;

r.h.dh=endy;

r.h.dl=endx+1;

r.h.bh=attr;

int86(0x10,&r,&r);

for(i=beginx;i

{ gotoxy(i,beginy);

putchar(196);

gotoxy(i,endy);

putchar(196);

}

for(i=beginy;i<=endy;i++)

{

gotoxy(beginx,i);

putchar(179);

gotoxy(endx,i);

putchar(179);

}

gotoxy(beginx,beginy);

putchar(218);

gotoxy(beginx,endy);

putchar(192);

gotoxy(endx,beginy);

putchar(191);

gotoxy(endx,endy);

putchar(217);

}