[BACK]Return to line.c CVS log [TXT][DIR] Up to [local] / src / usr.bin / mg

Diff for /src/usr.bin/mg/line.c between version 1.21 and 1.22

version 1.21, 2004/07/09 13:50:40 version 1.22, 2005/04/03 02:09:28
Line 28 
Line 28 
 #endif  #endif
   
 #ifndef NBLOCK  #ifndef NBLOCK
 #define NBLOCK  16              /* Line block chunk size         */  #define NBLOCK  16              /* Line block chunk size.        */
 #endif  #endif
   
 #ifndef KBLOCK  #ifndef KBLOCK
Line 51 
Line 51 
 {  {
         LINE *lp;          LINE *lp;
   
         if ((lp = malloc(sizeof *lp)) == NULL)          if ((lp = malloc(sizeof(*lp))) == NULL)
                 return NULL;                  return (NULL);
         lp->l_text = NULL;          lp->l_text = NULL;
         lp->l_size = 0;          lp->l_size = 0;
         lp->l_used = used;      /* XXX */          lp->l_used = used;      /* XXX */
         if (lrealloc(lp, used) == FALSE) {          if (lrealloc(lp, used) == FALSE) {
                 free(lp);                  free(lp);
                 return NULL;                  return (NULL);
         }          }
         return lp;          return (lp);
 }  }
   
 int  int
Line 70 
Line 70 
   
         if (lp->l_size < newsize) {          if (lp->l_size < newsize) {
                 if ((tmp = realloc(lp->l_text, newsize)) == NULL)                  if ((tmp = realloc(lp->l_text, newsize)) == NULL)
                         return FALSE;                          return (FALSE);
                 lp->l_text = tmp;                  lp->l_text = tmp;
                 lp->l_size = newsize;                  lp->l_size = newsize;
         }          }
           return (TRUE);
         return TRUE;  
 }  }
   
 /*  /*
Line 159 
Line 158 
 int  int
 linsert_str(const char *s, int n)  linsert_str(const char *s, int n)
 {  {
         LINE *lp1;          LINE    *lp1;
         MGWIN   *wp;          MGWIN   *wp;
         RSIZE    i;          RSIZE    i;
         int      doto;          int      doto;
   
         if (curbp->b_flag & BFREADONLY) {          if (curbp->b_flag & BFREADONLY) {
                 ewprintf("Buffer is read only");                  ewprintf("Buffer is read only");
                 return FALSE;                  return (FALSE);
         }          }
   
         if (!n)          if (!n)
Line 186 
Line 185 
                         panic("bug: linsert_str");                          panic("bug: linsert_str");
                 /* allocate a new line */                  /* allocate a new line */
                 if ((lp2 = lalloc(n)) == NULL)                  if ((lp2 = lalloc(n)) == NULL)
                         return FALSE;                          return (FALSE);
                 /* previous line */                  /* previous line */
                 lp3 = lp1->l_bp;                  lp3 = lp1->l_bp;
                 /* link in */                  /* link in */
Line 206 
Line 205 
                 }                  }
                 undo_add_insert(lp2, 0, n);                  undo_add_insert(lp2, 0, n);
                 curwp->w_doto = n;                  curwp->w_doto = n;
                 return TRUE;                  return (TRUE);
         }          }
         /* save for later */          /* save for later */
         doto = curwp->w_doto;          doto = curwp->w_doto;
   
         if ((lp1->l_used + n) > lp1->l_size) {          if ((lp1->l_used + n) > lp1->l_size) {
                 if (lrealloc(lp1, lp1->l_used + n) == FALSE)                  if (lrealloc(lp1, lp1->l_used + n) == FALSE)
                         return FALSE;                          return (FALSE);
         }          }
         lp1->l_used += n;          lp1->l_used += n;
         if (lp1->l_used != n)          if (lp1->l_used != n)
