external/bsd/nvi/dist/ex/ex_global.c

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