home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / newemacs / region.c < prev    next >
C/C++ Source or Header  |  1986-02-04  |  5KB  |  200 lines
  1. /*
  2.  * The routines in this file
  3.  * deal with the region, that magic space
  4.  * between "." and mark. Some functions are
  5.  * commands. Some functions are just for
  6.  * internal use.
  7.  */
  8. #include    <stdio.h>
  9. #include    "ed.h"
  10.  
  11. /*
  12.  * Kill the region. Ask "getregion"
  13.  * to figure out the bounds of the region.
  14.  * Move "." to the start, and kill the characters.
  15.  * Bound to "C-W".
  16.  */
  17. killregion(f, n)
  18. {
  19.     register int    s;
  20.     REGION        region;
  21.  
  22.     if ((s=getregion(®ion)) != TRUE)
  23.         return (s);
  24.     if ((lastflag&CFKILL) == 0)        /* This is a kill type    */
  25.         kdelete();            /* command, so do magic    */
  26.     thisflag |= CFKILL;            /* kill buffer stuff.    */
  27.     curwp->w_dotp = region.r_linep;
  28.     curwp->w_doto = region.r_offset;
  29.     return (ldelete(region.r_size, TRUE));
  30. }
  31.  
  32. /*
  33.  * Copy all of the characters in the
  34.  * region to the kill buffer. Don't move dot
  35.  * at all. This is a bit like a kill region followed
  36.  * by a yank. Bound to "M-W".
  37.  */
  38. copyregion(f, n)
  39. {
  40.     register LINE    *linep;
  41.     register int    loffs;
  42.     register int    s;
  43.     REGION        region;
  44.  
  45.     if ((s=getregion(®ion)) != TRUE)
  46.         return (s);
  47.     if ((lastflag&CFKILL) == 0)        /* Kill type command.    */
  48.         kdelete();
  49.     thisflag |= CFKILL;
  50.     linep = region.r_linep;            /* Current line.    */
  51.     loffs = region.r_offset;        /* Current offset.    */
  52.     while (region.r_size--) {
  53.         if (loffs == llength(linep)) {    /* End of line.        */
  54.             if ((s=kinsert('\n')) != TRUE)
  55.                 return (s);
  56.             linep = lforw(linep);
  57.             loffs = 0;
  58.         } else {            /* Middle of line.    */
  59.             if ((s=kinsert(lgetc(linep, loffs))) != TRUE)
  60.                 return (s);
  61.             ++loffs;
  62.         }
  63.     }
  64.     return (TRUE);
  65. }
  66.  
  67. /*
  68.  * Lower case region. Zap all of the upper
  69.  * case characters in the region to lower case. Use
  70.  * the region code to set the limits. Scan the buffer,
  71.  * doing the changes. Call "lchange" to ensure that
  72.  * redisplay is done in all buffers. Bound to 
  73.  * "C-X C-L".
  74.  */
  75. lowerregion(f, n)
  76. {
  77.     register LINE    *linep;
  78.     register int    loffs;
  79.     register int    c;
  80.     register int    s;
  81.     REGION        region;
  82.  
  83.     if ((s=getregion(®ion)) != TRUE)
  84.         return (s);
  85.     lchange(WFHARD);
  86.     linep = region.r_linep;
  87.     loffs = region.r_offset;
  88.     while (region.r_size--) {
  89.         if (loffs == llength(linep)) {
  90.             linep = lforw(linep);
  91.             loffs = 0;
  92.         } else {
  93.             c = lgetc(linep, loffs);
  94.             if (c>='A' && c<='Z')
  95.                 lputc(linep, loffs, c+'a'-'A');
  96.             ++loffs;
  97.         }
  98.     }
  99.     return (TRUE);
  100. }
  101.  
  102. /*
  103.  * Upper case region. Zap all of the lower
  104.  * case characters in the region to upper case. Use
  105.  * the region code to set the limits. Scan the buffer,
  106.  * doing the changes. Call "lchange" to ensure that
  107.  * redisplay is done in all buffers. Bound to 
  108.  * "C-X C-L".
  109.  */
  110. upperregion(f, n)
  111. {
  112.     register LINE    *linep;
  113.     register int    loffs;
  114.     register int    c;
  115.     register int    s;
  116.     REGION        region;
  117.  
  118.     if ((s=getregion(®ion)) != TRUE)
  119.         return (s);
  120.     lchange(WFHARD);
  121.     linep = region.r_linep;
  122.     loffs = region.r_offset;
  123.     while (region.r_size--) {
  124.         if (loffs == llength(linep)) {
  125.             linep = lforw(linep);
  126.             loffs = 0;
  127.         } else {
  128.             c = lgetc(linep, loffs);
  129.             if (c>='a' && c<='z')
  130.                 lputc(linep, loffs, c-'a'+'A');
  131.             ++loffs;
  132.         }
  133.     }
  134.     return (TRUE);
  135. }
  136.  
  137. /*
  138.  * This routine figures out the
  139.  * bounds of the region in the current window, and
  140.  * fills in the fields of the "REGION" structure pointed
  141.  * to by "rp". Because the dot and mark are usually very
  142.  * close together, we scan outward from dot looking for
  143.  * mark. This should save time. Return a standard code.
  144.  * Callers of this routine should be prepared to get
  145.  * an "ABORT" status; we might make this have the
  146.  * conform thing later.
  147.  */
  148. getregion(rp)
  149. register REGION    *rp;
  150. {
  151.     register LINE    *flp;
  152.     register LINE    *blp;
  153.     register int    fsize;
  154.     register int    bsize;
  155.  
  156.     if (curwp->w_markp == NULL) {
  157.         mlwrite("No mark set in this window");
  158.         return (FALSE);
  159.     }
  160.     if (curwp->w_dotp == curwp->w_markp) {
  161.         rp->r_linep = curwp->w_dotp;
  162.         if (curwp->w_doto < curwp->w_marko) {
  163.             rp->r_offset = curwp->w_doto;
  164.             rp->r_size = curwp->w_marko-curwp->w_doto;
  165.         } else {
  166.             rp->r_offset = curwp->w_marko;
  167.             rp->r_size = curwp->w_doto-curwp->w_marko;
  168.         }
  169.         return (TRUE);
  170.     }
  171.     blp = curwp->w_dotp;
  172.     bsize = curwp->w_doto;
  173.     flp = curwp->w_dotp;
  174.     fsize = llength(flp)-curwp->w_doto+1;
  175.     while (flp!=curbp->b_linep || lback(blp)!=curbp->b_linep) {
  176.         if (flp != curbp->b_linep) {
  177.             flp = lforw(flp);
  178.             if (flp == curwp->w_markp) {
  179.                 rp->r_linep = curwp->w_dotp;
  180.                 rp->r_offset = curwp->w_doto;
  181.                 rp->r_size = fsize+curwp->w_marko;
  182.                 return (TRUE);
  183.             }
  184.             fsize += llength(flp)+1;
  185.         }
  186.         if (lback(blp) != curbp->b_linep) {
  187.             blp = lback(blp);
  188.             bsize += llength(blp)+1;
  189.             if (blp == curwp->w_markp) {
  190.                 rp->r_linep = blp;
  191.                 rp->r_offset = curwp->w_marko;
  192.                 rp->r_size = bsize - curwp->w_marko;
  193.                 return (TRUE);
  194.             }
  195.         }
  196.     }
  197.     mlwrite("Bug: lost mark");
  198.     return (FALSE);
  199. }
  200.