contrib/nvi/vi/v_section.c

   1 /*-
   2  * Copyright (c) 1992, 1993, 1994
   3  *      The Regents of the University of California.  All rights reserved.
   4  * Copyright (c) 1992, 1993, 1994, 1995, 1996
   5  *      Keith Bostic.  All rights reserved.
   6  *
   7  * See the LICENSE file for redistribution information.
   8  */
   9
  10 #include "config.h"
  11
  12 #include <sys/types.h>
  13 #include <sys/queue.h>
  14 #include <sys/time.h>
  15
  16 #include <bitstring.h>
  17 #include <limits.h>
  18 #include <stdio.h>
  19 #include <string.h>
  20
  21 #include "../common/common.h"
  22 #include "vi.h"
  23
  24 /*
  25  * !!!
  26  * In historic vi, the section commands ignored empty lines, unlike the
  27  * paragraph commands, which was probably okay.  However, they also moved
  28  * to the start of the last line when there where no more sections instead
  29  * of the end of the last line like the paragraph commands.  I've changed
  30  * the latter behavior to match the paragraph commands.
  31  *
  32  * In historic vi, a section was defined as the first character(s) of the
  33  * line matching, which could be followed by anything.  This implementation
  34  * follows that historic practice.
  35  *
  36  * !!!
  37  * The historic vi documentation (USD:15-10) claimed:
  38  *      The section commands interpret a preceding count as a different
  39  *      window size in which to redraw the screen at the new location,
  40  *      and this window size is the base size for newly drawn windows
  41  *      until another size is specified.  This is very useful if you are
  42  *      on a slow terminal ...
  43  *
  44  * I can't get the 4BSD vi to do this, it just beeps at me.  For now, a
  45  * count to the section commands simply repeats the command.
  46  */
  47
  48 /*
  49  * v_sectionf -- [count]]]
  50  *      Move forward count sections/functions.
  51  *
  52  * !!!
  53  * Using ]] as a motion command was a bit special, historically.  It could
  54  * match } as well as the usual { and section values.  If it matched a { or
  55  * a section, it did NOT include the matched line.  If it matched a }, it
  56  * did include the line.  No clue why.
  57  *
  58  * PUBLIC: int v_sectionf(SCR *, VICMD *);
  59  */
  60 int
  61 v_sectionf(SCR *sp, VICMD *vp)
  62 {
  63         recno_t cnt, lno;
  64         size_t len;
  65         CHAR_T *p;
  66         char *list, *lp;
  67
  68         /* Get the macro list. */
  69         if ((list = O_STR(sp, O_SECTIONS)) == NULL)
  70                 return (1);
  71
  72         /*
  73          * !!!
  74          * If the starting cursor position is at or before any non-blank
  75          * characters in the line, i.e. the movement is cutting all of the
  76          * line's text, the buffer is in line mode.  It's a lot easier to
  77          * check here, because we know that the end is going to be the start
  78          * or end of a line.
  79          */
  80         if (ISMOTION(vp)) {
  81                 if (vp->m_start.cno == 0)
  82                         F_SET(vp, VM_LMODE);
  83                 else {
  84                         vp->m_stop = vp->m_start;
  85                         vp->m_stop.cno = 0;
  86                         if (nonblank(sp, vp->m_stop.lno, &vp->m_stop.cno))
  87                                 return (1);
  88                         if (vp->m_start.cno <= vp->m_stop.cno)
  89                                 F_SET(vp, VM_LMODE);
  90                 }
  91         }
  92
  93         cnt = F_ISSET(vp, VC_C1SET) ? vp->count : 1;
  94         for (lno = vp->m_start.lno; !db_get(sp, ++lno, 0, &p, &len);) {
  95                 if (len == 0)
  96                         continue;
  97                 if (p[0] == '{' || (ISMOTION(vp) && p[0] == '}')) {
  98                         if (!--cnt) {
  99                                 if (p[0] == '{')
 100                                         goto adjust1;
 101                                 goto adjust2;
 102                         }
 103                         continue;
 104                 }
 105                 /*
 106                  * !!!
 107                  * Historic documentation (USD:15-11, 4.2) said that formfeed
 108                  * characters (^L) in the first column delimited sections.
 109                  * The historic code mentions formfeed characters, but never
 110                  * implements them.  Seems reasonable, do it.
 111                  */
 112                 if (p[0] == '\014') {
 113                         if (!--cnt)
 114                                 goto adjust1;
 115                         continue;
 116                 }
 117                 if (p[0] != '.' || len < 2)
 118                         continue;
 119                 for (lp = list; *lp != '\0'; lp += 2 * sizeof(*lp))
 120                         if (lp[0] == p[1] &&
 121                             ((lp[1] == ' ' && len == 2) || lp[1] == p[2]) &&
 122                             !--cnt) {
 123                                 /*
 124                                  * !!!
 125                                  * If not cutting this line, adjust to the end
 126                                  * of the previous one.  Otherwise, position to
 127                                  * column 0.
 128                                  */
 129 adjust1:                        if (ISMOTION(vp))
 130                                         goto ret1;
 131
 132 adjust2:                        vp->m_stop.lno = lno;
 133                                 vp->m_stop.cno = 0;
 134                                 goto ret2;
 135                         }
 136         }
 137
 138         /* If moving forward, reached EOF, check to see if we started there. */
 139         if (vp->m_start.lno == lno - 1) {
 140                 v_eof(sp, NULL);
 141                 return (1);
 142         }
 143
 144 ret1:   if (db_get(sp, --lno, DBG_FATAL, NULL, &len))
 145                 return (1);
 146         vp->m_stop.lno = lno;
 147         vp->m_stop.cno = len ? len - 1 : 0;
 148
 149         /*
 150          * Non-motion commands go to the end of the range.  Delete and
 151          * yank stay at the start of the range.  Ignore others.
 152          */
 153 ret2:   if (ISMOTION(vp)) {
 154                 vp->m_final = vp->m_start;
 155                 if (F_ISSET(vp, VM_LMODE))
 156                         vp->m_final.cno = 0;
 157         } else
 158                 vp->m_final = vp->m_stop;
 159         return (0);
 160 }
 161
 162 /*
 163  * v_sectionb -- [count][[
 164  *      Move backward count sections/functions.
 165  *
 166  * PUBLIC: int v_sectionb(SCR *, VICMD *);
 167  */
 168 int
 169 v_sectionb(SCR *sp, VICMD *vp)
 170 {
 171         size_t len;
 172         recno_t cnt, lno;
 173         CHAR_T *p;
 174         char *list, *lp;
 175
 176         /* An empty file or starting from line 1 is always illegal. */
 177         if (vp->m_start.lno <= 1) {
 178                 v_sof(sp, NULL);
 179                 return (1);
 180         }
 181
 182         /* Get the macro list. */
 183         if ((list = O_STR(sp, O_SECTIONS)) == NULL)
 184                 return (1);
 185
 186         cnt = F_ISSET(vp, VC_C1SET) ? vp->count : 1;
 187         for (lno = vp->m_start.lno; !db_get(sp, --lno, 0, &p, &len);) {
 188                 if (len == 0)
 189                         continue;
 190                 if (p[0] == '{') {
 191                         if (!--cnt)
 192                                 goto adjust1;
 193                         continue;
 194                 }
 195                 /*
 196                  * !!!
 197                  * Historic documentation (USD:15-11, 4.2) said that formfeed
 198                  * characters (^L) in the first column delimited sections.
 199                  * The historic code mentions formfeed characters, but never
 200                  * implements them.  Seems reasonable, do it.
 201                  */
 202                 if (p[0] == '\014') {
 203                         if (!--cnt)
 204                                 goto adjust1;
 205                         continue;
 206                 }
 207                 if (p[0] != '.' || len < 2)
 208                         continue;
 209                 for (lp = list; *lp != '\0'; lp += 2 * sizeof(*lp))
 210                         if (lp[0] == p[1] &&
 211                             ((lp[1] == ' ' && len == 2) || lp[1] == p[2]) &&
 212                             !--cnt) {
 213 adjust1:                        vp->m_stop.lno = lno;
 214                                 vp->m_stop.cno = 0;
 215                                 goto ret1;
 216                         }
 217         }
 218
 219         /*
 220          * If moving backward, reached SOF, which is a movement sink.
 221          * We already checked for starting there.
 222          */
 223         vp->m_stop.lno = 1;
 224         vp->m_stop.cno = 0;
 225
 226         /*
 227          * All commands move to the end of the range.
 228          *
 229          * !!!
 230          * Historic practice is the section cut was in line mode if it started
 231          * from column 0 and was in the backward direction.  Otherwise, left
 232          * motion commands adjust the starting point to the character before
 233          * the current one.  What makes this worse is that if it cut to line
 234          * mode it also went to the first non-<blank>.
 235          */
 236 ret1:   if (vp->m_start.cno == 0) {
 237                 F_CLR(vp, VM_RCM_MASK);
 238                 F_SET(vp, VM_RCM_SETFNB);
 239
 240                 --vp->m_start.lno;
 241                 F_SET(vp, VM_LMODE);
 242         } else
 243                 --vp->m_start.cno;
 244
 245         vp->m_final = vp->m_stop;
 246         return (0);
 247 }