home *** CD-ROM | disk | FTP | other *** search
/ CP/M / CPM_CDROM.iso / simtel / sigm / vols000 / vol076 / ed3.c < prev    next >
Text File  |  1985-02-09  |  16KB  |  846 lines
  1. /* ED3.C */
  2.  
  3. #include ed0.c
  4. #include ed1.ccc
  5. int readfile = -1;    /* separate read and write files */
  6. int writefile = -1;    /* -1 for inactive, file channel no. for active */
  7. char rfilename[SYSFNMAX];    /* file names */
  8. char wfilename[SYSFNMAX];
  9. char databuf[MAXLEN1];        /* single buffer replaces redundant buffers */
  10. fileclear()        /* initializes filenames to zero length */
  11. {
  12.     rfilename[0] = EOS;
  13.     wfilename[0] = EOS;
  14. }
  15. append(args) char *args;
  16. {
  17. int file;
  18. int n;
  19. int topline;
  20. char locfn[SYSFNMAX];
  21.     if (name1(args,locfn)==ERR) {
  22.         return;
  23.     }
  24.     if (locfn[0]==EOS) {
  25.         message("no file argument");
  26.         return;
  27.     }
  28.     if ((file=sysopen(locfn,"r"))==ERR) {
  29.         message("file not found");
  30.         return;
  31.     }
  32.     while ((n=readline(file,databuf,MAXLEN))>=0) {
  33.         if (n>MAXLEN) {
  34.             message("line truncated");
  35.             n=MAXLEN;
  36.         }
  37.         if (bufins(databuf,n)==ERR) {
  38.             break;
  39.         }
  40.         if (bufdn()==ERR) {
  41.             break;
  42.         }
  43.     }
  44.     sysclose(file);
  45.     topline=max(1,bufln()-SCRNL2);
  46.     bufout(topline,2,SCRNL2);
  47.     bufgo(topline);
  48. }
  49. change(args) char *args;
  50. {
  51. char oldline[MAXLEN1];
  52. char newline[MAXLEN1];
  53. char oldpat[MAXLEN1];
  54. char newpat[MAXLEN1];
  55. int from, to, col, n, k;
  56.     if (get2args(args,&from,&to)==ERR) {
  57.         return;
  58.     }
  59.     fmtsout("search mask ?    ",0);
  60.     getcmnd(oldpat,15);
  61.     fmtcrlf();
  62.     if(oldpat[0]==EOS) {
  63.         return;
  64.     }
  65.     pmtline();
  66.     fmtsout("change mask ?    ",0);
  67.     getcmnd(newpat,15);
  68.     fmtcrlf();
  69.     while (from<=to) {
  70.         if (chkkey()==YES) {
  71.             break;
  72.         }
  73.         if (bufgo(from++)==ERR) {
  74.             break;
  75.         }
  76.         if (bufatbot()==YES) {
  77.             break;
  78.         }
  79.         n=bufgetln(oldline,MAXLEN);
  80.         n=min(n,MAXLEN);
  81.         oldline[n]=EOS;
  82.         if (oldpat[0]=='^') {
  83.             if (amatch(oldline,oldpat+1,0)==YES) {
  84.                 k=replace(oldline,newline,
  85.                     oldpat+1,newpat,0);
  86.                 if (k==ERR) {
  87.                     return;
  88.                 }
  89.                 fmtcrlf();
  90.                 putdec(bufln(),5);
  91.                 fmtsout(newline,5);
  92.                 outdeol();
  93.                 bufrepl(newline,k);
  94.             }
  95.             continue;
  96.         }
  97.         col=0;
  98.         while (col<n) {
  99.             if (amatch(oldline,oldpat,col++)==YES) {
  100.                 k=replace(oldline,newline,
  101.                     oldpat,newpat,col-1);
  102.                 if (k==ERR) {
  103.                     return;
  104.                 }
  105.                 fmtcrlf();
  106.                 putdec(bufln(),5);
  107.                 fmtsout(newline,5);
  108.                 outdeol();
  109.                 bufrepl(newline,k);
  110.                 break;
  111.             }
  112.         }
  113.     }
  114.     fmtcrlf();
  115. }
  116. clear()
  117. {
  118.     if (chkbuf()==YES) {
  119.         outclr();
  120.         outxy(0,SCRNL1);
  121.         bufnew();
  122.         message("buffer cleared");
  123.         return(YES);
  124.     }
  125.     else{
  126.         return(NO);
  127.     }
  128. }
  129. delete(args) char *args;
  130. {
  131. int from, to;
  132.     if(get2args(args,&from,&to)==ERR) {
  133.         return;
  134.     }
  135.     if (from>to) {
  136.         return;
  137.     }
  138.     if (bufgo(from)==ERR) {
  139.         return;
  140.     }
  141.     if (bufndel(to-from+1)==ERR) {
  142.         return;
  143.     }
  144.     bufout(bufln(),1,SCRNL1);
  145. }
  146. find()
  147. {
  148.     return(suurch(bufln()+1,HUGE,YES));
  149. }
  150. list(args) char *args;
  151. {
  152. int n;
  153. int from, to, line, oldline;
  154.     oldline=bufln();
  155.     if (get2args(args,&from,&to)==ERR) {
  156.         return;
  157.     }
  158.     line=from;
  159.     while (line<=to) {
  160.         fmtassn(NO);
  161.         if (chkkey()==YES) {
  162.             break;
  163.         }
  164.         fmtassn(YES);
  165.         if (bufgo(line++)!=OK) {
  166.             break;
  167.         }
  168.         if (bufatbot()) {
  169.             break;
  170.         }
  171.         n=bufgetln(databuf,MAXLEN1);
  172.         n=min(n,MAXLEN);
  173.         databuf[n]=CR;
  174.         fmtsout(databuf,0);
  175.         fmtcrlf();
  176.     }
  177.     fmtassn(NO);
  178.     bufgo(oldline);
  179. }
  180. extract(args) char *args;    /* write indicated line range to file */
  181. {
  182. char args1[SCRNW1];
  183. char *argp;
  184. int file;
  185. char locfn[SYSFNMAX];
  186. int oldline, from, to, n;
  187.     oldline = bufln();
  188.     if (get2args(args,&from,&to)==ERR) {    /* from and to are line range */
  189.         return;
  190.     }
  191.     message("enter file name");    /* request the file name */
  192.     getcmnd(args1,0);
  193.     argp=skipbl(args1);
  194.     if (syschkfn(argp)==ERR) {
  195.         return;
  196.     }
  197.     syscopfn(argp,locfn);
  198.     if (locfn[0]==EOS) {
  199.         message("no file argument");
  200.         return;
  201.     }
  202.     if ((file=sysopen(locfn,"w"))==ERR){
  203.         return;
  204.     }
  205.     if (bufgo(from)==ERR){
  206.         sysclose(file);
  207.         return;
  208.     }
  209.     while ((bufatbot()==NO)&(bufln()<=to)) {    /* do the writing */
  210.         n=bufgetln(databuf,MAXLEN);
  211.         n=min(n,MAXLEN);
  212.         if (pushline(file,databuf,n)==ERR){
  213.             break;
  214.         }
  215.         if (bufdn()==ERR) {
  216.             break;
  217.         }
  218.     }
  219.     bufgo(oldline);
  220.     sysclose(file);     /* close the file */
  221. }
  222. open (args) char *args;
  223. {
  224. /* open a file for reading */
  225. char locfn [SYSFNMAX];
  226. int n;
  227. int file;
  228. int topline;
  229.     if (readfile > 0) {        /* check for open readfile */
  230.         message("read file still open");
  231.         return;
  232.     }
  233.     if (name1(args,locfn)==ERR) {
  234.         return;
  235.     }
  236.     if (locfn[0]==EOS) {
  237.         message("no file argument");
  238.         return;
  239.     }
  240.     if (chkbuf()==NO) {
  241.         return;
  242.     }
  243.     if ((file=sysopen(locfn,"r"))==ERR) {
  244.         message("file not found");
  245.         return;
  246.     }
  247.     syscopfn(locfn, rfilename);    /* make the file name the readfile */
  248.     readfile = file;
  249.     pmtrfile(rfilename);
  250.     bufnew();
  251. }
  252. getit (args) char *args;    /* new: add n lines to buffer if room */
  253. {
  254. int n;
  255. int topline;
  256. int nlines,npoint;
  257.     if (readfile == -1) {
  258.         message ("no read file");
  259.         return;
  260.     }
  261.     pmtrfile(rfilename);
  262.     if (getarg(args,&nlines)==ERR) {
  263.         return;
  264.     }
  265.     if (nlines<1) {
  266.         return;
  267.     }
  268.     if (bufgo(HUGE)==ERR) {
  269.         return;
  270.     }
  271.     npoint=1;
  272.     while (npoint<=nlines) {    /* add the lines */
  273.         npoint++;
  274.         if ((n=readline(readfile,databuf,MAXLEN))>=0) {
  275.             if (n>MAXLEN) {
  276.                 message("line truncated");
  277.                 n=MAXLEN;
  278.             }
  279.             if (buf1ins(databuf,n)==ERR) {
  280.                 bufgo(1);
  281.                 topline=max(1,bufln()-SCRNL2);
  282.                 bufout(topline,2,SCRNL2);
  283.                 bufgo(topline);
  284.                 return;
  285.             }
  286.             if (bufdn()==ERR) {
  287.                 break;
  288.             }
  289.         }
  290.         else {
  291.             npoint = HUGE;       /* reached end of file - close it */
  292.             sysclose(readfile);
  293.             readfile = -1;
  294.             rfilename[0] = EOS;
  295.             pmtrfile(rfilename);
  296.         }
  297.     }
  298.     bufgo(1);
  299.     topline=max(1,bufln()-SCRNL2);
  300.     bufout(topline,2,SCRNL2);
  301.     bufgo(topline);
  302. }
  303. rest (args) char *args; /* new: try to read rest of readfile into buffer */
  304. {
  305. int n;
  306. int topline;
  307.     if (readfile == -1) {
  308.         message ("no read file");
  309.         return;
  310.     }
  311.     pmtrfile(rfilename);
  312. /* if buffer has been changed and not saved, give option of clearing, */
  313. /* otherwise add to end of buffer */
  314.     if(bufchng()==YES) {
  315.         fmtsout("buffer not saved. clear? ",0);
  316.         pmtline();
  317.         if (tolower(syscout(syscin()))=='y'){
  318.             outclr();
  319.             outxy(0,SCRNL1);
  320.             bufnew();
  321.             message("buffer cleared");
  322.         }
  323.         else {
  324.             bufgo(HUGE);
  325.         }
  326.     }
  327.     else{
  328.         outclr();
  329.         outxy(0,SCRNL1);
  330.         bufnew();
  331.         message("buffer cleared");
  332.  
  333.     }
  334.     while ((n=readline(readfile,databuf,MAXLEN))>=0) {
  335.         if (n>MAXLEN) {
  336.             message("line truncated");
  337.             n=MAXLEN;
  338.         }
  339.         if (buf1ins(databuf,n)==ERR) {
  340.             bufgo(1);
  341.             topline=max(1,bufln()-SCRNL2);
  342.             bufout(topline,2,SCRNL2);
  343.             bufgo(topline);
  344.             return;
  345.         }
  346.         if (bufdn()==ERR) {
  347.             break;
  348.         }
  349.     }
  350.     sysclose(readfile);    /* close file if all read */
  351.     readfile = -1;
  352.     rfilename[0] = EOS;
  353.     pmtrfile(rfilename);
  354.     bufgo(1);
  355.     topline=max(1,bufln()-SCRNL2);
  356.     bufout(topline,2,SCRNL2);
  357.     bufgo(topline);
  358. }
  359. rename(args) char *args;    /* new: change name of writefile */
  360. {
  361.     if (writefile == -1) {
  362.         message("no write file - call name");
  363.         return;
  364.     }
  365.     sysclose(writefile);
  366.     writefile = -1;
  367.     wfilename[0]=EOS;
  368.     pmtwfile(wfilename);
  369.     if (name0(args,wfilename)==ERR) {
  370.         return;
  371.     }
  372.     pmtwfile(wfilename);
  373. }
  374. name(args) char *args;        /* altered definition: name the writefile */
  375. {
  376.     if (writefile > 0) {
  377.         message("write file open");
  378.         return;
  379.     }
  380.     if (name0(args,wfilename)==ERR){
  381.         return;
  382.     }
  383.     pmtwfile(wfilename);
  384. }
  385. name0(args,wfilename) char *args, *wfilename;    /* names new writefile */
  386. {
  387. int file;
  388.     args=skiparg(args);
  389.     args=skipbl(args);
  390.     if (syschkfn(args)==ERR) {
  391.         return(ERR);
  392.     }
  393.     syscopfn(args,wfilename);
  394.     if ((file=sysopen(wfilename,"r"))!=ERR) {
  395.         sysclose(file);
  396.         message("disk file exists");
  397.         return(ERR);
  398.     }
  399.     if ((file=sysopen(wfilename,"w"))==ERR) {
  400.         return(ERR);
  401.     }
  402.     writefile = file;
  403.     return(OK);
  404. }
  405. delname(args) char *args;    /* new: similar to old resave command, */
  406. {                /* but doesn't automatically write file */
  407.     if (writefile > 0) {
  408.         message("write file open");
  409.         return;
  410.     }
  411.     if (name2(args,wfilename)==ERR){
  412.         return;
  413.     }
  414.     pmtwfile(wfilename);
  415. }
  416. name2(args,wfilename) char *args, *wfilename;    /* open writefile: no error */
  417. {                        /* file exists */
  418. int file;
  419.     args=skiparg(args);
  420.     args=skipbl(args);
  421.     if (syschkfn(args)==ERR) {
  422.         return(ERR);
  423.     }
  424.     syscopfn(args,wfilename);
  425.     if ((file=sysopen(wfilename,"w"))==ERR) {
  426.         return(ERR);
  427.     }
  428.     writefile = file;
  429.     return(OK);
  430. }
  431. name1(args,filename) char *args, *filename;
  432. {
  433.     args=skiparg(args);
  434.     args=skipbl(args);
  435.     if (syschkfn(args)==ERR) {
  436.         return(ERR);
  437.     }
  438.     syscopfn(args,filename);
  439.     return(OK);
  440. }
  441. writel(args) char *args;    /* new: write first n lines of buffer to */
  442. {                /* writefile and delete from buffer */
  443. int n, to;
  444.     if (writefile == -1) {
  445.         message("file not opened");
  446.         return;
  447.     }
  448.     if (getarg(args,&to)==ERR) {
  449.         return;
  450.     }
  451.     if (bufgo(1)==ERR) {
  452.         sysclose(writefile);
  453.         writefile = -1;
  454.         wfilename[0] = EOS;
  455.         pmtwfile(wfilename);
  456.         return;
  457.     }
  458.     while ((bufatbot()==NO)&(bufln()<=to)) {
  459.         n=bufgetln(databuf,MAXLEN);
  460.         n=min(n,MAXLEN);
  461.         if (pushline(writefile,databuf,n)==ERR) {
  462.             return;
  463.         }
  464.         if (bufdn()==ERR) {
  465.             return;
  466.         }
  467.     }
  468.     if (bufgo(1)==ERR) {
  469.         return;
  470.     }
  471.     if (bufndel(to)==ERR){
  472.         return;
  473.     }
  474.     bufout(bufln(),1,SCRNL1);
  475.     if (bufatbot()) {
  476.         bufsaved();
  477.     }
  478.     bufgo(1);
  479. }
  480. save()
  481. {
  482. int n, oldline;
  483.     if (writefile == -1) {             /* changed to writefile */
  484.         message("file not opened");     /* file assumed already open */
  485.         return;
  486.     }
  487.     oldline=bufln();
  488.     if (bufgo(1)==ERR) {
  489.         sysclose(writefile);    /* close the writefile if error */
  490.         writefile = -1;
  491.         wfilename[0]=EOS;
  492.         pmtwfile(wfilename);
  493.         return;
  494.     }
  495.     while (bufatbot()==NO) {
  496.         n=bufgetln(databuf,MAXLEN);
  497.         n=min(n,MAXLEN);
  498.         if (pushline(writefile,databuf,n)==ERR) {
  499.             break;
  500.         }
  501.         if (bufdn()==ERR) {
  502.             break;
  503.         }
  504.     }
  505.     if (bufatbot()) {
  506.         bufsaved();
  507.     }
  508.     bufgo(oldline);
  509.                     /* writefile no longer closed */
  510. }
  511. closeread()                /* new: close the readfile */
  512. {
  513.     if (readfile!= -1) {
  514.         sysclose(readfile);
  515.         readfile= -1;
  516.         rfilename[0]=EOS;
  517.         pmtrfile(rfilename);
  518.     }
  519. }
  520. closewrite()                /* new: close the writefile */
  521. {
  522.     if (writefile != -1) {
  523.         sysclose(writefile);
  524.         writefile= -1;
  525.         wfilename[0]=EOS;
  526.         pmtwfile(wfilename);
  527.     }
  528. }
  529. search (args) char *args;
  530. {
  531. int from, to;
  532.     if (get2args(args,&from,&to)==ERR) {
  533.         return;
  534.     }
  535.     suurch(from,to,NO);
  536. }
  537. suurch(from,to,flag) int from, to, flag;   /* old "search1" */
  538. {
  539.                     /* now uses module buffer */
  540. char pat [MAXLEN1];
  541. int col, n;
  542.     fmtsout("search mask ?    ",0);
  543.     getcmnd(pat,15);
  544.     fmtcrlf();
  545.     if (pat[0]==EOS) {
  546.         return (-1);
  547.     }
  548.     while (from<=to) {
  549.         if (chkkey()==YES) {
  550.             break;
  551.         }
  552.         if (bufgo(from++)==ERR) {
  553.             break;
  554.         }
  555.         if (bufatbot()==YES) {
  556.             break;
  557.         }
  558.         n=bufgetln(databuf,MAXLEN);
  559.         n=min(n,MAXLEN);
  560.         databuf[n]=EOS;
  561.         if (pat[0]=='^') {
  562.             if (amatch(databuf,pat+1,0)==YES) {
  563.                 if (flag==NO) {
  564.                     fmtcrlf();
  565.                     putdec(bufln(),5);
  566.                     fmtsout(databuf,5);
  567.                     outdeol();
  568.                 }
  569.                 else {
  570.                     return(0);
  571.                 }
  572.             }
  573.             continue;
  574.         }
  575.         col=0;
  576.         while (col<n) {
  577.             if (amatch(databuf,pat,col++)==YES) {
  578.                 if (flag==NO) {
  579.                     fmtcrlf();
  580.                     putdec(bufln(),5);
  581.                     fmtsout(databuf,5);
  582.                     outdeol();
  583.                     break;
  584.                 }
  585.                 else {
  586.                     return(col-1);
  587.                 }
  588.             }
  589.         }
  590.     }
  591.     if (flag==YES) {
  592.         return(-1);
  593.     }
  594.     else {
  595.         fmtcrlf();
  596.     }
  597. }
  598. tabs(args) char *args;
  599. {
  600. int n,junk;
  601.     if (get2args(args,&n,&junk)==ERR) {
  602.         return;
  603.     }
  604.     fmtset(n);
  605. }
  606. chkbuf()
  607. {
  608.     if (bufchng()==NO) {
  609.         return(YES);
  610.     }
  611.     fmtsout("Buffer not saved.  Proceed  ? ",0);
  612.     pmtline();
  613.     if (tolower(syscout(syscin()))!='y') {
  614.         fmtcrlf();
  615.         message("cancelled");
  616.         return(NO);
  617.     }
  618.     else {
  619.         fmtcrlf();
  620.         return(YES);
  621.     }
  622. }
  623. message(s) char *s;
  624. {
  625.         fmtsout(s,0);
  626.         fmtcrlf();
  627. }
  628. getarg(args,val) char *args; int *val;    /* new: get a single argument */
  629. {
  630.     args=skiparg(args);
  631.     args=skipbl(args);
  632.     if (*args==EOS) {
  633.         *val=1;
  634.         return(ERR);
  635.     }
  636.     if (number(args,val)==NO) {
  637.         message("bad argument");
  638.         return(ERR);
  639.     }
  640.     return(OK);
  641. }
  642. /* new: get three arguments                        */
  643. get3args(args,val1,val2,val3) char *args; int *val1, *val2,*val3;
  644. {
  645.     args=skiparg(args);
  646.     args=skipbl(args);
  647.     if (*args==EOS) {
  648.         return(ERR);
  649.     }
  650.     if (number(args,val1)==NO) {
  651.         message("bad argument");
  652.         return(ERR);
  653.     }
  654.     args=skiparg(args);
  655.     args=skipbl(args);
  656.     if(*args==EOS) {
  657.         return(ERR);
  658.     }
  659.     if (number(args,val2)==NO) {
  660.         message("bad argument");
  661.         return(ERR);
  662.     }
  663.     args=skiparg(args);
  664.     args=skipbl(args);
  665.     if(*args==EOS) {
  666.         return(ERR);
  667.     }
  668.     if (number(args,val3)==NO) {
  669.         message("bad argument");
  670.         return(ERR);
  671.     }
  672.     else {
  673.         return(OK);
  674.     }
  675. }
  676. get2args(args,val1,val2) char *args; int *val1, *val2;
  677. {
  678.     args=skiparg(args);
  679.     args=skipbl(args);
  680.     if (*args==EOS) {
  681.         *val1=1;
  682.         *val2=HUGE;
  683.         return(OK);
  684.     }
  685.     if (number(args,val1)==NO) {
  686.         message("bad argument");
  687.         return(ERR);
  688.     }
  689.     args=skiparg(args);
  690.     args=skipbl(args);
  691.     if(*args==EOS) {
  692.         *val2=HUGE;
  693.         return(OK);
  694.     }
  695.     if (number(args,val2)==NO) {
  696.         message("bad argument");
  697.         return(ERR);
  698.     }
  699.     else {
  700.         return(OK);
  701.     }
  702. }
  703. skiparg(args) char *args;
  704. {
  705.     while ((*args!=EOS)&(*args!=' ')) {
  706.         args++;
  707.     }
  708.     return(args);
  709. }
  710. skipbl(args) char *args;
  711. {
  712.     while(*args==' ') {
  713.         args++;
  714.     }
  715.     return(args);
  716. }
  717. chkkey()
  718. {
  719. int c;
  720.     c=syscstat();
  721.     if (c==-1) {        /* note correction from original version */
  722.         return(NO);
  723.     }
  724.     else if (c==' ') {
  725.         pmtline();
  726.         if (syscin()==' ') {
  727.             return(NO);
  728.         }
  729.     }
  730.     return(YES);
  731. }
  732. amatch(line,pat,col) char *line, *pat; int col;
  733. {
  734. int k;
  735.     k=0;
  736.     while (pat[k]!=EOS) {
  737.         if (pat[k]==line[col]) {
  738.             k++;
  739.             col++;
  740.         }
  741.         else if ((pat[k]=='?')&(line[col]!=EOS)) {
  742.             k++;
  743.             col++;
  744.         }
  745.         else {
  746.             return(NO);
  747.         }
  748.     }
  749.     return(YES);
  750. }
  751. replace(oldline,newline,oldpat,newpat,col)
  752. char *oldline, *newline, *oldpat, *newpat; int col;
  753. {
  754. int k;
  755. char *tail, *pat;
  756.     k=0;
  757.     while (k<col) {
  758.         newline[k++]= *oldline++;
  759.     }
  760.     tail=oldline;
  761.     pat=oldpat;
  762.     while (*pat++!=EOS) {
  763.         tail++;
  764.     }
  765.     while (*newpat!=EOS) {
  766.         if (k>MAXLEN-1) {
  767.             message("new line too long");
  768.             return(ERR);
  769.         }
  770.         if (*newpat!='?') {
  771.             newline[k++]= *newpat++;
  772.             continue;
  773.         }
  774.         while (*oldpat!='?') {
  775.             if (*oldpat==EOS) {
  776.                 message(
  777.                 "too many ?'s in change mask"
  778.                 );
  779.                 return(ERR);
  780.             }
  781.             oldpat++;
  782.             oldline++;
  783.         }
  784.         newline[k++]= *oldline++;
  785.         oldpat++;
  786.         newpat++;
  787.     }
  788.     while (*tail!=EOS) {
  789.         if (k>MAXLEN-1) {
  790.             message("new line too long");
  791.             return(ERR);
  792.         }
  793.         newline[k++]= *tail++;
  794.     }
  795.     newline[k]=EOS;
  796.     return(k);
  797. }
  798. copyit (args) char *args;    /* new: copies "lenn" lines from "from"   */
  799. {                /* to "to" */
  800. int from,to,lenn;
  801. int topline;
  802.     if (get3args(args,&from,&to,&lenn)==ERR) {
  803.         return;
  804.     }
  805.     if (to == from) {
  806.         return;
  807.     }
  808.     if ((to>from)&(to<=(from+lenn))) {
  809.         message("interleaving not permitted");
  810.         return;
  811.     }
  812.     bufcopy(from,to,lenn);
  813.     bufgo(1);
  814.     topline=max(1,bufln()-SCRNL2);
  815.     bufout(topline,2,SCRNL2);
  816.     bufgo(topline);
  817. }
  818. moveit (args) char *args;    /* new: moves "lenn" lines from "from" */
  819. {                /* to "to" - same as copyit except deletes */
  820. int from,to,lenn;        /* old lines */
  821. int topline;
  822.     if (get3args(args,&from,&to,&lenn)==ERR) {
  823.         return;
  824.     }
  825.     if (to == from) {
  826.         return;
  827.     }
  828.     if ((to>from)&(to<=(from+lenn))) {
  829.         message("interleaving not permitted");
  830.         return;
  831.     }
  832.     bufcopy(from,to,lenn);
  833.     if (to>from){
  834.         bufgo(from);
  835.         bufndel(lenn);
  836.     }
  837.     else {
  838.         bufgo(from+lenn);
  839.         bufndel(lenn);
  840.     }
  841.     bufgo(1);
  842.     topline=max(1,bufln()-SCRNL2);
  843.     bufout(topline,2,SCRNL2);
  844.     bufgo(topline);
  845. }
  846.