contrib/nvi/ex/ex_global.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 <ctype.h>
  18 #include <errno.h>
  19 #include <limits.h>
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22 #include <string.h>
  23 #include <unistd.h>
  24
  25 #include "../common/common.h"
  26
  27 enum which {GLOBAL, V};
  28
  29 static int ex_g_setup(SCR *, EXCMD *, enum which);
  30
  31 /*
  32  * ex_global -- [line [,line]] g[lobal][!] /pattern/ [commands]
  33  *      Exec on lines matching a pattern.
  34  *
  35  * PUBLIC: int ex_global(SCR *, EXCMD *);
  36  */
  37 int
  38 ex_global(SCR *sp, EXCMD *cmdp)
  39 {
  40         return (ex_g_setup(sp,
  41             cmdp, FL_ISSET(cmdp->iflags, E_C_FORCE) ? V : GLOBAL));
  42 }
  43
  44 /*
  45  * ex_v -- [line [,line]] v /pattern/ [commands]
  46  *      Exec on lines not matching a pattern.
  47  *
  48  * PUBLIC: int ex_v(SCR *, EXCMD *);
  49  */
  50 int
  51 ex_v(SCR *sp, EXCMD *cmdp)
  52 {
  53         return (ex_g_setup(sp, cmdp, V));
  54 }
  55
  56 /*
  57  * ex_g_setup --
  58  *      Ex global and v commands.
  59  */
  60 static int
  61 ex_g_setup(SCR *sp, EXCMD *cmdp, enum which cmd)
  62 {
  63         CHAR_T *ptrn, *p, *t;
  64         EXCMD *ecp;
  65         MARK abs;
  66         RANGE *rp;
  67         busy_t btype;
  68         recno_t start, end;
  69         regex_t *re;
  70         regmatch_t match[1];
  71         size_t len;
  72         int cnt, delim, eval;
  73         CHAR_T *dbp;
  74
  75         NEEDFILE(sp, cmdp);
  76
  77         if (F_ISSET(sp, SC_EX_GLOBAL)) {
  78                 msgq_wstr(sp, M_ERR, cmdp->cmd->name,
  79         "124|The %s command can't be used as part of a global or v command");
  80                 return (1);
  81         }
  82
  83         /*
  84          * Skip leading white space.  Historic vi allowed any non-alphanumeric
  85          * to serve as the global command delimiter.
  86          */
  87         if (cmdp->argc == 0)
  88                 goto usage;
  89         for (p = cmdp->argv[0]->bp; cmdskip(*p); ++p);
  90         if (*p == '\0' || is09azAZ(*p) ||
  91             *p == '\\' || *p == '|' || *p == '\n') {
  92 usage:          ex_emsg(sp, cmdp->cmd->usage, EXM_USAGE);
  93                 return (1);
  94         }
  95         delim = *p++;
  96
  97         /*
  98          * Get the pattern string, toss escaped characters.
  99          *
 100          * QUOTING NOTE:
 101          * Only toss an escaped character if it escapes a delimiter.
 102          */
 103         for (ptrn = t = p;;) {
 104                 if (p[0] == '\0' || p[0] == delim) {
 105                         if (p[0] == delim)
 106                                 ++p;
 107                         /*
 108                          * !!!
 109                          * Nul terminate the pattern string -- it's passed
 110                          * to regcomp which doesn't understand anything else.
 111                          */
 112                         *t = '\0';
 113                         break;
 114                 }
 115                 if (p[0] == '\\') {
 116                         if (p[1] == delim)
 117                                 ++p;
 118                         else if (p[1] == '\\')
 119                                 *t++ = *p++;
 120                 }
 121                 *t++ = *p++;
 122         }
 123
 124         /* If the pattern string is empty, use the last one. */
 125         if (*ptrn == '\0') {
 126                 if (sp->re == NULL) {
 127                         ex_emsg(sp, NULL, EXM_NOPREVRE);
 128                         return (1);
 129                 }
 130
 131                 /* Re-compile the RE if necessary. */
 132                 if (!F_ISSET(sp, SC_RE_SEARCH) &&
 133                     re_compile(sp, sp->re, sp->re_len,
 134                     NULL, NULL, &sp->re_c, RE_C_SEARCH))
 135                         return (1);
 136         } else {
 137                 /* Compile the RE. */
 138                 if (re_compile(sp, ptrn, t - ptrn, &sp->re,
 139                     &sp->re_len, &sp->re_c, RE_C_SEARCH))
 140                         return (1);
 141
 142                 /*
 143                  * Set saved RE.  Historic practice is that globals set
 144                  * direction as well as the RE.
 145                  */
 146                 sp->searchdir = FORWARD;
 147         }
 148         re = &sp->re_c;
 149
 150         /* The global commands always set the previous context mark. */
 151         abs.lno = sp->lno;
 152         abs.cno = sp->cno;
 153         if (mark_set(sp, ABSMARK1, &abs, 1))
 154                 return (1);
 155
 156         /* Get an EXCMD structure. */
 157         CALLOC_RET(sp, ecp, 1, sizeof(EXCMD));
 158         TAILQ_INIT(ecp->rq);
 159
 160         /*
 161          * Get a copy of the command string; the default command is print.
 162          * Don't worry about a set of <blank>s with no command, that will
 163          * default to print in the ex parser.  We need to have two copies
 164          * because the ex parser may step on the command string when it's
 165          * parsing it.
 166          */
 167         if ((len = cmdp->argv[0]->len - (p - cmdp->argv[0]->bp)) == 0) {
 168                 p = L("p");
 169                 len = 1;
 170         }
 171
 172         MALLOC_RET(sp, ecp->cp, (len * 2) * sizeof(CHAR_T));
 173         ecp->o_cp = ecp->cp;
 174         ecp->o_clen = len;
 175         MEMCPY(ecp->cp + len, p, len);
 176         ecp->range_lno = OOBLNO;
 177         FL_SET(ecp->agv_flags, cmd == GLOBAL ? AGV_GLOBAL : AGV_V);
 178         SLIST_INSERT_HEAD(sp->gp->ecq, ecp, q);
 179
 180         /*
 181          * For each line...  The semantics of global matching are that we first
 182          * have to decide which lines are going to get passed to the command,
 183          * and then pass them to the command, ignoring other changes.  There's
 184          * really no way to do this in a single pass, since arbitrary line
 185          * creation, deletion and movement can be done in the ex command.  For
 186          * example, a good vi clone test is ":g/X/mo.-3", or "g/X/.,.+1d".
 187          * What we do is create linked list of lines that are tracked through
 188          * each ex command.  There's a callback routine which the DB interface
 189          * routines call when a line is created or deleted.  This doesn't help
 190          * the layering much.
 191          */
 192         btype = BUSY_ON;
 193         cnt = INTERRUPT_CHECK;
 194         for (start = cmdp->addr1.lno,
 195             end = cmdp->addr2.lno; start <= end; ++start) {
 196                 if (cnt-- == 0) {
 197                         if (INTERRUPTED(sp)) {
 198                                 SLIST_REMOVE_HEAD(sp->gp->ecq, q);
 199                                 free(ecp->cp);
 200                                 free(ecp);
 201                                 break;
 202                         }
 203                         search_busy(sp, btype);
 204                         btype = BUSY_UPDATE;
 205                         cnt = INTERRUPT_CHECK;
 206                 }
 207                 if (db_get(sp, start, DBG_FATAL, &dbp, &len))
 208                         return (1);
 209                 match[0].rm_so = 0;
 210                 match[0].rm_eo = len;
 211                 switch (eval =
 212                     regexec(&sp->re_c, dbp, 0, match, REG_STARTEND)) {
 213                 case 0:
 214                         if (cmd == V)
 215                                 continue;
 216                         break;
 217                 case REG_NOMATCH:
 218                         if (cmd == GLOBAL)
 219                                 continue;
 220                         break;
 221                 default:
 222                         re_error(sp, eval, &sp->re_c);
 223                         break;
 224                 }
 225
 226                 /* If follows the last entry, extend the last entry's range. */
 227                 if ((rp = TAILQ_LAST(ecp->rq, _rh)) != NULL &&
 228                     rp->stop == start - 1) {
 229                         ++rp->stop;
 230                         continue;
 231                 }
 232
 233                 /* Allocate a new range, and append it to the list. */
 234                 CALLOC(sp, rp, 1, sizeof(RANGE));
 235                 if (rp == NULL)
 236                         return (1);
 237                 rp->start = rp->stop = start;
 238                 TAILQ_INSERT_TAIL(ecp->rq, rp, q);
 239         }
 240         search_busy(sp, BUSY_OFF);
 241         return (0);
 242 }
 243
 244 /*
 245  * ex_g_insdel --
 246  *      Update the ranges based on an insertion or deletion.
 247  *
 248  * PUBLIC: int ex_g_insdel(SCR *, lnop_t, recno_t);
 249  */
 250 int
 251 ex_g_insdel(SCR *sp, lnop_t op, recno_t lno)
 252 {
 253         EXCMD *ecp;
 254         RANGE *nrp, *rp;
 255
 256         /* All insert/append operations are done as inserts. */
 257         if (op == LINE_APPEND)
 258                 abort();
 259
 260         if (op == LINE_RESET)
 261                 return (0);
 262
 263         SLIST_FOREACH(ecp, sp->gp->ecq, q) {
 264                 if (!FL_ISSET(ecp->agv_flags, AGV_AT | AGV_GLOBAL | AGV_V))
 265                         continue;
 266                 TAILQ_FOREACH_SAFE(rp, ecp->rq, q, nrp) {
 267                         /* If range less than the line, ignore it. */
 268                         if (rp->stop < lno)
 269                                 continue;
 270
 271                         /*
 272                          * If range greater than the line, decrement or
 273                          * increment the range.
 274                          */
 275                         if (rp->start > lno) {
 276                                 if (op == LINE_DELETE) {
 277                                         --rp->start;
 278                                         --rp->stop;
 279                                 } else {
 280                                         ++rp->start;
 281                                         ++rp->stop;
 282                                 }
 283                                 continue;
 284                         }
 285
 286                         /*
 287                          * Lno is inside the range, decrement the end point
 288                          * for deletion, and split the range for insertion.
 289                          * In the latter case, since we're inserting a new
 290                          * element, neither range can be exhausted.
 291                          */
 292                         if (op == LINE_DELETE) {
 293                                 if (rp->start > --rp->stop) {
 294                                         TAILQ_REMOVE(ecp->rq, rp, q);
 295                                         free(rp);
 296                                 }
 297                         } else {
 298                                 CALLOC_RET(sp, nrp, 1, sizeof(RANGE));
 299                                 nrp->start = lno + 1;
 300                                 nrp->stop = rp->stop + 1;
 301                                 rp->stop = lno - 1;
 302                                 TAILQ_INSERT_AFTER(ecp->rq, rp, nrp, q);
 303                         }
 304                 }
 305
 306                 /*
 307                  * If the command deleted/inserted lines, the cursor moves to
 308                  * the line after the deleted/inserted line.
 309                  */
 310                 ecp->range_lno = lno;
 311         }
 312         return (0);
 313 }