Line 234 
Line 233 
                 }                  }
         }          }
         undo_add_insert(curwp->w_dotp, doto, n);          undo_add_insert(curwp->w_dotp, doto, n);
         return TRUE;          return (TRUE);
 }  }
   
 /*  /*
Line 249 
Line 248 
 int  int
 linsert(int n, int c)  linsert(int n, int c)
 {  {
         LINE *lp1;          LINE    *lp1;
         MGWIN   *wp;          MGWIN   *wp;
         RSIZE    i;          RSIZE    i;
         int      doto;          int      doto;
Line 259 
Line 258 
   
         if (curbp->b_flag & BFREADONLY) {          if (curbp->b_flag & BFREADONLY) {
                 ewprintf("Buffer is read only");                  ewprintf("Buffer is read only");
                 return FALSE;                  return (FALSE);
         }          }
   
         lchange(WFEDIT);          lchange(WFEDIT);
Line 274 
Line 273 
                 /* now should only happen in empty buffer */                  /* now should only happen in empty buffer */
                 if (curwp->w_doto != 0) {                  if (curwp->w_doto != 0) {
                         ewprintf("bug: linsert");                          ewprintf("bug: linsert");
                         return FALSE;                          return (FALSE);
                 }                  }
                 /* allocate a new line */                  /* allocate a new line */
                 if ((lp2 = lalloc(n)) == NULL)                  if ((lp2 = lalloc(n)) == NULL)
                         return FALSE;                          return (FALSE);
                 /* previous line */                  /* previous line */
                 lp3 = lp1->l_bp;                  lp3 = lp1->l_bp;
                 /* link in */                  /* link in */
Line 298 
Line 297 
                 }                  }
                 undo_add_insert(lp2, 0, n);                  undo_add_insert(lp2, 0, n);
                 curwp->w_doto = n;                  curwp->w_doto = n;
                 return TRUE;                  return (TRUE);
         }          }
         /* save for later */          /* save for later */
         doto = curwp->w_doto;          doto = curwp->w_doto;
   
   
         if ((lp1->l_used + n) > lp1->l_size) {          if ((lp1->l_used + n) > lp1->l_size) {
                 if (lrealloc(lp1, lp1->l_used + n) == FALSE)                  if (lrealloc(lp1, lp1->l_used + n) == FALSE)
                         return FALSE;                          return (FALSE);
         }          }
         lp1->l_used += n;          lp1->l_used += n;
         if (lp1->l_used != n)          if (lp1->l_used != n)
Line 327 
Line 325 
                 }                  }
         }          }
         undo_add_insert(curwp->w_dotp, doto, n);          undo_add_insert(curwp->w_dotp, doto, n);
         return TRUE;          return (TRUE);
 }  }
   
 int  int
Line 347 
Line 345 
         if (doto == 0) {          if (doto == 0) {
                 /* new first part */                  /* new first part */
                 if ((lp2 = lalloc(0)) == NULL)                  if ((lp2 = lalloc(0)) == NULL)
                         return FALSE;                          return (FALSE);
                 lp2->l_bp = lp1->l_bp;                  lp2->l_bp = lp1->l_bp;
                 lp1->l_bp->l_fp = lp2;                  lp1->l_bp->l_fp = lp2;
                 lp2->l_fp = lp1;                  lp2->l_fp = lp1;
Line 355 
Line 353 
                 for (wp = wheadp; wp != NULL; wp = wp->w_wndp)                  for (wp = wheadp; wp != NULL; wp = wp->w_wndp)
                         if (wp->w_linep == lp1)                          if (wp->w_linep == lp1)
                                 wp->w_linep = lp2;                                  wp->w_linep = lp2;
                 return TRUE;                  return (TRUE);
         }          }
   
         /* length of new part */          /* length of new part */
Line 363 
Line 361 
   
         /* new second half line */          /* new second half line */
         if ((lp2 = lalloc(nlen)) == NULL)          if ((lp2 = lalloc(nlen)) == NULL)
                 return FALSE;                  return (FALSE);
         if (nlen != 0)          if (nlen != 0)
                 bcopy(&lp1->l_text[doto], &lp2->l_text[0], nlen);                  bcopy(&lp1->l_text[doto], &lp2->l_text[0], nlen);
         lp1->l_used = doto;          lp1->l_used = doto;
Line 382 
Line 380 
                         wp->w_marko -= doto;                          wp->w_marko -= doto;
                 }                  }
         }          }
         return TRUE;          return (TRUE);
 }  }
   
 /*  /*
Line 394 
Line 392 
 {  {
         if (curbp->b_flag & BFREADONLY) {          if (curbp->b_flag & BFREADONLY) {
                 ewprintf("Buffer is read only");                  ewprintf("Buffer is read only");
                 return FALSE;                  return (FALSE);
         }          }
         return lnewline_at(curwp->w_dotp, curwp->w_doto);          return (lnewline_at(curwp->w_dotp, curwp->w_doto));
 }  }
   
 /*  /*
Line 417 
Line 415 
   
         if (curbp->b_flag & BFREADONLY) {          if (curbp->b_flag & BFREADONLY) {
                 ewprintf("Buffer is read only");                  ewprintf("Buffer is read only");
                 return FALSE;                  return (FALSE);
         }          }
   
         undo_add_delete(curwp->w_dotp, curwp->w_doto, n);          undo_add_delete(curwp->w_dotp, curwp->w_doto, n);
Line 434 
Line 432 
                 doto = curwp->w_doto;                  doto = curwp->w_doto;
                 /* Hit the end of the buffer */                  /* Hit the end of the buffer */
                 if (dotp == curbp->b_linep)                  if (dotp == curbp->b_linep)
                         return FALSE;                          return (FALSE);
                 /* Size of the chunk */                  /* Size of the chunk */
                 chunk = dotp->l_used - doto;                  chunk = dotp->l_used - doto;
   
Line 444 
Line 442 
                 if (chunk == 0) {                  if (chunk == 0) {
                         if (dotp == lback(curbp->b_linep))                          if (dotp == lback(curbp->b_linep))
                                 /* End of buffer */                                  /* End of buffer */
                                 return FALSE;                                  return (FALSE);
                         lchange(WFHARD);                          lchange(WFHARD);
                         if (ldelnewline() == FALSE ||                          if (ldelnewline() == FALSE ||
                             (kflag != KNONE && kinsert('\n', kflag) == FALSE))                              (kflag != KNONE && kinsert('\n', kflag) == FALSE))
                                 return FALSE;                                  return (FALSE);
                         --n;                          --n;
                         continue;                          continue;
                 }                  }
Line 458 
Line 456 
                 if (kflag == KFORW) {                  if (kflag == KFORW) {
                         while (ksize - kused < chunk)                          while (ksize - kused < chunk)
                                 if (kgrow(FALSE) == FALSE)                                  if (kgrow(FALSE) == FALSE)
                                         return FALSE;                                          return (FALSE);
                         bcopy(cp1, &(kbufp[kused]), (int)chunk);                          bcopy(cp1, &(kbufp[kused]), (int)chunk);
                         kused += chunk;                          kused += chunk;
                 } else if (kflag == KBACK) {                  } else if (kflag == KBACK) {
                         while (kstart < chunk)                          while (kstart < chunk)
                                 if (kgrow(TRUE) == FALSE)                                  if (kgrow(TRUE) == FALSE)
                                         return FALSE;                                          return (FALSE);
                         bcopy(cp1, &(kbufp[kstart - chunk]), (int)chunk);                          bcopy(cp1, &(kbufp[kstart - chunk]), (int)chunk);
                         kstart -= chunk;                          kstart -= chunk;
                 } else if (kflag != KNONE)                  } else if (kflag != KNONE)
Line 489 
Line 487 
                 }                  }
                 n -= chunk;                  n -= chunk;
         }          }
         return TRUE;          return (TRUE);
 }  }
   
 /*  /*
Line 509 
Line 507 
   
         if (curbp->b_flag & BFREADONLY) {          if (curbp->b_flag & BFREADONLY) {
                 ewprintf("Buffer is read only");                  ewprintf("Buffer is read only");
                 return FALSE;                  return (FALSE);
         }          }
   
         lp1 = curwp->w_dotp;          lp1 = curwp->w_dotp;
         lp2 = lp1->l_fp;          lp2 = lp1->l_fp;
         /* at the end of the buffer */          /* at the end of the buffer */
         if (lp2 == curbp->b_linep)          if (lp2 == curbp->b_linep)
                 return TRUE;                  return (TRUE);
         if (lp2->l_used <= lp1->l_size - lp1->l_used) {          if (lp2->l_used <= lp1->l_size - lp1->l_used) {
                 bcopy(&lp2->l_text[0], &lp1->l_text[lp1->l_used], lp2->l_used);                  bcopy(&lp2->l_text[0], &lp1->l_text[lp1->l_used], lp2->l_used);
                 for (wp = wheadp; wp != NULL; wp = wp->w_wndp) {                  for (wp = wheadp; wp != NULL; wp = wp->w_wndp) {
Line 535 
Line 533 
                 lp1->l_fp = lp2->l_fp;                  lp1->l_fp = lp2->l_fp;
                 lp2->l_fp->l_bp = lp1;                  lp2->l_fp->l_bp = lp1;
                 free((char *)lp2);                  free((char *)lp2);
                 return TRUE;                  return (TRUE);
         }          }
         if ((lp3 = lalloc(lp1->l_used + lp2->l_used)) == NULL)          if ((lp3 = lalloc(lp1->l_used + lp2->l_used)) == NULL)
                 return FALSE;                  return (FALSE);
         bcopy(&lp1->l_text[0], &lp3->l_text[0], lp1->l_used);          bcopy(&lp1->l_text[0], &lp3->l_text[0], lp1->l_used);
         bcopy(&lp2->l_text[0], &lp3->l_text[lp1->l_used], lp2->l_used);          bcopy(&lp2->l_text[0], &lp3->l_text[lp1->l_used], lp2->l_used);
         lp1->l_bp->l_fp = lp3;          lp1->l_bp->l_fp = lp3;
Line 563 
Line 561 
         }          }
         free((char *)lp1);          free((char *)lp1);
         free((char *)lp2);          free((char *)lp2);
         return TRUE;          return (TRUE);
 }  }
   
   
 /*  /*
  * Replace plen characters before dot with argument string.  Control-J   * Replace plen characters before dot with argument string.  Control-J
  * characters in st are interpreted as newlines.  There is a casehack   * characters in st are interpreted as newlines.  There is a casehack
Line 583 
Line 580 
   
         if (curbp->b_flag & BFREADONLY) {          if (curbp->b_flag & BFREADONLY) {
                 ewprintf("Buffer is read only");                  ewprintf("Buffer is read only");
                 return FALSE;                  return (FALSE);
         }          }
   
         undo_add_change(curwp->w_dotp, curwp->w_doto, plen);          undo_add_change(curwp->w_dotp, curwp->w_doto, plen);
Line 618 
Line 615 
                 (void)ldelete((RSIZE) (plen - rlen), KNONE);                  (void)ldelete((RSIZE) (plen - rlen), KNONE);
         else if (plen < rlen) {          else if (plen < rlen) {
                 if (linsert((int)(rlen - plen), ' ') == FALSE)                  if (linsert((int)(rlen - plen), ' ') == FALSE)
                         return FALSE;                          return (FALSE);
         }          }
         curwp->w_doto = doto;          curwp->w_doto = doto;
   
Line 651 
Line 648 
         return (TRUE);          return (TRUE);
 }  }
   
   
 /*  /*
  * Delete all of the text saved in the kill buffer.  Called by commands when   * Delete all of the text saved in the kill buffer.  Called by commands when
  * a new kill context is created. The kill buffer array is released, just in   * a new kill context is created. The kill buffer array is released, just in
Line 678 
Line 674 
 kinsert(int c, int dir)  kinsert(int c, int dir)
 {  {
         if (kused == ksize && dir == KFORW && kgrow(FALSE) == FALSE)          if (kused == ksize && dir == KFORW && kgrow(FALSE) == FALSE)
                 return FALSE;                  return (FALSE);
         if (kstart == 0 && dir == KBACK && kgrow(TRUE) == FALSE)          if (kstart == 0 && dir == KBACK && kgrow(TRUE) == FALSE)
                 return FALSE;                  return (FALSE);
         if (dir == KFORW)          if (dir == KFORW)
                 kbufp[kused++] = c;                  kbufp[kused++] = c;
         else if (dir == KBACK)          else if (dir == KBACK)
Line 703 
Line 699 
         if ((unsigned)(ksize + KBLOCK) <= (unsigned)ksize) {          if ((unsigned)(ksize + KBLOCK) <= (unsigned)ksize) {
                 /* probably 16 bit unsigned */                  /* probably 16 bit unsigned */
                 ewprintf("Kill buffer size at maximum");                  ewprintf("Kill buffer size at maximum");
                 return FALSE;                  return (FALSE);
         }          }
         if ((nbufp = malloc((unsigned)(ksize + KBLOCK))) == NULL) {          if ((nbufp = malloc((unsigned)(ksize + KBLOCK))) == NULL) {
                 ewprintf("Can't get %ld bytes", (long)(ksize + KBLOCK));                  ewprintf("Can't get %ld bytes", (long)(ksize + KBLOCK));
                 return FALSE;                  return (FALSE);
         }          }
         nstart = (back == TRUE) ? (kstart + KBLOCK) : (KBLOCK / 4);          nstart = (back == TRUE) ? (kstart + KBLOCK) : (KBLOCK / 4);
         bcopy(&(kbufp[kstart]), &(nbufp[nstart]), (int)(kused - kstart));          bcopy(&(kbufp[kstart]), &(nbufp[nstart]), (int)(kused - kstart));
Line 717 
Line 713 
         ksize += KBLOCK;          ksize += KBLOCK;
         kused = kused - kstart + nstart;          kused = kused - kstart + nstart;
         kstart = nstart;          kstart = nstart;
         return TRUE;          return (TRUE);
 }  }
   
 /*  /*
Line 729 
Line 725 
 kremove(int n)  kremove(int n)
 {  {
         if (n < 0 || n + kstart >= kused)          if (n < 0 || n + kstart >= kused)
                 return -1;                  return (-1);
         return CHARMASK(kbufp[n + kstart]);          return (CHARMASK(kbufp[n + kstart]));
 }  }
Legend:
Removed from v.1.21  
changed lines
  Added in v.1.22