heirloom-ed

annotate ed.c @ 0:1493bea5ac22

find changesets by author, revision, files, or words in the commit message
Initial version of the standalone heirloom-ed
author markus schnalke <meillo@marmaro.de>
date Mon, 05 Sep 2011 16:31:35 +0200
parents
children a09d0630f05b
rev   line source
meillo@0 1 /*
meillo@0 2 * Editor
meillo@0 3 */
meillo@0 4
meillo@0 5 /*
meillo@0 6 * Changes by Gunnar Ritter, Freiburg i. Br., Germany, July 2003.
meillo@0 7 */
meillo@0 8 /* from Unix 32V /usr/src/cmd/ed.c */
meillo@0 9 /*
meillo@0 10 * Copyright(C) Caldera International Inc. 2001-2002. All rights reserved.
meillo@0 11 *
meillo@0 12 * Redistribution and use in source and binary forms, with or without
meillo@0 13 * modification, are permitted provided that the following conditions
meillo@0 14 * are met:
meillo@0 15 * Redistributions of source code and documentation must retain the
meillo@0 16 * above copyright notice, this list of conditions and the following
meillo@0 17 * disclaimer.
meillo@0 18 * Redistributions in binary form must reproduce the above copyright
meillo@0 19 * notice, this list of conditions and the following disclaimer in the
meillo@0 20 * documentation and/or other materials provided with the distribution.
meillo@0 21 * All advertising materials mentioning features or use of this software
meillo@0 22 * must display the following acknowledgement:
meillo@0 23 * This product includes software developed or owned by Caldera
meillo@0 24 * International, Inc.
meillo@0 25 * Neither the name of Caldera International, Inc. nor the names of
meillo@0 26 * other contributors may be used to endorse or promote products
meillo@0 27 * derived from this software without specific prior written permission.
meillo@0 28 *
meillo@0 29 * USE OF THE SOFTWARE PROVIDED FOR UNDER THIS LICENSE BY CALDERA
meillo@0 30 * INTERNATIONAL, INC. AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR
meillo@0 31 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
meillo@0 32 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
meillo@0 33 * ARE DISCLAIMED. IN NO EVENT SHALL CALDERA INTERNATIONAL, INC. BE
meillo@0 34 * LIABLE FOR ANY DIRECT, INDIRECT INCIDENTAL, SPECIAL, EXEMPLARY, OR
meillo@0 35 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
meillo@0 36 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
meillo@0 37 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
meillo@0 38 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
meillo@0 39 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
meillo@0 40 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
meillo@0 41 */
meillo@0 42
meillo@0 43 #if __GNUC__ >= 3 && __GNUC_MINOR__ >= 4 || __GNUC__ >= 4
meillo@0 44 #define USED __attribute__ ((used))
meillo@0 45 #elif defined __GNUC__
meillo@0 46 #define USED __attribute__ ((unused))
meillo@0 47 #else
meillo@0 48 #define USED
meillo@0 49 #endif
meillo@0 50 #if defined (SU3)
meillo@0 51 static const char sccsid[] USED = "@(#)ed_su3.sl 1.99 (gritter) 7/27/06";
meillo@0 52 #elif defined (SUS)
meillo@0 53 static const char sccsid[] USED = "@(#)ed_sus.sl 1.99 (gritter) 7/27/06";
meillo@0 54 #elif defined (S42)
meillo@0 55 static const char sccsid[] USED = "@(#)ed_s42.sl 1.99 (gritter) 7/27/06";
meillo@0 56 #else /* !SU3, !SUS, !S42 */
meillo@0 57 static const char sccsid[] USED = "@(#)ed.sl 1.99 (gritter) 7/27/06";
meillo@0 58 #endif /* !SU3, !SUS, !S42 */
meillo@0 59
meillo@0 60 #include <sys/types.h>
meillo@0 61 #include <sys/stat.h>
meillo@0 62 #include <sys/wait.h>
meillo@0 63 #include <sys/stat.h>
meillo@0 64 #include <fcntl.h>
meillo@0 65 #include <unistd.h>
meillo@0 66 #include <time.h>
meillo@0 67 #include <string.h>
meillo@0 68 #include <stdlib.h>
meillo@0 69 #include <signal.h>
meillo@0 70 #include "sigset.h"
meillo@0 71 #include <termios.h>
meillo@0 72 #include <setjmp.h>
meillo@0 73 #include <libgen.h>
meillo@0 74 #include <inttypes.h>
meillo@0 75 #include <locale.h>
meillo@0 76 #include <wchar.h>
meillo@0 77 #include <ctype.h>
meillo@0 78 #include <wctype.h>
meillo@0 79 #include <limits.h>
meillo@0 80 #include <termios.h>
meillo@0 81 static int FNSIZE;
meillo@0 82 static int LBSIZE;
meillo@0 83 static int RHSIZE;
meillo@0 84 #define ESIZE 2048
meillo@0 85 static int GBSIZE;
meillo@0 86 #undef EOF
meillo@0 87 #define EOF -1
meillo@0 88 #define puts(s) xxputs(s)
meillo@0 89 #define getline(t, n) xxgetline(t, n)
meillo@0 90
meillo@0 91 #if (LONG_MAX > 017777777777L)
meillo@0 92 #define MAXCNT 0777777777777777777777L /* 2^63-1 */
meillo@0 93 #else
meillo@0 94 #define MAXCNT 017777777777L /* 2^31-1 */
meillo@0 95 #endif
meillo@0 96 #define BLKMSK (MAXCNT>>8) /* was 0377 */
meillo@0 97
meillo@0 98 #define READ 0
meillo@0 99 #define WRITE 1
meillo@0 100 #define EXIST 2
meillo@0 101
meillo@0 102 struct tabulator {
meillo@0 103 struct tabulator *t_nxt; /* next list element */
meillo@0 104 const char *t_str; /* tabulator string */
meillo@0 105 int t_tab; /* tab stop position */
meillo@0 106 int t_rep; /* repetitive tab count */
meillo@0 107 };
meillo@0 108
meillo@0 109 static int peekc;
meillo@0 110 static int lastc;
meillo@0 111 static char *savedfile;
meillo@0 112 static char *file;
meillo@0 113 static struct stat fstbuf;
meillo@0 114 static char *linebuf;
meillo@0 115 static char *rhsbuf;
meillo@0 116 static char expbuf[ESIZE + 4];
meillo@0 117 static long *zero;
meillo@0 118 static long *undzero;
meillo@0 119 static long *dot;
meillo@0 120 static long *unddot;
meillo@0 121 static long *dol;
meillo@0 122 static long *unddol;
meillo@0 123 static long *addr1;
meillo@0 124 static long *addr2;
meillo@0 125 static char *genbuf;
meillo@0 126 static long count;
meillo@0 127 static char *linebp;
meillo@0 128 static int ninbuf;
meillo@0 129 static int io;
meillo@0 130 static int ioeof;
meillo@0 131 static int pflag;
meillo@0 132 static char *wrtemp;
meillo@0 133 static uid_t myuid;
meillo@0 134 static void (*oldhup)(int);
meillo@0 135 static void (*oldquit)(int);
meillo@0 136 static void (*oldpipe)(int);
meillo@0 137 static int vflag = 1;
meillo@0 138 static int listf;
meillo@0 139 static int numbf;
meillo@0 140 static char *globp;
meillo@0 141 static int tfile = -1;
meillo@0 142 static long tline;
meillo@0 143 static char tfname[64];
meillo@0 144 static char ibuff[512];
meillo@0 145 static int iblock = -1;
meillo@0 146 static char obuff[512];
meillo@0 147 static int oblock = -1;
meillo@0 148 static int ichanged;
meillo@0 149 static int nleft;
meillo@0 150 static long *names;
meillo@0 151 static long *undnames;
meillo@0 152 static int anymarks;
meillo@0 153 static int subnewa;
meillo@0 154 static int fchange;
meillo@0 155 static int wrapp;
meillo@0 156 static unsigned nlall = 128;
meillo@0 157 static const char *progname;
meillo@0 158 static const char *prompt = "*";
meillo@0 159 static int Pflag;
meillo@0 160 static int prhelp;
meillo@0 161 static const char *prvmsg;
meillo@0 162 static int lastsig;
meillo@0 163 static int pipid = -1;
meillo@0 164 static int readop;
meillo@0 165 static int status;
meillo@0 166 static int mb_cur_max;
meillo@0 167 static int needsub;
meillo@0 168 static int insub;
meillo@0 169 static struct tabulator *tabstops;
meillo@0 170 static int maxlength;
meillo@0 171 static int rspec;
meillo@0 172 static int Nflag;
meillo@0 173 static int bcount = 22;
meillo@0 174 static int ocount = 11;
meillo@0 175
meillo@0 176 static jmp_buf savej;
meillo@0 177
meillo@0 178 static void usage(char, int);
meillo@0 179 static void commands(void);
meillo@0 180 static long *address(void);
meillo@0 181 static void setdot(void);
meillo@0 182 static void setall(void);
meillo@0 183 static void setnoaddr(void);
meillo@0 184 static void nonzero(void);
meillo@0 185 static void newline(void);
meillo@0 186 static void filename(int);
meillo@0 187 static void exfile(void);
meillo@0 188 static void onintr(int);
meillo@0 189 static void onhup(int);
meillo@0 190 static void onpipe(int);
meillo@0 191 static void error(const char *);
meillo@0 192 static void error2(const char *, const char *);
meillo@0 193 static void errput(const char *, const char *);
meillo@0 194 static int getchr(void);
meillo@0 195 static int gettty(void);
meillo@0 196 static long getnum(void);
meillo@0 197 static int getfile(void);
meillo@0 198 static void putfile(void);
meillo@0 199 static int append(int (*)(void), long *);
meillo@0 200 static void callunix(void);
meillo@0 201 static char *readcmd(void);
meillo@0 202 static void quit(int);
meillo@0 203 static void delete(void);
meillo@0 204 static void rdelete(long *, long *);
meillo@0 205 static void gdelete(void);
meillo@0 206 static char *getline(long, int);
meillo@0 207 static int putline(void);
meillo@0 208 static char *getblock(long, long);
meillo@0 209 static void blkio(long, char *, int);
meillo@0 210 static void init(void);
meillo@0 211 static void global(int, int);
meillo@0 212 static void globrd(char **, int);
meillo@0 213 static void join(void);
meillo@0 214 static void substitute(int);
meillo@0 215 static int compsub(void);
meillo@0 216 static int getsub(void);
meillo@0 217 static int dosub(int);
meillo@0 218 static int place(int, const char *, const char *);
meillo@0 219 static void move(int);
meillo@0 220 static void reverse(long *, long *);
meillo@0 221 static int getcopy(void);
meillo@0 222 static int execute(int, long *, int);
meillo@0 223 static void cmplerr(int);
meillo@0 224 static void doprnt(long *, long *);
meillo@0 225 static void putd(long);
meillo@0 226 static void puts(const char *);
meillo@0 227 static void nlputs(const char *);
meillo@0 228 static void list(const char *);
meillo@0 229 static int lstchr(int);
meillo@0 230 static void putstr(const char *);
meillo@0 231 static void putchr(int);
meillo@0 232 static void checkpoint(void);
meillo@0 233 static void undo(void);
meillo@0 234 static int maketf(int);
meillo@0 235 static int creatf(const char *);
meillo@0 236 static int sopen(const char *, int);
meillo@0 237 static void sclose(int);
meillo@0 238 static void fspec(const char *);
meillo@0 239 static const char *ftok(const char **);
meillo@0 240 static struct tabulator *tabstring(const char *);
meillo@0 241 static void freetabs(void);
meillo@0 242 static void expand(const char *);
meillo@0 243 static void growlb(const char *);
meillo@0 244 static void growrhs(const char *);
meillo@0 245 static void growfn(const char *);
meillo@0 246 static void help(void);
meillo@0 247
meillo@0 248 #define INIT
meillo@0 249 #define GETC() getchr()
meillo@0 250 #define UNGETC(c) (peekc = c)
meillo@0 251 #define PEEKC() (peekc = getchr())
meillo@0 252 #define RETURN(c) return c
meillo@0 253 #define ERROR(c) cmplerr(c)
meillo@0 254 static wint_t GETWC(char *);
meillo@0 255
meillo@0 256 #if defined (SUS) || defined (S42) || defined (SU3)
meillo@0 257
meillo@0 258 #include <regex.h>
meillo@0 259
meillo@0 260 #define NBRA 9
meillo@0 261
meillo@0 262 static char *braslist[NBRA];
meillo@0 263 static char *braelist[NBRA];
meillo@0 264 static char *loc1, *loc2, *locs;
meillo@0 265 static int nbra;
meillo@0 266 static int circf;
meillo@0 267 static int nodelim;
meillo@0 268
meillo@0 269 static char *compile(char *, char *, const char *, int);
meillo@0 270 static int step(const char *, const char *);
meillo@0 271
meillo@0 272 #else /* !SUS, !S42, !SU3 */
meillo@0 273
meillo@0 274 #include <regexp.h>
meillo@0 275
meillo@0 276 #endif /* !SUS, !S42, !SU3 */
meillo@0 277
meillo@0 278 int
meillo@0 279 main(int argc, char **argv)
meillo@0 280 {
meillo@0 281 register int i;
meillo@0 282 void (*oldintr)(int);
meillo@0 283
meillo@0 284 progname = basename(argv[0]);
meillo@0 285 #if defined (SUS) || defined (S42) || defined (SU3)
meillo@0 286 setlocale(LC_COLLATE, "");
meillo@0 287 #endif
meillo@0 288 setlocale(LC_CTYPE, "");
meillo@0 289 mb_cur_max = MB_CUR_MAX;
meillo@0 290 myuid = getuid();
meillo@0 291 oldquit = sigset(SIGQUIT, SIG_IGN);
meillo@0 292 oldhup = sigset(SIGHUP, SIG_IGN);
meillo@0 293 oldintr = sigset(SIGINT, SIG_IGN);
meillo@0 294 if (sigset(SIGTERM, SIG_IGN) != SIG_IGN)
meillo@0 295 sigset(SIGTERM, quit);
meillo@0 296 oldpipe = sigset(SIGPIPE, onpipe);
meillo@0 297 argv++;
meillo@0 298 while (argc > 1 && **argv=='-') {
meillo@0 299 if ((*argv)[1] == '\0') {
meillo@0 300 vflag = 0;
meillo@0 301 goto next;
meillo@0 302 } else if ((*argv)[1] == '-' && (*argv)[2] == '\0') {
meillo@0 303 argv++;
meillo@0 304 argc--;
meillo@0 305 break;
meillo@0 306 }
meillo@0 307 letter: switch((*argv)[1]) {
meillo@0 308
meillo@0 309 case 's':
meillo@0 310 vflag = 0;
meillo@0 311 break;
meillo@0 312
meillo@0 313 case 'q':
meillo@0 314 sigset(SIGQUIT, SIG_DFL);
meillo@0 315 vflag = 1;
meillo@0 316 break;
meillo@0 317
meillo@0 318 case 'p':
meillo@0 319 if ((*argv)[2])
meillo@0 320 prompt = &(*argv)[2];
meillo@0 321 else if (argv[1]) {
meillo@0 322 prompt = argv[1];
meillo@0 323 argv++;
meillo@0 324 argc--;
meillo@0 325 } else
meillo@0 326 usage((*argv)[1], 1);
meillo@0 327 Pflag = 1;
meillo@0 328 goto next;
meillo@0 329
meillo@0 330 default:
meillo@0 331 usage((*argv)[1], 0);
meillo@0 332 }
meillo@0 333 if ((*argv)[2]) {
meillo@0 334 (*argv)++;
meillo@0 335 goto letter;
meillo@0 336 }
meillo@0 337 next: argv++;
meillo@0 338 argc--;
meillo@0 339 }
meillo@0 340
meillo@0 341 growfn("no space");
meillo@0 342 if (argc>1) {
meillo@0 343 i = -1;
meillo@0 344 do
meillo@0 345 if (++i >= FNSIZE)
meillo@0 346 growfn("maximum of characters in "
meillo@0 347 "file names reached");
meillo@0 348 while (savedfile[i] = (*argv)[i]);
meillo@0 349 globp = "e";
meillo@0 350 }
meillo@0 351 names = malloc(26*sizeof *names);
meillo@0 352 undnames = malloc(26*sizeof *undnames);
meillo@0 353 zero = malloc(nlall*sizeof *zero);
meillo@0 354 if ((undzero = malloc(nlall*sizeof *undzero)) == NULL)
meillo@0 355 puts("no memory for undo");
meillo@0 356 growlb("no space");
meillo@0 357 growrhs("no space");
meillo@0 358 init();
meillo@0 359 if (oldintr != SIG_IGN)
meillo@0 360 sigset(SIGINT, onintr);
meillo@0 361 if (oldhup != SIG_IGN)
meillo@0 362 sigset(SIGHUP, onhup);
meillo@0 363 setjmp(savej);
meillo@0 364 if (lastsig) {
meillo@0 365 sigrelse(lastsig);
meillo@0 366 lastsig = 0;
meillo@0 367 }
meillo@0 368 commands();
meillo@0 369 quit(0);
meillo@0 370 /*NOTREACHED*/
meillo@0 371 return 0;
meillo@0 372 }
meillo@0 373
meillo@0 374 static void
meillo@0 375 usage(char c, int misarg)
meillo@0 376 {
meillo@0 377 if (c) {
meillo@0 378 write(2, progname, strlen(progname));
meillo@0 379 if (misarg)
meillo@0 380 write(2, ": option requires an argument -- ", 33);
meillo@0 381 else
meillo@0 382 write(2, ": illegal option -- ", 20);
meillo@0 383 write(2, &c, 1);
meillo@0 384 write(2, "\n", 1);
meillo@0 385 }
meillo@0 386 write(2, "usage: ", 7);
meillo@0 387 write(2, progname, strlen(progname));
meillo@0 388 write(2, " [- | -s] [-p string] [file]\n", 29);
meillo@0 389 exit(2);
meillo@0 390 }
meillo@0 391
meillo@0 392 static void
meillo@0 393 commands(void)
meillo@0 394 {
meillo@0 395 register long *a1;
meillo@0 396 register int c;
meillo@0 397 int n;
meillo@0 398
meillo@0 399 for (;;) {
meillo@0 400 if (pflag) {
meillo@0 401 pflag = 0;
meillo@0 402 addr1 = addr2 = dot;
meillo@0 403 goto print;
meillo@0 404 }
meillo@0 405 if (Pflag && globp == NULL)
meillo@0 406 write(1, prompt, strlen(prompt));
meillo@0 407 addr1 = 0;
meillo@0 408 addr2 = 0;
meillo@0 409 switch (c = getchr()) {
meillo@0 410 case ',':
meillo@0 411 case ';':
meillo@0 412 addr2 = c == ',' ? zero+1 : dot;
meillo@0 413 if (((peekc = getchr()) < '0' || peekc > '9') &&
meillo@0 414 peekc != ' ' && peekc != '\t' &&
meillo@0 415 peekc != '+' && peekc != '-' &&
meillo@0 416 peekc != '^' && peekc != '?' &&
meillo@0 417 peekc != '/' && peekc != '$' &&
meillo@0 418 peekc != '.' && peekc != '\'') {
meillo@0 419 addr1 = addr2;
meillo@0 420 a1 = dol;
meillo@0 421 goto loop;
meillo@0 422 }
meillo@0 423 break;
meillo@0 424 default:
meillo@0 425 peekc = c;
meillo@0 426 }
meillo@0 427 do {
meillo@0 428 addr1 = addr2;
meillo@0 429 if ((a1 = address())==0) {
meillo@0 430 c = getchr();
meillo@0 431 break;
meillo@0 432 }
meillo@0 433 loop: addr2 = a1;
meillo@0 434 if ((c=getchr()) == ';') {
meillo@0 435 c = ',';
meillo@0 436 dot = a1;
meillo@0 437 }
meillo@0 438 } while (c==',');
meillo@0 439 if (addr1==0)
meillo@0 440 addr1 = addr2;
meillo@0 441 switch(c) {
meillo@0 442
meillo@0 443 case 'a':
meillo@0 444 setdot();
meillo@0 445 newline();
meillo@0 446 checkpoint();
meillo@0 447 append(gettty, addr2);
meillo@0 448 continue;
meillo@0 449
meillo@0 450 case 'c':
meillo@0 451 #if defined (SU3)
meillo@0 452 if (addr1 == zero && addr1+1 <= dol) {
meillo@0 453 if (addr1 == addr2)
meillo@0 454 addr2++;
meillo@0 455 addr1++;
meillo@0 456 }
meillo@0 457 #endif /* SU3 */
meillo@0 458 delete();
meillo@0 459 append(gettty, addr1-1);
meillo@0 460 #if defined (SUS) || defined (SU3)
meillo@0 461 if (dot == addr1-1 && addr1 <= dol)
meillo@0 462 dot = addr1;
meillo@0 463 #endif /* SUS || SU3 */
meillo@0 464 continue;
meillo@0 465
meillo@0 466 case 'd':
meillo@0 467 delete();
meillo@0 468 continue;
meillo@0 469
meillo@0 470 case 'E':
meillo@0 471 fchange = 0;
meillo@0 472 c = 'e';
meillo@0 473 case 'e':
meillo@0 474 setnoaddr();
meillo@0 475 if (vflag && fchange) {
meillo@0 476 fchange = 0;
meillo@0 477 error("warning: expecting `w'");
meillo@0 478 }
meillo@0 479 filename(c);
meillo@0 480 init();
meillo@0 481 addr2 = zero;
meillo@0 482 goto caseread;
meillo@0 483
meillo@0 484 case 'f':
meillo@0 485 setnoaddr();
meillo@0 486 filename(c);
meillo@0 487 puts(savedfile);
meillo@0 488 continue;
meillo@0 489
meillo@0 490 case 'g':
meillo@0 491 global(1, 0);
meillo@0 492 continue;
meillo@0 493
meillo@0 494 case 'G':
meillo@0 495 global(1, 1);
meillo@0 496 continue;
meillo@0 497
meillo@0 498 case 'H':
meillo@0 499 prhelp = !prhelp;
meillo@0 500 /*FALLTHRU*/
meillo@0 501
meillo@0 502 case 'h':
meillo@0 503 if ((peekc = getchr()) == 'e') {
meillo@0 504 peekc = 0;
meillo@0 505 if (getchr() != 'l' || getchr() != 'p' ||
meillo@0 506 getchr() != '\n')
meillo@0 507 error("illegal suffix");
meillo@0 508 setnoaddr();
meillo@0 509 help();
meillo@0 510 continue;
meillo@0 511 }
meillo@0 512 newline();
meillo@0 513 setnoaddr();
meillo@0 514 if (prvmsg)
meillo@0 515 puts(prvmsg);
meillo@0 516 continue;
meillo@0 517
meillo@0 518 case 'i':
meillo@0 519 setdot();
meillo@0 520 #if defined (SU3)
meillo@0 521 if (addr1 == zero) {
meillo@0 522 if (addr1 == addr2)
meillo@0 523 addr2++;
meillo@0 524 addr1++;
meillo@0 525 if (dol != zero)
meillo@0 526 nonzero();
meillo@0 527 } else
meillo@0 528 #endif /* SU3 */
meillo@0 529 nonzero();
meillo@0 530 newline();
meillo@0 531 checkpoint();
meillo@0 532 append(gettty, addr2-1);
meillo@0 533 if (dot == addr2-1)
meillo@0 534 dot++;
meillo@0 535 continue;
meillo@0 536
meillo@0 537
meillo@0 538 case 'j':
meillo@0 539 if (addr2==0) {
meillo@0 540 addr1 = dot;
meillo@0 541 addr2 = dot+1;
meillo@0 542 }
meillo@0 543 setdot();
meillo@0 544 newline();
meillo@0 545 nonzero();
meillo@0 546 checkpoint();
meillo@0 547 if (addr1 != addr2)
meillo@0 548 join();
meillo@0 549 continue;
meillo@0 550
meillo@0 551 case 'k':
meillo@0 552 if ((c = getchr()) < 'a' || c > 'z')
meillo@0 553 error("mark not lower case");
meillo@0 554 newline();
meillo@0 555 setdot();
meillo@0 556 nonzero();
meillo@0 557 names[c-'a'] = *addr2 & ~01;
meillo@0 558 anymarks |= 01;
meillo@0 559 continue;
meillo@0 560
meillo@0 561 case 'm':
meillo@0 562 move(0);
meillo@0 563 continue;
meillo@0 564
meillo@0 565 case '\n':
meillo@0 566 if (addr2==0)
meillo@0 567 addr2 = dot+1;
meillo@0 568 addr1 = addr2;
meillo@0 569 goto print;
meillo@0 570
meillo@0 571 case 'n':
meillo@0 572 numbf = 1;
meillo@0 573 newline();
meillo@0 574 goto print;
meillo@0 575
meillo@0 576 case 'N':
meillo@0 577 newline();
meillo@0 578 setnoaddr();
meillo@0 579 Nflag = !Nflag;
meillo@0 580 continue;
meillo@0 581
meillo@0 582 case 'b':
meillo@0 583 case 'o':
meillo@0 584 n = getnum();
meillo@0 585 newline();
meillo@0 586 setdot();
meillo@0 587 nonzero();
meillo@0 588 if (n >= 0) {
meillo@0 589 if (c == 'b')
meillo@0 590 bcount = n;
meillo@0 591 else
meillo@0 592 ocount = n;
meillo@0 593 }
meillo@0 594 if (c == 'b') {
meillo@0 595 a1 = addr2+bcount > dol ? dol : addr2 + bcount;
meillo@0 596 doprnt(addr1, a1);
meillo@0 597 dot = a1;
meillo@0 598 } else {
meillo@0 599 a1 = addr2+ocount > dol ? dol : addr2 + ocount;
meillo@0 600 doprnt(addr2-ocount<zero+1?zero+1:addr2-ocount, a1);
meillo@0 601 dot = addr2;
meillo@0 602 }
meillo@0 603 continue;
meillo@0 604
meillo@0 605 case 'l':
meillo@0 606 listf++;
meillo@0 607 case 'p':
meillo@0 608 newline();
meillo@0 609 print:
meillo@0 610 setdot();
meillo@0 611 nonzero();
meillo@0 612 doprnt(addr1, addr2);
meillo@0 613 dot = addr2;
meillo@0 614 continue;
meillo@0 615
meillo@0 616 case 'P':
meillo@0 617 setnoaddr();
meillo@0 618 newline();
meillo@0 619 Pflag = !Pflag;
meillo@0 620 continue;
meillo@0 621
meillo@0 622 case 'Q':
meillo@0 623 fchange = 0;
meillo@0 624 case 'q':
meillo@0 625 setnoaddr();
meillo@0 626 newline();
meillo@0 627 quit(0);
meillo@0 628
meillo@0 629 case 'r':
meillo@0 630 filename(c);
meillo@0 631 caseread:
meillo@0 632 if ((io = sopen(file, READ)) < 0) {
meillo@0 633 lastc = '\n';
meillo@0 634 error2("cannot open input file", file);
meillo@0 635 }
meillo@0 636 ioeof = 0;
meillo@0 637 setall();
meillo@0 638 ninbuf = 0;
meillo@0 639 if (c == 'r')
meillo@0 640 checkpoint();
meillo@0 641 n = zero != dol;
meillo@0 642 rspec = (c == 'e' || !n) && file[0] != '!';
meillo@0 643 append(getfile, addr2);
meillo@0 644 rspec = 0;
meillo@0 645 exfile();
meillo@0 646 fchange = n;
meillo@0 647 continue;
meillo@0 648
meillo@0 649 case 's':
meillo@0 650 setdot();
meillo@0 651 nonzero();
meillo@0 652 substitute(globp!=0);
meillo@0 653 continue;
meillo@0 654
meillo@0 655 case 't':
meillo@0 656 move(1);
meillo@0 657 continue;
meillo@0 658
meillo@0 659 case 'u':
meillo@0 660 setdot();
meillo@0 661 newline();
meillo@0 662 if (unddot == NULL)
meillo@0 663 error("nothing to undo");
meillo@0 664 undo();
meillo@0 665 continue;
meillo@0 666
meillo@0 667 case 'v':
meillo@0 668 global(0, 0);
meillo@0 669 continue;
meillo@0 670
meillo@0 671 case 'V':
meillo@0 672 global(0, 1);
meillo@0 673 continue;
meillo@0 674
meillo@0 675 case 'W':
meillo@0 676 wrapp++;
meillo@0 677 case 'w':
meillo@0 678 write:
meillo@0 679 setall();
meillo@0 680 if (zero != dol)
meillo@0 681 nonzero();
meillo@0 682 filename(c);
meillo@0 683 if(!wrapp ||
meillo@0 684 ((io = open(file,O_WRONLY|O_APPEND)) == -1) ||
meillo@0 685 ((lseek(io, 0, SEEK_END)) == -1)) {
meillo@0 686 struct stat st;
meillo@0 687 if (lstat(file, &st) == 0 &&
meillo@0 688 (st.st_mode&S_IFMT) == S_IFREG &&
meillo@0 689 st.st_nlink == 1 &&
meillo@0 690 (myuid==0 || myuid==st.st_uid)) {
meillo@0 691 char *cp, *tp;
meillo@0 692 int nio;
meillo@0 693 if ((io = sopen(file, EXIST)) < 0)
meillo@0 694 error("cannot create output file");
meillo@0 695 if ((wrtemp = malloc(strlen(file)+8)) == NULL)
meillo@0 696 error("out of memory");
meillo@0 697 for (cp = file, tp = wrtemp; *cp; cp++)
meillo@0 698 *tp++ = *cp;
meillo@0 699 while (tp > wrtemp && tp[-1] != '/')
meillo@0 700 tp--;
meillo@0 701 for (cp = "\7XXXXXX"; *cp; cp++)
meillo@0 702 *tp++ = *cp;
meillo@0 703 *tp = '\0';
meillo@0 704 if ((nio = mkstemp(wrtemp)) < 0) {
meillo@0 705 free(wrtemp);
meillo@0 706 wrtemp = NULL;
meillo@0 707 ftruncate(io, 0);
meillo@0 708 } else {
meillo@0 709 close(io);
meillo@0 710 io = nio;
meillo@0 711 }
meillo@0 712 } else {
meillo@0 713 if ((io = sopen(file, WRITE)) < 0)
meillo@0 714 error("cannot create output file");
meillo@0 715 }
meillo@0 716 }
meillo@0 717 if (zero != dol) {
meillo@0 718 ioeof = 0;
meillo@0 719 wrapp = 0;
meillo@0 720 putfile();
meillo@0 721 }
meillo@0 722 exfile();
meillo@0 723 if (addr1==zero+1 && addr2==dol || addr1==addr2 && dol==zero)
meillo@0 724 fchange = 0;
meillo@0 725 if (c == 'z')
meillo@0 726 quit(0);
meillo@0 727 continue;
meillo@0 728
meillo@0 729 case 'z':
meillo@0 730 if ((peekc=getchr()) != '\n')
meillo@0 731 error("illegal suffix");
meillo@0 732 setnoaddr();
meillo@0 733 goto write;
meillo@0 734
meillo@0 735 case '=':
meillo@0 736 setall();
meillo@0 737 newline();
meillo@0 738 putd((addr2-zero)&MAXCNT);
meillo@0 739 putchr('\n');
meillo@0 740 continue;
meillo@0 741
meillo@0 742 case '!':
meillo@0 743 callunix();
meillo@0 744 continue;
meillo@0 745
meillo@0 746 case EOF:
meillo@0 747 return;
meillo@0 748
meillo@0 749 }
meillo@0 750 error("unknown command");
meillo@0 751 }
meillo@0 752 }
meillo@0 753
meillo@0 754 static long *
meillo@0 755 address(void)
meillo@0 756 {
meillo@0 757 register long *a1;
meillo@0 758 register int minus, c;
meillo@0 759 int n, relerr;
meillo@0 760
meillo@0 761 minus = 0;
meillo@0 762 a1 = 0;
meillo@0 763 for (;;) {
meillo@0 764 c = getchr();
meillo@0 765 if ('0'<=c && c<='9') {
meillo@0 766 n = 0;
meillo@0 767 do {
meillo@0 768 n *= 10;
meillo@0 769 n += c - '0';
meillo@0 770 } while ((c = getchr())>='0' && c<='9');
meillo@0 771 peekc = c;
meillo@0 772 if (a1==0)
meillo@0 773 a1 = zero;
meillo@0 774 if (minus<0)
meillo@0 775 n = -n;
meillo@0 776 a1 += n;
meillo@0 777 minus = 0;
meillo@0 778 continue;
meillo@0 779 }
meillo@0 780 relerr = 0;
meillo@0 781 if (a1 || minus)
meillo@0 782 relerr++;
meillo@0 783 switch(c) {
meillo@0 784 case ' ':
meillo@0 785 case '\t':
meillo@0 786 continue;
meillo@0 787
meillo@0 788 case '+':
meillo@0 789 minus++;
meillo@0 790 if (a1==0)
meillo@0 791 a1 = dot;
meillo@0 792 continue;
meillo@0 793
meillo@0 794 case '-':
meillo@0 795 case '^':
meillo@0 796 minus--;
meillo@0 797 if (a1==0)
meillo@0 798 a1 = dot;
meillo@0 799 continue;
meillo@0 800
meillo@0 801 case '?':
meillo@0 802 case '/':
meillo@0 803 compile(NULL, expbuf, &expbuf[ESIZE], c);
meillo@0 804 a1 = dot;
meillo@0 805 for (;;) {
meillo@0 806 if (c=='/') {
meillo@0 807 a1++;
meillo@0 808 if (a1 > dol)
meillo@0 809 a1 = zero;
meillo@0 810 } else {
meillo@0 811 a1--;
meillo@0 812 if (a1 < zero)
meillo@0 813 a1 = dol;
meillo@0 814 }
meillo@0 815 if (execute(0, a1, 0))
meillo@0 816 break;
meillo@0 817 if (a1==dot)
meillo@0 818 error("search string not found");
meillo@0 819 }
meillo@0 820 break;
meillo@0 821
meillo@0 822 case '$':
meillo@0 823 a1 = dol;
meillo@0 824 break;
meillo@0 825
meillo@0 826 case '.':
meillo@0 827 a1 = dot;
meillo@0 828 break;
meillo@0 829
meillo@0 830 case '\'':
meillo@0 831 if ((c = getchr()) < 'a' || c > 'z')
meillo@0 832 error("mark not lower case");
meillo@0 833 for (a1=zero; a1<=dol; a1++)
meillo@0 834 if (names[c-'a'] == (*a1 & ~01))
meillo@0 835 break;
meillo@0 836 break;
meillo@0 837
meillo@0 838 default:
meillo@0 839 peekc = c;
meillo@0 840 if (a1==0)
meillo@0 841 return(0);
meillo@0 842 a1 += minus;
meillo@0 843 if (a1<zero || a1>dol)
meillo@0 844 error("line out of range");
meillo@0 845 return(a1);
meillo@0 846 }
meillo@0 847 if (relerr)
meillo@0 848 error("bad number");
meillo@0 849 }
meillo@0 850 }
meillo@0 851
meillo@0 852 static void
meillo@0 853 setdot(void)
meillo@0 854 {
meillo@0 855 if (addr2 == 0)
meillo@0 856 addr1 = addr2 = dot;
meillo@0 857 if (addr1 > addr2)
meillo@0 858 error("bad range");
meillo@0 859 }
meillo@0 860
meillo@0 861 static void
meillo@0 862 setall(void)
meillo@0 863 {
meillo@0 864 if (addr2==0) {
meillo@0 865 addr1 = zero+1;
meillo@0 866 addr2 = dol;
meillo@0 867 if (dol==zero)
meillo@0 868 addr1 = zero;
meillo@0 869 }
meillo@0 870 setdot();
meillo@0 871 }
meillo@0 872
meillo@0 873 static void
meillo@0 874 setnoaddr(void)
meillo@0 875 {
meillo@0 876 if (addr2)
meillo@0 877 error("Illegal address count");
meillo@0 878 }
meillo@0 879
meillo@0 880 static void
meillo@0 881 nonzero(void)
meillo@0 882 {
meillo@0 883 if (addr1<=zero || addr2>dol)
meillo@0 884 error("line out of range");
meillo@0 885 }
meillo@0 886
meillo@0 887 static void
meillo@0 888 newline(void)
meillo@0 889 {
meillo@0 890 register int c;
meillo@0 891
meillo@0 892 if ((c = getchr()) == '\n')
meillo@0 893 return;
meillo@0 894 if (c=='p' || c=='l' || c=='n') {
meillo@0 895 pflag++;
meillo@0 896 if (c=='l')
meillo@0 897 listf++;
meillo@0 898 else if (c=='n')
meillo@0 899 numbf = 1;
meillo@0 900 if (getchr() == '\n')
meillo@0 901 return;
meillo@0 902 }
meillo@0 903 error("illegal suffix");
meillo@0 904 }
meillo@0 905
meillo@0 906 static void
meillo@0 907 filename(int comm)
meillo@0 908 {
meillo@0 909 register char *p1, *p2;
meillo@0 910 register int c, i;
meillo@0 911
meillo@0 912 count = 0;
meillo@0 913 c = getchr();
meillo@0 914 if (c=='\n' || c==EOF) {
meillo@0 915 p1 = savedfile;
meillo@0 916 if (*p1==0 && comm!='f')
meillo@0 917 error("illegal or missing filename");
meillo@0 918 p2 = file;
meillo@0 919 while (*p2++ = *p1++)
meillo@0 920 ;
meillo@0 921 return;
meillo@0 922 }
meillo@0 923 if (c!=' ')
meillo@0 924 error("no space after command");
meillo@0 925 while ((c = getchr()) == ' ')
meillo@0 926 ;
meillo@0 927 if (c=='\n')
meillo@0 928 error("illegal or missing filename");
meillo@0 929 i = 0;
meillo@0 930 do {
meillo@0 931 if (i >= FNSIZE)
meillo@0 932 growfn("maximum of characters in file names reached");
meillo@0 933 file[i++] = c;
meillo@0 934 if (c==' ' && file[0] != '!' || c==EOF)
meillo@0 935 error("illegal or missing filename");
meillo@0 936 } while ((c = getchr()) != '\n');
meillo@0 937 file[i++] = 0;
meillo@0 938 if ((savedfile[0]==0 || comm=='e' || comm=='f') && file[0] != '!') {
meillo@0 939 p1 = savedfile;
meillo@0 940 p2 = file;
meillo@0 941 while (*p1++ = *p2++)
meillo@0 942 ;
meillo@0 943 }
meillo@0 944 }
meillo@0 945
meillo@0 946 static void
meillo@0 947 exfile(void)
meillo@0 948 {
meillo@0 949 sclose(io);
meillo@0 950 io = -1;
meillo@0 951 if (wrtemp) {
meillo@0 952 extern int rename(const char *, const char *);
meillo@0 953 if (rename(wrtemp, file) < 0)
meillo@0 954 error("cannot create output file");
meillo@0 955 if (myuid == 0)
meillo@0 956 chown(file, fstbuf.st_uid, fstbuf.st_gid);
meillo@0 957 chmod(file, fstbuf.st_mode & 07777);
meillo@0 958 free(wrtemp);
meillo@0 959 wrtemp = NULL;
meillo@0 960 }
meillo@0 961 if (vflag) {
meillo@0 962 putd(count);
meillo@0 963 putchr('\n');
meillo@0 964 }
meillo@0 965 }
meillo@0 966
meillo@0 967 static void
meillo@0 968 onintr(int signo)
meillo@0 969 {
meillo@0 970 lastsig = signo;
meillo@0 971 putchr('\n');
meillo@0 972 lastc = '\n';
meillo@0 973 if (readop) {
meillo@0 974 puts("\007read may be incomplete - beware!\007");
meillo@0 975 fchange = 0;
meillo@0 976 }
meillo@0 977 error("interrupt");
meillo@0 978 }
meillo@0 979
meillo@0 980 static void
meillo@0 981 onhup(int signo)
meillo@0 982 {
meillo@0 983 if (dol > zero && fchange) {
meillo@0 984 addr1 = zero+1;
meillo@0 985 addr2 = dol;
meillo@0 986 io = creat("ed.hup", 0666);
meillo@0 987 if (io < 0) {
meillo@0 988 char *home = getenv("HOME");
meillo@0 989 if (home) {
meillo@0 990 char *fn = malloc(strlen(home) + 10);
meillo@0 991 if (fn) {
meillo@0 992 strcpy(fn, home);
meillo@0 993 strcat(fn, "/ed.hup");
meillo@0 994 io = creat(fn, 0666);
meillo@0 995 }
meillo@0 996 }
meillo@0 997 }
meillo@0 998 if (io >= 0)
meillo@0 999 putfile();
meillo@0 1000 }
meillo@0 1001 fchange = 0;
meillo@0 1002 status = 0200 | signo;
meillo@0 1003 quit(0);
meillo@0 1004 }
meillo@0 1005
meillo@0 1006 static void
meillo@0 1007 onpipe(int signo)
meillo@0 1008 {
meillo@0 1009 lastsig = signo;
meillo@0 1010 error("write or open on pipe failed");
meillo@0 1011 }
meillo@0 1012
meillo@0 1013 static void
meillo@0 1014 error(const char *s)
meillo@0 1015 {
meillo@0 1016 error2(s, NULL);
meillo@0 1017 }
meillo@0 1018
meillo@0 1019 static void
meillo@0 1020 error2(const char *s, const char *fn)
meillo@0 1021 {
meillo@0 1022 register int c;
meillo@0 1023
meillo@0 1024 wrapp = 0;
meillo@0 1025 listf = 0;
meillo@0 1026 numbf = 0;
meillo@0 1027 errput(s, fn);
meillo@0 1028 count = 0;
meillo@0 1029 if (lseek(0, 0, SEEK_END) > 0)
meillo@0 1030 status = 2;
meillo@0 1031 pflag = 0;
meillo@0 1032 if (globp)
meillo@0 1033 lastc = '\n';
meillo@0 1034 globp = 0;
meillo@0 1035 peekc = lastc;
meillo@0 1036 if(lastc)
meillo@0 1037 while ((c = getchr()) != '\n' && c != EOF)
meillo@0 1038 ;
meillo@0 1039 if (io > 0) {
meillo@0 1040 sclose(io);
meillo@0 1041 io = -1;
meillo@0 1042 }
meillo@0 1043 if (wrtemp) {
meillo@0 1044 unlink(wrtemp);
meillo@0 1045 free(wrtemp);
meillo@0 1046 wrtemp = NULL;
meillo@0 1047 }
meillo@0 1048 longjmp(savej, 1);
meillo@0 1049 }
meillo@0 1050
meillo@0 1051 static void
meillo@0 1052 errput(const char *s, const char *fn)
meillo@0 1053 {
meillo@0 1054 prvmsg = s;
meillo@0 1055 if (fn) {
meillo@0 1056 putchr('?');
meillo@0 1057 puts(fn);
meillo@0 1058 } else
meillo@0 1059 puts("?");
meillo@0 1060 if (prhelp)
meillo@0 1061 puts(s);
meillo@0 1062 }
meillo@0 1063
meillo@0 1064 static int
meillo@0 1065 getchr(void)
meillo@0 1066 {
meillo@0 1067 char c;
meillo@0 1068 if (lastc=peekc) {
meillo@0 1069 peekc = 0;
meillo@0 1070 return(lastc);
meillo@0 1071 }
meillo@0 1072 if (globp) {
meillo@0 1073 if ((lastc = *globp++) != 0)
meillo@0 1074 return(lastc);
meillo@0 1075 globp = 0;
meillo@0 1076 return(EOF);
meillo@0 1077 }
meillo@0 1078 if (read(0, &c, 1) <= 0)
meillo@0 1079 return(lastc = EOF);
meillo@0 1080 lastc = c;
meillo@0 1081 return(lastc);
meillo@0 1082 }
meillo@0 1083
meillo@0 1084 static int
meillo@0 1085 gettty(void)
meillo@0 1086 {
meillo@0 1087 register int c, i;
meillo@0 1088 register char *gf;
meillo@0 1089
meillo@0 1090 i = 0;
meillo@0 1091 gf = globp;
meillo@0 1092 while ((c = getchr()) != '\n') {
meillo@0 1093 if (c==EOF) {
meillo@0 1094 if (gf)
meillo@0 1095 peekc = c;
meillo@0 1096 return(c);
meillo@0 1097 }
meillo@0 1098 if (c == 0)
meillo@0 1099 continue;
meillo@0 1100 if (i >= LBSIZE)
meillo@0 1101 growlb("line too long");
meillo@0 1102 linebuf[i++] = c;
meillo@0 1103 }
meillo@0 1104 if (i >= LBSIZE-2)
meillo@0 1105 growlb("line too long");
meillo@0 1106 linebuf[i++] = 0;
meillo@0 1107 if (linebuf[0]=='.' && linebuf[1]==0)
meillo@0 1108 return(EOF);
meillo@0 1109 #if !defined (SUS) && !defined (SU3)
meillo@0 1110 if (linebuf[0]=='\\' && linebuf[1]=='.' && linebuf[2]==0)
meillo@0 1111 linebuf[0]='.', linebuf[1]=0;
meillo@0 1112 #endif
meillo@0 1113 return(0);
meillo@0 1114 }
meillo@0 1115
meillo@0 1116 static long
meillo@0 1117 getnum(void)
meillo@0 1118 {
meillo@0 1119 char scount[20];
meillo@0 1120 int i;
meillo@0 1121
meillo@0 1122 i = 0;
meillo@0 1123 while ((peekc=getchr()) >= '0' && peekc <= '9' && i < sizeof scount) {
meillo@0 1124 scount[i++] = peekc;
meillo@0 1125 peekc = 0;
meillo@0 1126 }
meillo@0 1127 scount[i] = '\0';
meillo@0 1128 return i ? atol(scount) : -1;
meillo@0 1129 }
meillo@0 1130
meillo@0 1131 static int
meillo@0 1132 getfile(void)
meillo@0 1133 {
meillo@0 1134 register int c, i, j;
meillo@0 1135 static int nextj;
meillo@0 1136
meillo@0 1137 i = 0;
meillo@0 1138 j = nextj;
meillo@0 1139 do {
meillo@0 1140 if (--ninbuf < 0) {
meillo@0 1141 if (ioeof || (ninbuf=read(io, genbuf, LBSIZE)-1) < 0) {
meillo@0 1142 if (ioeof == 0 && ninbuf < -1) {
meillo@0 1143 puts("input error");
meillo@0 1144 status = 1;
meillo@0 1145 }
meillo@0 1146 if (i > 0) {
meillo@0 1147 puts("'\\n' appended");
meillo@0 1148 c = '\n';
meillo@0 1149 ioeof = 1;
meillo@0 1150 goto wrc;
meillo@0 1151 }
meillo@0 1152 return(EOF);
meillo@0 1153 }
meillo@0 1154 j = 0;
meillo@0 1155 }
meillo@0 1156 c = genbuf[j++]&0377;
meillo@0 1157 wrc: if (i >= LBSIZE) {
meillo@0 1158 lastc = '\n';
meillo@0 1159 growlb("line too long");
meillo@0 1160 }
meillo@0 1161 linebuf[i++] = c ? c : '\n';
meillo@0 1162 count++;
meillo@0 1163 } while (c != '\n');
meillo@0 1164 linebuf[--i] = 0;
meillo@0 1165 nextj = j;
meillo@0 1166 if (rspec && dot == zero)
meillo@0 1167 fspec(linebuf);
meillo@0 1168 if (maxlength && i > maxlength) {
meillo@0 1169 putstr("line too long: lno = ");
meillo@0 1170 putd((dot - zero+1)&MAXCNT);
meillo@0 1171 putchr('\n');
meillo@0 1172 }
meillo@0 1173 return(0);
meillo@0 1174 }
meillo@0 1175
meillo@0 1176 static void
meillo@0 1177 putfile(void)
meillo@0 1178 {
meillo@0 1179 long *a1;
meillo@0 1180 int n;
meillo@0 1181 register char *fp, *lp;
meillo@0 1182 register int nib;
meillo@0 1183
meillo@0 1184 nib = 512;
meillo@0 1185 fp = genbuf;
meillo@0 1186 a1 = addr1;
meillo@0 1187 do {
meillo@0 1188 lp = getline(*a1++, 0);
meillo@0 1189 if (maxlength) {
meillo@0 1190 for (n = 0; lp[n]; n++);
meillo@0 1191 if (n > maxlength) {
meillo@0 1192 putstr("line too long: lno = ");
meillo@0 1193 putd((a1-1 - zero)&MAXCNT);
meillo@0 1194 putchr('\n');
meillo@0 1195 }
meillo@0 1196 }
meillo@0 1197 for (;;) {
meillo@0 1198 if (--nib < 0) {
meillo@0 1199 n = fp-genbuf;
meillo@0 1200 if(write(io, genbuf, n) != n)
meillo@0 1201 error("write error");
meillo@0 1202 nib = 511;
meillo@0 1203 fp = genbuf;
meillo@0 1204 }
meillo@0 1205 count++;
meillo@0 1206 if ((*fp++ = *lp++) == 0) {
meillo@0 1207 fp[-1] = '\n';
meillo@0 1208 break;
meillo@0 1209 } else if (fp[-1] == '\n')
meillo@0 1210 fp[-1] = '\0';
meillo@0 1211 }
meillo@0 1212 } while (a1 <= addr2);
meillo@0 1213 n = fp-genbuf;
meillo@0 1214 if(write(io, genbuf, n) != n)
meillo@0 1215 error("write error");
meillo@0 1216 }
meillo@0 1217
meillo@0 1218 static int
meillo@0 1219 append(int (*f)(void), long *a)
meillo@0 1220 {
meillo@0 1221 register long *a1, *a2, *rdot;
meillo@0 1222 int nline, tl;
meillo@0 1223
meillo@0 1224 nline = 0;
meillo@0 1225 dot = a;
meillo@0 1226 while ((*f)() == 0) {
meillo@0 1227 if ((dol-zero)+1 >= nlall) {
meillo@0 1228 long *ozero = zero;
meillo@0 1229 nlall += 512;
meillo@0 1230 if ((zero = realloc(zero, nlall*sizeof *zero))==NULL) {
meillo@0 1231 lastc = '\n';
meillo@0 1232 zero = ozero;
meillo@0 1233 error("out of memory for append");
meillo@0 1234 }
meillo@0 1235 dot += zero - ozero;
meillo@0 1236 dol += zero - ozero;
meillo@0 1237 addr1 += zero - ozero;
meillo@0 1238 addr2 += zero - ozero;
meillo@0 1239 if (unddot) {
meillo@0 1240 unddot += zero - ozero;
meillo@0 1241 unddol += zero - ozero;
meillo@0 1242 }
meillo@0 1243 if (undzero) {
meillo@0 1244 ozero = undzero;
meillo@0 1245 if ((undzero = realloc(undzero,
meillo@0 1246 nlall*sizeof *undzero)) == 0) {
meillo@0 1247 puts("no memory for undo");
meillo@0 1248 free(ozero);
meillo@0 1249 }
meillo@0 1250 }
meillo@0 1251 }
meillo@0 1252 tl = putline();
meillo@0 1253 nline++;
meillo@0 1254 a1 = ++dol;
meillo@0 1255 a2 = a1+1;
meillo@0 1256 rdot = ++dot;
meillo@0 1257 while (a1 > rdot)
meillo@0 1258 *--a2 = *--a1;
meillo@0 1259 *rdot = tl;
meillo@0 1260 }
meillo@0 1261 return(nline);
meillo@0 1262 }
meillo@0 1263
meillo@0 1264 static void
meillo@0 1265 callunix(void)
meillo@0 1266 {
meillo@0 1267 char *line;
meillo@0 1268 void (*savint)(int);
meillo@0 1269 pid_t pid, rpid;
meillo@0 1270 int retcode;
meillo@0 1271
meillo@0 1272 setnoaddr();
meillo@0 1273 line = readcmd();
meillo@0 1274 if ((pid = fork()) == 0) {
meillo@0 1275 sigset(SIGHUP, oldhup);
meillo@0 1276 sigset(SIGQUIT, oldquit);
meillo@0 1277 sigset(SIGPIPE, oldpipe);
meillo@0 1278 execl(SHELL, "sh", "-c", line, NULL);
meillo@0 1279 _exit(0100);
meillo@0 1280 } else if (pid < 0)
meillo@0 1281 error("fork failed - try again");
meillo@0 1282 savint = sigset(SIGINT, SIG_IGN);
meillo@0 1283 while ((rpid = wait(&retcode)) != pid && rpid != -1)
meillo@0 1284 ;
meillo@0 1285 sigset(SIGINT, savint);
meillo@0 1286 if (vflag)
meillo@0 1287 puts("!");
meillo@0 1288 }
meillo@0 1289
meillo@0 1290 #define cmadd(c) ((i>=cmsize ? \
meillo@0 1291 ((line=realloc(line,cmsize+=128)) == 0 ? \
meillo@0 1292 (error("line too long"),0) : 0, 0) \
meillo@0 1293 : 0), line[i++]=(c))
meillo@0 1294
meillo@0 1295 static char *
meillo@0 1296 readcmd(void)
meillo@0 1297 {
meillo@0 1298 static char *line, *prev;
meillo@0 1299 static int cmsize, pvsize;
meillo@0 1300 char *pp;
meillo@0 1301 int c, mod = 0, i;
meillo@0 1302
meillo@0 1303 i = 0;
meillo@0 1304 if ((c = getchr()) == '!') {
meillo@0 1305 for (pp = prev; *pp; pp++)
meillo@0 1306 line[i++] = *pp;
meillo@0 1307 mod = 1;
meillo@0 1308 c = getchr();
meillo@0 1309 }
meillo@0 1310 while (c != '\n' && c != EOF) {
meillo@0 1311 if (c == '\\') {
meillo@0 1312 c = getchr();
meillo@0 1313 if (c != '%')
meillo@0 1314 cmadd('\\');
meillo@0 1315 cmadd(c);
meillo@0 1316 } else if (c == '%') {
meillo@0 1317 for (pp = savedfile; *pp; pp++)
meillo@0 1318 cmadd(*pp);
meillo@0 1319 mod = 1;
meillo@0 1320 } else
meillo@0 1321 cmadd(c);
meillo@0 1322 c = getchr();
meillo@0 1323 }
meillo@0 1324 cmadd('\0');
meillo@0 1325 if (pvsize < cmsize && (prev = realloc(prev, pvsize=cmsize)) == 0)
meillo@0 1326 error("line too long");
meillo@0 1327 strcpy(prev, line);
meillo@0 1328 if (mod)
meillo@0 1329 nlputs(line);
meillo@0 1330 return line;
meillo@0 1331 }
meillo@0 1332
meillo@0 1333 static void
meillo@0 1334 quit(int signo)
meillo@0 1335 {
meillo@0 1336 lastsig = signo;
meillo@0 1337 if (vflag && fchange) {
meillo@0 1338 fchange = 0;
meillo@0 1339 error("warning: expecting `w'");
meillo@0 1340 }
meillo@0 1341 if (wrtemp)
meillo@0 1342 unlink(wrtemp);
meillo@0 1343 unlink(tfname);
meillo@0 1344 exit(status);
meillo@0 1345 }
meillo@0 1346
meillo@0 1347 static void
meillo@0 1348 delete(void)
meillo@0 1349 {
meillo@0 1350 setdot();
meillo@0 1351 newline();
meillo@0 1352 nonzero();
meillo@0 1353 checkpoint();
meillo@0 1354 rdelete(addr1, addr2);
meillo@0 1355 }
meillo@0 1356
meillo@0 1357 static void
meillo@0 1358 rdelete(long *ad1, long *ad2)
meillo@0 1359 {
meillo@0 1360 register long *a1, *a2, *a3;
meillo@0 1361
meillo@0 1362 a1 = ad1;
meillo@0 1363 a2 = ad2+1;
meillo@0 1364 a3 = dol;
meillo@0 1365 dol -= a2 - a1;
meillo@0 1366 do {
meillo@0 1367 *a1++ = *a2++;
meillo@0 1368 } while (a2 <= a3);
meillo@0 1369 a1 = ad1;
meillo@0 1370 if (a1 > dol)
meillo@0 1371 a1 = dol;
meillo@0 1372 dot = a1;
meillo@0 1373 fchange = 1;
meillo@0 1374 }
meillo@0 1375
meillo@0 1376 static void
meillo@0 1377 gdelete(void)
meillo@0 1378 {
meillo@0 1379 register long *a1, *a2, *a3;
meillo@0 1380
meillo@0 1381 a3 = dol;
meillo@0 1382 for (a1=zero+1; (*a1&01)==0; a1++)
meillo@0 1383 if (a1>=a3)
meillo@0 1384 return;
meillo@0 1385 for (a2=a1+1; a2<=a3;) {
meillo@0 1386 if (*a2&01) {
meillo@0 1387 a2++;
meillo@0 1388 dot = a1;
meillo@0 1389 } else
meillo@0 1390 *a1++ = *a2++;
meillo@0 1391 }
meillo@0 1392 dol = a1-1;
meillo@0 1393 if (dot>dol)
meillo@0 1394 dot = dol;
meillo@0 1395 fchange = 1;
meillo@0 1396 }
meillo@0 1397
meillo@0 1398 static char *
meillo@0 1399 getline(long tl, int nulterm)
meillo@0 1400 {
meillo@0 1401 register char *bp, *lp;
meillo@0 1402 register long nl;
meillo@0 1403
meillo@0 1404 lp = linebuf;
meillo@0 1405 bp = getblock(tl, READ);
meillo@0 1406 nl = nleft;
meillo@0 1407 tl &= ~0377;
meillo@0 1408 while (*lp++ = *bp++) {
meillo@0 1409 if (lp[-1] == '\n' && nulterm) {
meillo@0 1410 lp[-1] = '\0';
meillo@0 1411 break;
meillo@0 1412 }
meillo@0 1413 if (--nl == 0) {
meillo@0 1414 bp = getblock(tl+=0400, READ);
meillo@0 1415 nl = nleft;
meillo@0 1416 }
meillo@0 1417 }
meillo@0 1418 return(linebuf);
meillo@0 1419 }
meillo@0 1420
meillo@0 1421 static int
meillo@0 1422 putline(void)
meillo@0 1423 {
meillo@0 1424 register char *bp, *lp;
meillo@0 1425 register long nl;
meillo@0 1426 long tl;
meillo@0 1427
meillo@0 1428 fchange = 1;
meillo@0 1429 lp = linebuf;
meillo@0 1430 tl = tline;
meillo@0 1431 bp = getblock(tl, WRITE);
meillo@0 1432 nl = nleft;
meillo@0 1433 tl &= ~0377;
meillo@0 1434 while (*bp = *lp++) {
meillo@0 1435 if (*bp++ == '\n' && insub) {
meillo@0 1436 *--bp = 0;
meillo@0 1437 linebp = lp;
meillo@0 1438 break;
meillo@0 1439 }
meillo@0 1440 if (--nl == 0) {
meillo@0 1441 bp = getblock(tl+=0400, WRITE);
meillo@0 1442 nl = nleft;
meillo@0 1443 }
meillo@0 1444 }
meillo@0 1445 nl = tline;
meillo@0 1446 tline += (((lp-linebuf)+03)>>1)&(MAXCNT-1);
meillo@0 1447 return(nl);
meillo@0 1448 }
meillo@0 1449
meillo@0 1450 static char *
meillo@0 1451 getblock(long atl, long iof)
meillo@0 1452 {
meillo@0 1453 register long bno, off;
meillo@0 1454
meillo@0 1455 bno = (atl>>8)&BLKMSK;
meillo@0 1456 off = (atl<<1)&0774;
meillo@0 1457 if (bno >= BLKMSK) {
meillo@0 1458 lastc = '\n';
meillo@0 1459 error("temp file too big");
meillo@0 1460 }
meillo@0 1461 nleft = 512 - off;
meillo@0 1462 if (bno==iblock) {
meillo@0 1463 ichanged |= iof;
meillo@0 1464 return(ibuff+off);
meillo@0 1465 }
meillo@0 1466 if (bno==oblock)
meillo@0 1467 return(obuff+off);
meillo@0 1468 if (iof==READ) {
meillo@0 1469 if (ichanged)
meillo@0 1470 blkio(iblock, ibuff, 1);
meillo@0 1471 ichanged = 0;
meillo@0 1472 iblock = bno;
meillo@0 1473 blkio(bno, ibuff, 0);
meillo@0 1474 return(ibuff+off);
meillo@0 1475 }
meillo@0 1476 if (oblock>=0)
meillo@0 1477 blkio(oblock, obuff, 1);
meillo@0 1478 oblock = bno;
meillo@0 1479 return(obuff+off);
meillo@0 1480 }
meillo@0 1481
meillo@0 1482 static void
meillo@0 1483 blkio(long b, char *buf, int wr)
meillo@0 1484 {
meillo@0 1485 lseek(tfile, b<<9, SEEK_SET);
meillo@0 1486 if ((wr ? write(tfile, buf, 512) : read (tfile, buf, 512)) != 512) {
meillo@0 1487 status = 1;
meillo@0 1488 error("I/O error on temp file");
meillo@0 1489 }
meillo@0 1490 }
meillo@0 1491
meillo@0 1492 static void
meillo@0 1493 init(void)
meillo@0 1494 {
meillo@0 1495 register long *markp;
meillo@0 1496
meillo@0 1497 tline = 2;
meillo@0 1498 for (markp = names; markp < &names[26]; markp++)
meillo@0 1499 *markp = 0;
meillo@0 1500 for (markp = undnames; markp < &undnames[26]; markp++)
meillo@0 1501 *markp = 0;
meillo@0 1502 subnewa = 0;
meillo@0 1503 anymarks = 0;
meillo@0 1504 iblock = -1;
meillo@0 1505 oblock = -1;
meillo@0 1506 ichanged = 0;
meillo@0 1507 tfile = maketf(tfile);
meillo@0 1508 dot = dol = zero;
meillo@0 1509 unddot = NULL;
meillo@0 1510 }
meillo@0 1511
meillo@0 1512 static void
meillo@0 1513 global(int k, int ia)
meillo@0 1514 {
meillo@0 1515 register int c;
meillo@0 1516 register long *a1;
meillo@0 1517 static char *globuf;
meillo@0 1518 char mb[MB_LEN_MAX+1];
meillo@0 1519 int spflag = 0;
meillo@0 1520
meillo@0 1521 if (globp)
meillo@0 1522 error("multiple globals not allowed");
meillo@0 1523 setall();
meillo@0 1524 nonzero();
meillo@0 1525 if ((c=GETWC(mb))=='\n')
meillo@0 1526 error("incomplete global expression");
meillo@0 1527 compile(NULL, expbuf, &expbuf[ESIZE], c);
meillo@0 1528 if (!ia) {
meillo@0 1529 globrd(&globuf, EOF);
meillo@0 1530 if (globuf[0] == '\n')
meillo@0 1531 globuf[0] = 'p', globuf[1] = '\n', globuf[2] = '\0';
meillo@0 1532 } else {
meillo@0 1533 newline();
meillo@0 1534 spflag = pflag;
meillo@0 1535 pflag = 0;
meillo@0 1536 }
meillo@0 1537 checkpoint();
meillo@0 1538 for (a1=zero; a1<=dol; a1++) {
meillo@0 1539 *a1 &= ~01;
meillo@0 1540 if (a1>=addr1 && a1<=addr2 && execute(0, a1, 0)==k)
meillo@0 1541 *a1 |= 01;
meillo@0 1542 }
meillo@0 1543 /*
meillo@0 1544 * Special case: g/.../d (avoid n^2 algorithm)
meillo@0 1545 */
meillo@0 1546 if (!ia && globuf[0]=='d' && globuf[1]=='\n' && globuf[2]=='\0') {
meillo@0 1547 gdelete();
meillo@0 1548 return;
meillo@0 1549 }
meillo@0 1550 for (a1=zero; a1<=dol; a1++) {
meillo@0 1551 if (*a1 & 01) {
meillo@0 1552 *a1 &= ~01;
meillo@0 1553 dot = a1;
meillo@0 1554 if (ia) {
meillo@0 1555 puts(getline(*a1, 0));
meillo@0 1556 if ((c = getchr()) == EOF)
meillo@0 1557 error("command expected");
meillo@0 1558 if (c == 'a' || c == 'c' || c == 'i')
meillo@0 1559 error("a, i, or c not allowed in G");
meillo@0 1560 else if (c == '&') {
meillo@0 1561 if ((c = getchr()) != '\n')
meillo@0 1562 error("end of line expected");
meillo@0 1563 if (globuf == 0 || *globuf == 0)
meillo@0 1564 error("no remembered command");
meillo@0 1565 } else if (c == '\n') {
meillo@0 1566 a1 = zero;
meillo@0 1567 continue;
meillo@0 1568 } else
meillo@0 1569 globrd(&globuf, c);
meillo@0 1570 }
meillo@0 1571 globp = globuf;
meillo@0 1572 commands();
meillo@0 1573 globp = NULL;
meillo@0 1574 a1 = zero;
meillo@0 1575 }
meillo@0 1576 }
meillo@0 1577 if (ia)
meillo@0 1578 pflag = spflag;
meillo@0 1579 }
meillo@0 1580
meillo@0 1581 static void
meillo@0 1582 globrd(char **globuf, register int c)
meillo@0 1583 {
meillo@0 1584 register int i;
meillo@0 1585
meillo@0 1586 if (*globuf == 0 && (*globuf = malloc(GBSIZE=256)) == 0)
meillo@0 1587 error("global too long");
meillo@0 1588 i = 0;
meillo@0 1589 if (c != EOF)
meillo@0 1590 (*globuf)[i++] = c;
meillo@0 1591 while ((c = getchr()) != '\n') {
meillo@0 1592 if (c==EOF)
meillo@0 1593 error("incomplete global expression");
meillo@0 1594 if (c=='\\') {
meillo@0 1595 c = getchr();
meillo@0 1596 if (c!='\n')
meillo@0 1597 (*globuf)[i++] = '\\';
meillo@0 1598 }
meillo@0 1599 (*globuf)[i++] = c;
meillo@0 1600 if (i>=GBSIZE-4 && (*globuf=realloc(*globuf,GBSIZE+=256)) == 0)
meillo@0 1601 error("global too long");
meillo@0 1602 }
meillo@0 1603 (*globuf)[i++] = '\n';
meillo@0 1604 (*globuf)[i++] = 0;
meillo@0 1605 }
meillo@0 1606
meillo@0 1607 static void
meillo@0 1608 join(void)
meillo@0 1609 {
meillo@0 1610 register int i, j;
meillo@0 1611 register long *a1;
meillo@0 1612
meillo@0 1613 j = 0;
meillo@0 1614 for (a1=addr1; a1<=addr2; a1++) {
meillo@0 1615 i = getline(*a1, 0) - linebuf;
meillo@0 1616 while (genbuf[j] = linebuf[i++])
meillo@0 1617 if (j++ >= LBSIZE-2)
meillo@0 1618 growlb("line too long");
meillo@0 1619 }
meillo@0 1620 i = 0;
meillo@0 1621 j = 0;
meillo@0 1622 while (linebuf[i++] = genbuf[j++])
meillo@0 1623 ;
meillo@0 1624 *addr1 = putline();
meillo@0 1625 if (addr1<addr2)
meillo@0 1626 rdelete(addr1+1, addr2);
meillo@0 1627 dot = addr1;
meillo@0 1628 }
meillo@0 1629
meillo@0 1630 static void
meillo@0 1631 substitute(int inglob)
meillo@0 1632 {
meillo@0 1633 register long *markp;
meillo@0 1634 register long *a1;
meillo@0 1635 intptr_t nl;
meillo@0 1636 int gsubf;
meillo@0 1637
meillo@0 1638 checkpoint();
meillo@0 1639 gsubf = compsub();
meillo@0 1640 insub = 1;
meillo@0 1641 for (a1 = addr1; a1 <= addr2; a1++) {
meillo@0 1642 long *ozero;
meillo@0 1643 if (execute(0, a1, 1)==0)
meillo@0 1644 continue;
meillo@0 1645 inglob |= dosub(gsubf < 2);
meillo@0 1646 if (gsubf) {
meillo@0 1647 int i = 1;
meillo@0 1648
meillo@0 1649 while (*loc2) {
meillo@0 1650 if (execute(1, NULL, 1)==0)
meillo@0 1651 break;
meillo@0 1652 inglob |= dosub(gsubf == -1 || ++i == gsubf);
meillo@0 1653 }
meillo@0 1654 }
meillo@0 1655 subnewa = putline();
meillo@0 1656 *a1 &= ~01;
meillo@0 1657 if (anymarks) {
meillo@0 1658 for (markp = names; markp < &names[26]; markp++)
meillo@0 1659 if (*markp == *a1)
meillo@0 1660 *markp = subnewa;
meillo@0 1661 }
meillo@0 1662 *a1 = subnewa;
meillo@0 1663 ozero = zero;
meillo@0 1664 nl = append(getsub, a1);
meillo@0 1665 nl += zero-ozero;
meillo@0 1666 a1 += nl;
meillo@0 1667 addr2 += nl;
meillo@0 1668 }
meillo@0 1669 insub = 0;
meillo@0 1670 if (inglob==0)
meillo@0 1671 error("no match");
meillo@0 1672 }
meillo@0 1673
meillo@0 1674 static int
meillo@0 1675 compsub(void)
meillo@0 1676 {
meillo@0 1677 register int seof, c, i;
meillo@0 1678 static char *oldrhs;
meillo@0 1679 static int orhssz;
meillo@0 1680 char mb[MB_LEN_MAX+1];
meillo@0 1681
meillo@0 1682 if ((seof = GETWC(mb)) == '\n' || seof == ' ')
meillo@0 1683 error("illegal or missing delimiter");
meillo@0 1684 nodelim = 0;
meillo@0 1685 compile(NULL, expbuf, &expbuf[ESIZE], seof);
meillo@0 1686 i = 0;
meillo@0 1687 for (;;) {
meillo@0 1688 c = GETWC(mb);
meillo@0 1689 if (c=='\\') {
meillo@0 1690 if (i >= RHSIZE-2)
meillo@0 1691 growrhs("replacement string too long");
meillo@0 1692 rhsbuf[i++] = c;
meillo@0 1693 c = GETWC(mb);
meillo@0 1694 } else if (c=='\n') {
meillo@0 1695 if (globp && *globp) {
meillo@0 1696 if (i >= RHSIZE-2)
meillo@0 1697 growrhs("replacement string too long");
meillo@0 1698 rhsbuf[i++] = '\\';
meillo@0 1699 }
meillo@0 1700 else if (nodelim)
meillo@0 1701 error("illegal or missing delimiter");
meillo@0 1702 else {
meillo@0 1703 peekc = c;
meillo@0 1704 pflag++;
meillo@0 1705 break;
meillo@0 1706 }
meillo@0 1707 } else if (c==seof)
meillo@0 1708 break;
meillo@0 1709 for (c = 0; c==0 || mb[c]; c++) {
meillo@0 1710 if (i >= RHSIZE-2)
meillo@0 1711 growrhs("replacement string too long");
meillo@0 1712 rhsbuf[i++] = mb[c];
meillo@0 1713 }
meillo@0 1714 }
meillo@0 1715 rhsbuf[i++] = 0;
meillo@0 1716 if (rhsbuf[0] == '%' && rhsbuf[1] == 0) {
meillo@0 1717 if (orhssz == 0)
meillo@0 1718 error("no remembered replacement string");
meillo@0 1719 strcpy(rhsbuf, oldrhs);
meillo@0 1720 } else {
meillo@0 1721 if (orhssz < RHSIZE &&
meillo@0 1722 (oldrhs = realloc(oldrhs, orhssz=RHSIZE)) == 0)
meillo@0 1723 error("replacement string too long");
meillo@0 1724 strcpy(oldrhs, rhsbuf);
meillo@0 1725 }
meillo@0 1726 if ((peekc = getchr()) == 'g') {
meillo@0 1727 peekc = 0;
meillo@0 1728 newline();
meillo@0 1729 return(-1);
meillo@0 1730 } else if (peekc >= '0' && peekc <= '9') {
meillo@0 1731 c = getnum();
meillo@0 1732 if (c < 1 || c > LBSIZE)
meillo@0 1733 error("invalid count");
meillo@0 1734 newline();
meillo@0 1735 return c;
meillo@0 1736 }
meillo@0 1737 newline();
meillo@0 1738 return(0);
meillo@0 1739 }
meillo@0 1740
meillo@0 1741 static int
meillo@0 1742 getsub(void)
meillo@0 1743 {
meillo@0 1744 register char *p1, *p2;
meillo@0 1745
meillo@0 1746 p1 = linebuf;
meillo@0 1747 if ((p2 = linebp) == 0)
meillo@0 1748 return(EOF);
meillo@0 1749 while (*p1++ = *p2++)
meillo@0 1750 ;
meillo@0 1751 linebp = 0;
meillo@0 1752 return(0);
meillo@0 1753 }
meillo@0 1754
meillo@0 1755 static int
meillo@0 1756 dosub(int really)
meillo@0 1757 {
meillo@0 1758 register char *lp, *sp;
meillo@0 1759 register int i, j, k;
meillo@0 1760 int c;
meillo@0 1761
meillo@0 1762 if (!really)
meillo@0 1763 goto copy;
meillo@0 1764 i = 0;
meillo@0 1765 j = 0;
meillo@0 1766 k = 0;
meillo@0 1767 while (&linebuf[i] < loc1)
meillo@0 1768 genbuf[j++] = linebuf[i++];
meillo@0 1769 while (c = rhsbuf[k++]&0377) {
meillo@0 1770 if (c=='&') {
meillo@0 1771 j = place(j, loc1, loc2);
meillo@0 1772 continue;
meillo@0 1773 } else if (c == '\\') {
meillo@0 1774 c = rhsbuf[k++]&0377;
meillo@0 1775 if (c >='1' && c < nbra+'1') {
meillo@0 1776 j = place(j, braslist[c-'1'], braelist[c-'1']);
meillo@0 1777 continue;
meillo@0 1778 }
meillo@0 1779 }
meillo@0 1780 if (j >= LBSIZE)
meillo@0 1781 growlb("line too long");
meillo@0 1782 genbuf[j++] = c;
meillo@0 1783 }
meillo@0 1784 i = loc2 - linebuf;
meillo@0 1785 loc2 = j + linebuf;
meillo@0 1786 #if defined (SUS) || defined (SU3) || defined (S42)
meillo@0 1787 if (loc1 == &linebuf[i]) {
meillo@0 1788 int n;
meillo@0 1789 wchar_t wc;
meillo@0 1790 if (mb_cur_max > 1 && (n = mbtowc(&wc, loc2, mb_cur_max)) > 0)
meillo@0 1791 loc2 += n;
meillo@0 1792 else
meillo@0 1793 loc2++;
meillo@0 1794 }
meillo@0 1795 #endif /* SUS || SU3 || S42 */
meillo@0 1796 while (genbuf[j++] = linebuf[i++])
meillo@0 1797 if (j >= LBSIZE)
meillo@0 1798 growlb("line too long");
meillo@0 1799 if (really) {
meillo@0 1800 lp = linebuf;
meillo@0 1801 sp = genbuf;
meillo@0 1802 } else {
meillo@0 1803 copy: sp = linebuf;
meillo@0 1804 lp = genbuf;
meillo@0 1805 }
meillo@0 1806 while (*lp++ = *sp++)
meillo@0 1807 ;
meillo@0 1808 return really;
meillo@0 1809 }
meillo@0 1810
meillo@0 1811 static int
meillo@0 1812 place(register int j, register const char *l1, register const char *l2)
meillo@0 1813 {
meillo@0 1814
meillo@0 1815 while (l1 < l2) {
meillo@0 1816 genbuf[j++] = *l1++;
meillo@0 1817 if (j >= LBSIZE)
meillo@0 1818 growlb("line too long");
meillo@0 1819 }
meillo@0 1820 return(j);
meillo@0 1821 }
meillo@0 1822
meillo@0 1823 static void
meillo@0 1824 move(int cflag)
meillo@0 1825 {
meillo@0 1826 register long *adt, *ad1, *ad2;
meillo@0 1827
meillo@0 1828 setdot();
meillo@0 1829 nonzero();
meillo@0 1830 if ((adt = address())==0)
meillo@0 1831 error("illegal move destination");
meillo@0 1832 newline();
meillo@0 1833 checkpoint();
meillo@0 1834 if (cflag) {
meillo@0 1835 long *ozero;
meillo@0 1836 intptr_t delta;
meillo@0 1837 ad1 = dol;
meillo@0 1838 ozero = zero;
meillo@0 1839 append(getcopy, ad1++);
meillo@0 1840 ad2 = dol;
meillo@0 1841 delta = zero - ozero;
meillo@0 1842 ad1 += delta;
meillo@0 1843 adt += delta;
meillo@0 1844 } else {
meillo@0 1845 ad2 = addr2;
meillo@0 1846 for (ad1 = addr1; ad1 <= ad2;)
meillo@0 1847 *ad1++ &= ~01;
meillo@0 1848 ad1 = addr1;
meillo@0 1849 }
meillo@0 1850 ad2++;
meillo@0 1851 if (adt<ad1) {
meillo@0 1852 dot = adt + (ad2-ad1);
meillo@0 1853 if ((++adt)==ad1)
meillo@0 1854 return;
meillo@0 1855 reverse(adt, ad1);
meillo@0 1856 reverse(ad1, ad2);
meillo@0 1857 reverse(adt, ad2);
meillo@0 1858 } else if (adt >= ad2) {
meillo@0 1859 dot = adt++;
meillo@0 1860 reverse(ad1, ad2);
meillo@0 1861 reverse(ad2, adt);
meillo@0 1862 reverse(ad1, adt);
meillo@0 1863 } else
meillo@0 1864 error("illegal move destination");
meillo@0 1865 fchange = 1;
meillo@0 1866 }
meillo@0 1867
meillo@0 1868 static void
meillo@0 1869 reverse(register long *a1, register long *a2)
meillo@0 1870 {
meillo@0 1871 register int t;
meillo@0 1872
meillo@0 1873 for (;;) {
meillo@0 1874 t = *--a2;
meillo@0 1875 if (a2 <= a1)
meillo@0 1876 return;
meillo@0 1877 *a2 = *a1;
meillo@0 1878 *a1++ = t;
meillo@0 1879 }
meillo@0 1880 }
meillo@0 1881
meillo@0 1882 static int
meillo@0 1883 getcopy(void)
meillo@0 1884 {
meillo@0 1885 if (addr1 > addr2)
meillo@0 1886 return(EOF);
meillo@0 1887 getline(*addr1++, 0);
meillo@0 1888 return(0);
meillo@0 1889 }
meillo@0 1890
meillo@0 1891 static int
meillo@0 1892 execute(int gf, long *addr, int subst)
meillo@0 1893 {
meillo@0 1894 register char *p1, *p2, c;
meillo@0 1895
meillo@0 1896 for (c=0; c<NBRA; c++) {
meillo@0 1897 braslist[c&0377] = 0;
meillo@0 1898 braelist[c&0377] = 0;
meillo@0 1899 }
meillo@0 1900 if (gf) {
meillo@0 1901 if (circf)
meillo@0 1902 return(0);
meillo@0 1903 p1 = linebuf;
meillo@0 1904 p2 = genbuf;
meillo@0 1905 while (*p1++ = *p2++)
meillo@0 1906 ;
meillo@0 1907 locs = p1 = loc2;
meillo@0 1908 } else {
meillo@0 1909 if (addr==zero)
meillo@0 1910 return(0);
meillo@0 1911 p1 = getline(*addr, 1);
meillo@0 1912 locs = 0;
meillo@0 1913 }
meillo@0 1914 needsub = subst;
meillo@0 1915 return step(p1, expbuf);
meillo@0 1916 }
meillo@0 1917
meillo@0 1918 static void
meillo@0 1919 cmplerr(int c)
meillo@0 1920 {
meillo@0 1921 const char *msg;
meillo@0 1922
meillo@0 1923 #if !defined (SUS) && !defined (S42) && !defined (SU3)
meillo@0 1924 expbuf[0] = 0;
meillo@0 1925 #endif
meillo@0 1926 switch (c) {
meillo@0 1927 case 11:
meillo@0 1928 msg = "Range endpoint too large";
meillo@0 1929 break;
meillo@0 1930 case 16:
meillo@0 1931 msg = "bad number";
meillo@0 1932 break;
meillo@0 1933 case 25:
meillo@0 1934 msg = "`\\digit' out of range";
meillo@0 1935 break;
meillo@0 1936 case 36:
meillo@0 1937 msg = "illegal or missing delimiter";
meillo@0 1938 break;
meillo@0 1939 case 41:
meillo@0 1940 msg = "no remembered search string";
meillo@0 1941 break;
meillo@0 1942 case 42:
meillo@0 1943 msg = "'\\( \\)' imbalance";
meillo@0 1944 break;
meillo@0 1945 case 43:
meillo@0 1946 msg = "Too many `\\(' s";
meillo@0 1947 break;
meillo@0 1948 case 44:
meillo@0 1949 msg = "more than 2 numbers given";
meillo@0 1950 break;
meillo@0 1951 case 45:
meillo@0 1952 msg = "'\\}' expected";
meillo@0 1953 break;
meillo@0 1954 case 46:
meillo@0 1955 msg = "first number exceeds second";
meillo@0 1956 break;
meillo@0 1957 case 49:
meillo@0 1958 msg = "'[ ]' imbalance";
meillo@0 1959 break;
meillo@0 1960 case 50:
meillo@0 1961 msg = "regular expression overflow";
meillo@0 1962 break;
meillo@0 1963 case 67:
meillo@0 1964 msg = "illegal byte sequence";
meillo@0 1965 break;
meillo@0 1966 default:
meillo@0 1967 msg = "regular expression error";
meillo@0 1968 break;
meillo@0 1969 }
meillo@0 1970 error(msg);
meillo@0 1971 }
meillo@0 1972
meillo@0 1973 static void
meillo@0 1974 doprnt(long *bot, long *top)
meillo@0 1975 {
meillo@0 1976 long *a1;
meillo@0 1977
meillo@0 1978 a1 = bot;
meillo@0 1979 do {
meillo@0 1980 if (numbf ^ Nflag) {
meillo@0 1981 putd(a1-zero);
meillo@0 1982 putchr('\t');
meillo@0 1983 }
meillo@0 1984 nlputs(getline(*a1++, 0));
meillo@0 1985 } while (a1 <= top);
meillo@0 1986 pflag = 0;
meillo@0 1987 listf = 0;
meillo@0 1988 numbf = 0;
meillo@0 1989 }
meillo@0 1990
meillo@0 1991 static void
meillo@0 1992 putd(long c)
meillo@0 1993 {
meillo@0 1994 register int r;
meillo@0 1995
meillo@0 1996 r = c%10;
meillo@0 1997 c /= 10;
meillo@0 1998 if (c)
meillo@0 1999 putd(c);
meillo@0 2000 putchr(r + '0');
meillo@0 2001 }
meillo@0 2002
meillo@0 2003 static void
meillo@0 2004 nlputs(register const char *sp)
meillo@0 2005 {
meillo@0 2006 if (listf)
meillo@0 2007 list(sp);
meillo@0 2008 else if (tabstops)
meillo@0 2009 expand(sp);
meillo@0 2010 else
meillo@0 2011 puts(sp);
meillo@0 2012 }
meillo@0 2013
meillo@0 2014 static void
meillo@0 2015 puts(register const char *sp)
meillo@0 2016 {
meillo@0 2017 while (*sp) {
meillo@0 2018 if (*sp != '\n')
meillo@0 2019 putchr(*sp++ & 0377);
meillo@0 2020 else
meillo@0 2021 sp++, putchr('\0');
meillo@0 2022 }
meillo@0 2023 putchr('\n');
meillo@0 2024 }
meillo@0 2025
meillo@0 2026 static void
meillo@0 2027 list(const char *lp)
meillo@0 2028 {
meillo@0 2029 int col, n;
meillo@0 2030 wchar_t c;
meillo@0 2031
meillo@0 2032 col = numbf ^ Nflag ? 8 : 0;
meillo@0 2033 while (*lp) {
meillo@0 2034 if (mb_cur_max > 1 && *lp&0200)
meillo@0 2035 n = mbtowc(&c, lp, mb_cur_max);
meillo@0 2036 else {
meillo@0 2037 n = 1;
meillo@0 2038 c = *lp&0377;
meillo@0 2039 }
meillo@0 2040 if (col+1 >= 72) {
meillo@0 2041 col = 0;
meillo@0 2042 putchr('\\');
meillo@0 2043 putchr('\n');
meillo@0 2044 }
meillo@0 2045 if (n<0 ||
meillo@0 2046 #if defined (SUS) || defined (S42) || defined (SU3)
meillo@0 2047 c == '\\' ||
meillo@0 2048 #endif /* SUS || S42 || SU3 */
meillo@0 2049 !(mb_cur_max>1 ? iswprint(c) : isprint(c))) {
meillo@0 2050 if (n<0)
meillo@0 2051 n = 1;
meillo@0 2052 while (n--)
meillo@0 2053 col += lstchr(*lp++&0377);
meillo@0 2054 } else if (mb_cur_max>1) {
meillo@0 2055 col += wcwidth(c);
meillo@0 2056 while (n--)
meillo@0 2057 putchr(*lp++&0377);
meillo@0 2058 } else {
meillo@0 2059 putchr(*lp++&0377);
meillo@0 2060 col++;
meillo@0 2061 }
meillo@0 2062 }
meillo@0 2063 #if defined (SUS) || defined (S42) || defined (SU3)
meillo@0 2064 putchr('$');
meillo@0 2065 #endif
meillo@0 2066 putchr('\n');
meillo@0 2067 }
meillo@0 2068
meillo@0 2069 static int
meillo@0 2070 lstchr(int c)
meillo@0 2071 {
meillo@0 2072 int cad = 1, d;
meillo@0 2073
meillo@0 2074 #if !defined (SUS) && !defined (S42) && !defined (SU3)
meillo@0 2075 if (c=='\t') {
meillo@0 2076 c = '>';
meillo@0 2077 goto esc;
meillo@0 2078 }
meillo@0 2079 if (c=='\b') {
meillo@0 2080 c = '<';
meillo@0 2081 esc:
meillo@0 2082 putchr('-');
meillo@0 2083 putchr('\b');
meillo@0 2084 putchr(c);
meillo@0 2085 } else if (c == '\n') {
meillo@0 2086 putchr('\\');
meillo@0 2087 putchr('0');
meillo@0 2088 putchr('0');
meillo@0 2089 putchr('0');
meillo@0 2090 cad = 4;
meillo@0 2091 #else /* !SUS, !S42, !SU3 */
meillo@0 2092 if (c == '\n')
meillo@0 2093 c = '\0';
meillo@0 2094 if (c == '\\') {
meillo@0 2095 putchr('\\');
meillo@0 2096 putchr('\\');
meillo@0 2097 cad = 2;
meillo@0 2098 } else if (c == '\a') {
meillo@0 2099 putchr('\\');
meillo@0 2100 putchr('a');
meillo@0 2101 cad = 2;
meillo@0 2102 } else if (c == '\b') {
meillo@0 2103 putchr('\\');
meillo@0 2104 putchr('b');
meillo@0 2105 cad = 2;
meillo@0 2106 } else if (c == '\f') {
meillo@0 2107 putchr('\\');
meillo@0 2108 putchr('f');
meillo@0 2109 cad = 2;
meillo@0 2110 } else if (c == '\r') {
meillo@0 2111 putchr('\\');
meillo@0 2112 putchr('r');
meillo@0 2113 cad = 2;
meillo@0 2114 } else if (c == '\t') {
meillo@0 2115 putchr('\\');
meillo@0 2116 putchr('t');
meillo@0 2117 cad = 2;
meillo@0 2118 } else if (c == '\v') {
meillo@0 2119 putchr('\\');
meillo@0 2120 putchr('v');
meillo@0 2121 cad = 2;
meillo@0 2122 #endif /* !SUS, !S42, !SU3 */
meillo@0 2123 } else {
meillo@0 2124 putchr('\\');
meillo@0 2125 putchr(((c&~077)>>6)+'0');
meillo@0 2126 c &= 077;
meillo@0 2127 d = c & 07;
meillo@0 2128 putchr(c > d ? ((c-d)>>3)+'0' : '0');
meillo@0 2129 putchr(d+'0');
meillo@0 2130 cad = 4;
meillo@0 2131 }
meillo@0 2132 return cad;
meillo@0 2133 }
meillo@0 2134
meillo@0 2135 static void
meillo@0 2136 putstr(const char *s)
meillo@0 2137 {
meillo@0 2138 while (*s)
meillo@0 2139 putchr(*s++);
meillo@0 2140 }
meillo@0 2141
meillo@0 2142 static char line[70];
meillo@0 2143 static char *linp = line;
meillo@0 2144
meillo@0 2145 static void
meillo@0 2146 putchr(int ac)
meillo@0 2147 {
meillo@0 2148 register char *lp;
meillo@0 2149 register int c;
meillo@0 2150
meillo@0 2151 lp = linp;
meillo@0 2152 c = ac;
meillo@0 2153 *lp++ = c;
meillo@0 2154 if(c == '\n' || lp >= &line[64]) {
meillo@0 2155 linp = line;
meillo@0 2156 write(1, line, lp-line);
meillo@0 2157 return;
meillo@0 2158 }
meillo@0 2159 linp = lp;
meillo@0 2160 }
meillo@0 2161
meillo@0 2162 static void
meillo@0 2163 checkpoint(void)
meillo@0 2164 {
meillo@0 2165 long *a1, *a2;
meillo@0 2166
meillo@0 2167 if (undzero && globp == NULL) {
meillo@0 2168 for (a1 = zero+1, a2 = undzero+1; a1 <= dol; a1++, a2++)
meillo@0 2169 *a2 = *a1;
meillo@0 2170 unddot = &undzero[dot-zero];
meillo@0 2171 unddol = &undzero[dol-zero];
meillo@0 2172 for (a1 = names, a2 = undnames; a1 < &names[26]; a1++, a2++)
meillo@0 2173 *a2 = *a1;
meillo@0 2174 }
meillo@0 2175 }
meillo@0 2176
meillo@0 2177 #define swap(a, b) (t = a, a = b, b = t)
meillo@0 2178
meillo@0 2179 static void
meillo@0 2180 undo(void)
meillo@0 2181 {
meillo@0 2182 long *t;
meillo@0 2183
meillo@0 2184 if (undzero == NULL)
meillo@0 2185 error("no undo information saved");
meillo@0 2186 swap(zero, undzero);
meillo@0 2187 swap(dot, unddot);
meillo@0 2188 swap(dol, unddol);
meillo@0 2189 swap(names, undnames);
meillo@0 2190 }
meillo@0 2191
meillo@0 2192 static int
meillo@0 2193 maketf(int fd)
meillo@0 2194 {
meillo@0 2195 char *tmpdir;
meillo@0 2196
meillo@0 2197 if (fd == -1) {
meillo@0 2198 if ((tmpdir = getenv("TMPDIR")) == NULL ||
meillo@0 2199 (fd = creatf(tmpdir)) < 0)
meillo@0 2200 if ((fd = creatf("/var/tmp")) < 0 &&
meillo@0 2201 (fd = creatf("/tmp")) < 0)
meillo@0 2202 error("cannot create temporary file");
meillo@0 2203 } else
meillo@0 2204 ftruncate(fd, 0); /* blkio() will seek to 0 anyway */
meillo@0 2205 return fd;
meillo@0 2206 }
meillo@0 2207
meillo@0 2208 static int
meillo@0 2209 creatf(const char *tmpdir)
meillo@0 2210 {
meillo@0 2211 if (strlen(tmpdir) >= sizeof tfname - 9)
meillo@0 2212 return -1;
meillo@0 2213 strcpy(tfname, tmpdir);
meillo@0 2214 strcat(tfname, "/eXXXXXX");
meillo@0 2215 return mkstemp(tfname);
meillo@0 2216 }
meillo@0 2217
meillo@0 2218 static int
meillo@0 2219 sopen(const char *fn, int rdwr)
meillo@0 2220 {
meillo@0 2221 int pf[2], fd = -1;
meillo@0 2222
meillo@0 2223 if (fn[0] == '!') {
meillo@0 2224 fn++;
meillo@0 2225 if (pipe(pf) < 0)
meillo@0 2226 error("write or open on pipe failed");
meillo@0 2227 switch (pipid = fork()) {
meillo@0 2228 case 0:
meillo@0 2229 if (rdwr == READ)
meillo@0 2230 dup2(pf[1], 1);
meillo@0 2231 else
meillo@0 2232 dup2(pf[0], 0);
meillo@0 2233 close(pf[0]);
meillo@0 2234 close(pf[1]);
meillo@0 2235 sigset(SIGHUP, oldhup);
meillo@0 2236 sigset(SIGQUIT, oldquit);
meillo@0 2237 sigset(SIGPIPE, oldpipe);
meillo@0 2238 execl(SHELL, "sh", "-c", fn, NULL);
meillo@0 2239 _exit(0100);
meillo@0 2240 default:
meillo@0 2241 close(pf[rdwr == READ ? 1 : 0]);
meillo@0 2242 fd = pf[rdwr == READ ? 0 : 1];
meillo@0 2243 break;
meillo@0 2244 case -1:
meillo@0 2245 error("fork failed - try again");
meillo@0 2246 }
meillo@0 2247 } else if (rdwr == READ)
meillo@0 2248 fd = open(fn, O_RDONLY);
meillo@0 2249 else if (rdwr == EXIST)
meillo@0 2250 fd = open(fn, O_WRONLY);
meillo@0 2251 else /*if (rdwr == WRITE)*/
meillo@0 2252 fd = creat(fn, 0666);
meillo@0 2253 if (fd >= 0 && rdwr == READ)
meillo@0 2254 readop = 1;
meillo@0 2255 if (fd >= 0)
meillo@0 2256 fstat(fd, &fstbuf);
meillo@0 2257 return fd;
meillo@0 2258 }
meillo@0 2259
meillo@0 2260 static void
meillo@0 2261 sclose(int fd)
meillo@0 2262 {
meillo@0 2263 int status;
meillo@0 2264
meillo@0 2265 close(fd);
meillo@0 2266 if (pipid >= 0) {
meillo@0 2267 while (wait(&status) != pipid);
meillo@0 2268 pipid = -1;
meillo@0 2269 }
meillo@0 2270 readop = 0;
meillo@0 2271 }
meillo@0 2272
meillo@0 2273 static void
meillo@0 2274 fspec(const char *lp)
meillo@0 2275 {
meillo@0 2276 struct termios ts;
meillo@0 2277 const char *cp;
meillo@0 2278
meillo@0 2279 freetabs();
meillo@0 2280 maxlength = 0;
meillo@0 2281 if (tcgetattr(1, &ts) < 0
meillo@0 2282 #ifdef TAB3
meillo@0 2283 || (ts.c_oflag&TAB3) == 0
meillo@0 2284 #endif
meillo@0 2285 )
meillo@0 2286 return;
meillo@0 2287 while (lp[0]) {
meillo@0 2288 if (lp[0] == '<' && lp[1] == ':')
meillo@0 2289 break;
meillo@0 2290 lp++;
meillo@0 2291 }
meillo@0 2292 if (lp[0]) {
meillo@0 2293 lp += 2;
meillo@0 2294 while ((cp = ftok(&lp)) != NULL) {
meillo@0 2295 switch (*cp) {
meillo@0 2296 case 't':
meillo@0 2297 freetabs();
meillo@0 2298 if ((tabstops = tabstring(&cp[1])) == NULL)
meillo@0 2299 goto err;
meillo@0 2300 break;
meillo@0 2301 case 's':
meillo@0 2302 maxlength = atoi(&cp[1]);
meillo@0 2303 break;
meillo@0 2304 case 'm':
meillo@0 2305 case 'd':
meillo@0 2306 case 'e':
meillo@0 2307 break;
meillo@0 2308 case ':':
meillo@0 2309 if (cp[1] == '>') {
meillo@0 2310 if (tabstops == NULL)
meillo@0 2311 if ((tabstops = tabstring("0"))
meillo@0 2312 == NULL)
meillo@0 2313 goto err;
meillo@0 2314 return;
meillo@0 2315 }
meillo@0 2316 /*FALLTHRU*/
meillo@0 2317 default:
meillo@0 2318 err: freetabs();
meillo@0 2319 maxlength = 0;
meillo@0 2320 errput("PWB spec problem", NULL);
meillo@0 2321 return;
meillo@0 2322 }
meillo@0 2323 }
meillo@0 2324 }
meillo@0 2325 }
meillo@0 2326
meillo@0 2327 static const char *
meillo@0 2328 ftok(const char **lp)
meillo@0 2329 {
meillo@0 2330 const char *cp;
meillo@0 2331
meillo@0 2332 while (**lp && **lp != ':' && (**lp == ' ' || **lp == '\t'))
meillo@0 2333 (*lp)++;
meillo@0 2334 cp = *lp;
meillo@0 2335 while (**lp && **lp != ':' && **lp != ' ' && **lp != '\t')
meillo@0 2336 (*lp)++;
meillo@0 2337 return cp;
meillo@0 2338 }
meillo@0 2339
meillo@0 2340 static struct tabulator *
meillo@0 2341 repetitive(int repetition)
meillo@0 2342 {
meillo@0 2343 struct tabulator *tp, *tabspec;
meillo@0 2344 int col, i;
meillo@0 2345
meillo@0 2346 if ((tp = tabspec = calloc(1, sizeof *tp)) == NULL)
meillo@0 2347 return NULL;
meillo@0 2348 tp->t_rep = repetition;
meillo@0 2349 if (repetition > 0) {
meillo@0 2350 for (col = 1+repetition, i = 0; i < 22; col += repetition) {
meillo@0 2351 if ((tp->t_nxt = calloc(1, sizeof *tp)) == NULL)
meillo@0 2352 return NULL;
meillo@0 2353 tp = tp->t_nxt;
meillo@0 2354 tp->t_tab = col;
meillo@0 2355 }
meillo@0 2356 }
meillo@0 2357 return tabspec;
meillo@0 2358 }
meillo@0 2359
meillo@0 2360 #define blank(c) ((c) == ' ' || (c) == '\t')
meillo@0 2361
meillo@0 2362 static struct tabulator *
meillo@0 2363 tablist(const char *s)
meillo@0 2364 {
meillo@0 2365 struct tabulator *tp, *tabspec;
meillo@0 2366 char *x;
meillo@0 2367 int prev = 0, val;
meillo@0 2368
meillo@0 2369 if ((tp = tabspec = calloc(1, sizeof *tp)) == NULL)
meillo@0 2370 return NULL;
meillo@0 2371 for (;;) {
meillo@0 2372 while (*s == ',')
meillo@0 2373 s++;
meillo@0 2374 if (*s == '\0' || blank(*s) || *s == ':')
meillo@0 2375 break;
meillo@0 2376 val = strtol(s, &x, 10);
meillo@0 2377 if (*s == '+')
meillo@0 2378 val += prev;
meillo@0 2379 prev = val;
meillo@0 2380 if (*s == '-' || (*x != ',' && !blank(*x) && *x != ':' &&
meillo@0 2381 *x != '\0'))
meillo@0 2382 return NULL;
meillo@0 2383 s = x;
meillo@0 2384 if ((tp->t_nxt = calloc(1, sizeof *tp)) == NULL)
meillo@0 2385 return NULL;
meillo@0 2386 tp = tp->t_nxt;
meillo@0 2387 tp->t_tab = val;
meillo@0 2388 }
meillo@0 2389 return tabspec;
meillo@0 2390 }
meillo@0 2391
meillo@0 2392 static struct tabulator *
meillo@0 2393 tabstring(const char *s)
meillo@0 2394 {
meillo@0 2395 const struct {
meillo@0 2396 const char *c_nam;
meillo@0 2397 const char *c_str;
meillo@0 2398 } canned[] = {
meillo@0 2399 { "a", "1,10,16,36,72" },
meillo@0 2400 { "a2", "1,10,16,40,72" },
meillo@0 2401 { "c", "1,8,12,16,20,55" },
meillo@0 2402 { "c2", "1,6,10,14,49" },
meillo@0 2403 { "c3", "1,6,10,14,18,22,26,30,34,38,42,46,50,54,58,62,67" },
meillo@0 2404 { "f", "1,7,11,15,19,23" },
meillo@0 2405 { "p", "1,5,9,13,17,21,25,29,33,37,41,45,49,53,57,61" },
meillo@0 2406 { "s", "1,10,55" },
meillo@0 2407 { "u", "1,12,20,44" },
meillo@0 2408 { 0, 0 }
meillo@0 2409 };
meillo@0 2410
meillo@0 2411 int i, j;
meillo@0 2412
meillo@0 2413 if (s[0] == '-') {
meillo@0 2414 if (s[1] >= '0' && s[1] <= '9' && ((i = atoi(&s[1])) != 0))
meillo@0 2415 return repetitive(i);
meillo@0 2416 for (i = 0; canned[i].c_nam; i++) {
meillo@0 2417 for (j = 0; canned[i].c_nam[j]; j++)
meillo@0 2418 if (s[j+1] != canned[i].c_nam[j])
meillo@0 2419 break;
meillo@0 2420 if ((s[j+1]=='\0' || s[j+1]==':' || blank(s[j+1])) &&
meillo@0 2421 canned[i].c_nam[j] == '\0')
meillo@0 2422 return tablist(canned[i].c_str);
meillo@0 2423 }
meillo@0 2424 return NULL;
meillo@0 2425 } else
meillo@0 2426 return tablist(s);
meillo@0 2427 }
meillo@0 2428
meillo@0 2429 static void
meillo@0 2430 freetabs(void)
meillo@0 2431 {
meillo@0 2432 struct tabulator *tp;
meillo@0 2433
meillo@0 2434 tp = tabstops;
meillo@0 2435 while (tp) {
meillo@0 2436 tabstops = tp->t_nxt;
meillo@0 2437 free(tp);
meillo@0 2438 tp = tabstops;
meillo@0 2439 }
meillo@0 2440 }
meillo@0 2441
meillo@0 2442 static void
meillo@0 2443 expand(const char *s)
meillo@0 2444 {
meillo@0 2445 struct tabulator *tp = tabstops;
meillo@0 2446 int col = 0, n = 1, m, tabcnt = 0, nspc;
meillo@0 2447 wchar_t wc;
meillo@0 2448
meillo@0 2449 while (*s) {
meillo@0 2450 nspc = 0;
meillo@0 2451 switch (*s) {
meillo@0 2452 case '\n':
meillo@0 2453 putchr('\0');
meillo@0 2454 s++;
meillo@0 2455 continue;
meillo@0 2456 case '\t':
meillo@0 2457 if (tp) {
meillo@0 2458 if (tp->t_rep) {
meillo@0 2459 if (col % tp->t_rep == 0) {
meillo@0 2460 nspc++;
meillo@0 2461 col++;
meillo@0 2462 }
meillo@0 2463 while (col % tp->t_rep) {
meillo@0 2464 nspc++;
meillo@0 2465 col++;
meillo@0 2466 }
meillo@0 2467 break;
meillo@0 2468 }
meillo@0 2469 while (tp && (col>tp->t_tab || tp->t_tab == 0))
meillo@0 2470 tp = tp->t_nxt;
meillo@0 2471 if (tp && col == tp->t_tab) {
meillo@0 2472 nspc++;
meillo@0 2473 col++;
meillo@0 2474 tp = tp->t_nxt;
meillo@0 2475 }
meillo@0 2476 if (tp) {
meillo@0 2477 while (col < tp->t_tab) {
meillo@0 2478 nspc++;
meillo@0 2479 col++;
meillo@0 2480 }
meillo@0 2481 tp = tp->t_nxt;
meillo@0 2482 break;
meillo@0 2483 }
meillo@0 2484 }
meillo@0 2485 tabcnt = 1;
meillo@0 2486 nspc++;
meillo@0 2487 break;
meillo@0 2488 default:
meillo@0 2489 if (mb_cur_max>1 && (n=mbtowc(&wc, s, mb_cur_max))>0) {
meillo@0 2490 if ((m = wcwidth(wc)) > 0)
meillo@0 2491 col += m;
meillo@0 2492 } else {
meillo@0 2493 col++;
meillo@0 2494 n = 1;
meillo@0 2495 }
meillo@0 2496 }
meillo@0 2497 if (maxlength && col > maxlength) {
meillo@0 2498 putstr("\ntoo long");
meillo@0 2499 break;
meillo@0 2500 }
meillo@0 2501 if (nspc) {
meillo@0 2502 while (nspc--)
meillo@0 2503 putchr(' ');
meillo@0 2504 s++;
meillo@0 2505 } else
meillo@0 2506 while (n--)
meillo@0 2507 putchr(*s++);
meillo@0 2508 }
meillo@0 2509 if (tabcnt)
meillo@0 2510 putstr("\ntab count");
meillo@0 2511 putchr('\n');
meillo@0 2512 }
meillo@0 2513
meillo@0 2514 static wint_t
meillo@0 2515 GETWC(char *mb)
meillo@0 2516 {
meillo@0 2517 int c, n;
meillo@0 2518
meillo@0 2519 n = 1;
meillo@0 2520 mb[0] = c = GETC();
meillo@0 2521 mb[1] = '\0';
meillo@0 2522 if (mb_cur_max > 1 && c&0200 && c != EOF) {
meillo@0 2523 int m;
meillo@0 2524 wchar_t wc;
meillo@0 2525
meillo@0 2526 while ((m = mbtowc(&wc, mb, mb_cur_max)) < 0 && n<mb_cur_max) {
meillo@0 2527 mb[n++] = c = GETC();
meillo@0 2528 mb[n] = '\0';
meillo@0 2529 if (c == '\n' || c == EOF)
meillo@0 2530 break;
meillo@0 2531 }
meillo@0 2532 if (m != n)
meillo@0 2533 ERROR(67);
meillo@0 2534 return wc;
meillo@0 2535 } else
meillo@0 2536 return c;
meillo@0 2537 }
meillo@0 2538
meillo@0 2539 static void
meillo@0 2540 growlb(const char *msg)
meillo@0 2541 {
meillo@0 2542 char *olb = linebuf;
meillo@0 2543 int i;
meillo@0 2544
meillo@0 2545 LBSIZE += 512;
meillo@0 2546 if ((linebuf = realloc(linebuf, LBSIZE)) == NULL ||
meillo@0 2547 (genbuf = realloc(genbuf, LBSIZE)) == NULL)
meillo@0 2548 error(msg);
meillo@0 2549 if (linebuf != olb) {
meillo@0 2550 loc1 += linebuf - olb;
meillo@0 2551 loc2 += linebuf - olb;
meillo@0 2552 for (i = 0; i < NBRA; i++) {
meillo@0 2553 if (braslist[i])
meillo@0 2554 braslist[i] += linebuf - olb;
meillo@0 2555 if (braelist[i])
meillo@0 2556 braelist[i] += linebuf - olb;
meillo@0 2557 }
meillo@0 2558 }
meillo@0 2559 }
meillo@0 2560
meillo@0 2561 static void
meillo@0 2562 growrhs(const char *msg)
meillo@0 2563 {
meillo@0 2564 RHSIZE += 256;
meillo@0 2565 if ((rhsbuf = realloc(rhsbuf, RHSIZE)) == NULL)
meillo@0 2566 error(msg);
meillo@0 2567 }
meillo@0 2568
meillo@0 2569 static void
meillo@0 2570 growfn(const char *msg)
meillo@0 2571 {
meillo@0 2572 FNSIZE += 64;
meillo@0 2573 if ((savedfile = realloc(savedfile, FNSIZE)) == NULL ||
meillo@0 2574 (file = realloc(file, FNSIZE)) == NULL)
meillo@0 2575 error(msg);
meillo@0 2576 if (FNSIZE == 64)
meillo@0 2577 file[0] = savedfile[0] = 0;
meillo@0 2578 }
meillo@0 2579
meillo@0 2580 #if defined (SUS) || defined (S42) || defined (SU3)
meillo@0 2581 union ptrstore {
meillo@0 2582 void *vp;
meillo@0 2583 char bp[sizeof (void *)];
meillo@0 2584 };
meillo@0 2585
meillo@0 2586 static void *
meillo@0 2587 fetchptr(const char *bp)
meillo@0 2588 {
meillo@0 2589 union ptrstore u;
meillo@0 2590 int i;
meillo@0 2591
meillo@0 2592 for (i = 0; i < sizeof (void *); i++)
meillo@0 2593 u.bp[i] = bp[i];
meillo@0 2594 return u.vp;
meillo@0 2595 }
meillo@0 2596
meillo@0 2597 static void
meillo@0 2598 storeptr(void *vp, char *bp)
meillo@0 2599 {
meillo@0 2600 union ptrstore u;
meillo@0 2601 int i;
meillo@0 2602
meillo@0 2603 u.vp = vp;
meillo@0 2604 for (i = 0; i < sizeof (void *); i++)
meillo@0 2605 bp[i] = u.bp[i];
meillo@0 2606 }
meillo@0 2607
meillo@0 2608 #define add(c) ((i>=LBSIZE ? (growlb("regular expression overflow"),0) : 0), \
meillo@0 2609 genbuf[i++] = (c))
meillo@0 2610
meillo@0 2611 #define copy(s) { \
meillo@0 2612 int m; \
meillo@0 2613 for (m = 0; m==0 || s[m]; m++) \
meillo@0 2614 add(s[m]); \
meillo@0 2615 }
meillo@0 2616
meillo@0 2617 static char *
meillo@0 2618 compile(char *unused, char *ep, const char *endbuf, int seof)
meillo@0 2619 {
meillo@0 2620 INIT
meillo@0 2621 int c, d, i;
meillo@0 2622 regex_t *rp;
meillo@0 2623 char *op;
meillo@0 2624 char mb[MB_LEN_MAX+1];
meillo@0 2625
meillo@0 2626 op = ep;
meillo@0 2627 ep += 2;
meillo@0 2628 if ((rp = fetchptr(ep)) == NULL) {
meillo@0 2629 if ((rp = calloc(1, sizeof *rp)) == NULL)
meillo@0 2630 ERROR(50);
meillo@0 2631 storeptr(rp, ep);
meillo@0 2632 }
meillo@0 2633 ep += sizeof (void *);
meillo@0 2634 i = 0;
meillo@0 2635 nbra = 0;
meillo@0 2636 do {
meillo@0 2637 if ((c = GETWC(mb)) == seof)
meillo@0 2638 add('\0');
meillo@0 2639 else if (c == '\\') {
meillo@0 2640 copy(mb);
meillo@0 2641 c = GETWC(mb);
meillo@0 2642 if (c == '(')
meillo@0 2643 nbra++;
meillo@0 2644 goto normchar;
meillo@0 2645 } else if (c == '[') {
meillo@0 2646 add(c);
meillo@0 2647 d = EOF;
meillo@0 2648 do {
meillo@0 2649 c = GETWC(mb);
meillo@0 2650 if (c == EOF || c == '\n')
meillo@0 2651 ERROR(49);
meillo@0 2652 copy(mb);
meillo@0 2653 if (d=='[' && (c==':' || c=='.' || c=='=')) {
meillo@0 2654 d = c;
meillo@0 2655 do {
meillo@0 2656 c = GETWC(mb);
meillo@0 2657 if (c == EOF || c == '\n')
meillo@0 2658 ERROR(49);
meillo@0 2659 copy(mb);
meillo@0 2660 } while (c != d || PEEKC() != ']');
meillo@0 2661 c = GETWC(mb);
meillo@0 2662 copy(mb);
meillo@0 2663 c = EOF;
meillo@0 2664 }
meillo@0 2665 d = c;
meillo@0 2666 } while (c != ']');
meillo@0 2667 } else {
meillo@0 2668 if (c == EOF || c == '\n') {
meillo@0 2669 if (c == '\n')
meillo@0 2670 UNGETC(c);
meillo@0 2671 mb[0] = c = '\0';
meillo@0 2672 }
meillo@0 2673 if (c == '\0')
meillo@0 2674 nodelim = 1;
meillo@0 2675 normchar: copy(mb);
meillo@0 2676 }
meillo@0 2677 } while (genbuf[i-1] != '\0');
meillo@0 2678 if (genbuf[0]) {
meillo@0 2679 int reflags = 0;
meillo@0 2680
meillo@0 2681 #ifdef REG_ANGLES
meillo@0 2682 reflags |= REG_ANGLES;
meillo@0 2683 #endif
meillo@0 2684 #if defined (SU3) && defined (REG_AVOIDNULL)
meillo@0 2685 reflags |= REG_AVOIDNULL;
meillo@0 2686 #endif
meillo@0 2687 if (op[0])
meillo@0 2688 regfree(rp);
meillo@0 2689 op[0] = 0;
meillo@0 2690 switch (regcomp(rp, genbuf, reflags)) {
meillo@0 2691 case 0:
meillo@0 2692 break;
meillo@0 2693 case REG_ESUBREG:
meillo@0 2694 ERROR(25);
meillo@0 2695 /*NOTREACHED*/
meillo@0 2696 case REG_EBRACK:
meillo@0 2697 ERROR(49);
meillo@0 2698 /*NOTREACHED*/
meillo@0 2699 case REG_EPAREN:
meillo@0 2700 ERROR(42);
meillo@0 2701 /*NOTREACHED*/
meillo@0 2702 case REG_BADBR:
meillo@0 2703 case REG_EBRACE:
meillo@0 2704 ERROR(45);
meillo@0 2705 /*NOTREACHED*/
meillo@0 2706 case REG_ERANGE:
meillo@0 2707 ERROR(11);
meillo@0 2708 /*NOTREACHED*/
meillo@0 2709 case REG_ESPACE:
meillo@0 2710 ERROR(50);
meillo@0 2711 /*NOTREACHED*/
meillo@0 2712 default:
meillo@0 2713 ERROR(-1);
meillo@0 2714 }
meillo@0 2715 op[0] = 1;
meillo@0 2716 circf = op[1] = genbuf[0] == '^';
meillo@0 2717 } else if (op[0]) {
meillo@0 2718 circf = op[1];
meillo@0 2719 } else
meillo@0 2720 ERROR(41);
meillo@0 2721 return ep + sizeof (void *);
meillo@0 2722 }
meillo@0 2723
meillo@0 2724 static int
meillo@0 2725 step(const char *lp, const char *ep)
meillo@0 2726 {
meillo@0 2727 regex_t *rp;
meillo@0 2728 regmatch_t bralist[NBRA+1];
meillo@0 2729 int eflag = 0;
meillo@0 2730 int res;
meillo@0 2731 int i;
meillo@0 2732
meillo@0 2733 rp = fetchptr(&ep[2]);
meillo@0 2734 if (ep[0] == 0)
meillo@0 2735 return 0;
meillo@0 2736 if (locs)
meillo@0 2737 eflag |= REG_NOTBOL;
meillo@0 2738 if ((res = regexec(rp, lp, needsub? NBRA+1 : 0, bralist, eflag)) == 0 &&
meillo@0 2739 needsub) {
meillo@0 2740 loc1 = (char *)lp + bralist[0].rm_so;
meillo@0 2741 loc2 = (char *)lp + bralist[0].rm_eo;
meillo@0 2742 for (i = 1; i <= NBRA; i++) {
meillo@0 2743 if (bralist[i].rm_so != -1) {
meillo@0 2744 braslist[i-1] = (char *)lp + bralist[i].rm_so;
meillo@0 2745 braelist[i-1] = (char *)lp + bralist[i].rm_eo;
meillo@0 2746 } else
meillo@0 2747 braslist[i-1] = braelist[i-1] = NULL;
meillo@0 2748 }
meillo@0 2749 }
meillo@0 2750 return res == 0;
meillo@0 2751 }
meillo@0 2752 #endif /* SUS || S42 || SU3 */
meillo@0 2753
meillo@0 2754 static void
meillo@0 2755 help(void)
meillo@0 2756 {
meillo@0 2757 const char *desc[] = {
meillo@0 2758 "(.)a append up to .",
meillo@0 2759 "(.)b[n] browse n lines",
meillo@0 2760 "(.,.)c change up to .",
meillo@0 2761 "(.,.)d delete lines",
meillo@0 2762 "e [file] edit file",
meillo@0 2763 "E [file] force edit",
meillo@0 2764 "f [file] print or set file",
meillo@0 2765 "(1,$)g/RE/cmd global cmd",
meillo@0 2766 "(1,$)G/RE/ interactive global",
meillo@0 2767 "h print last error",
meillo@0 2768 "H toggle error messages",
meillo@0 2769 "help print this screen",
meillo@0 2770 "(.)i insert up to .",
meillo@0 2771 "(.,.+1)j join lines",
meillo@0 2772 "(.)kx mark line with x",
meillo@0 2773 "(.,.)l list lines",
meillo@0 2774 "(.,.)ma move lines to a",
meillo@0 2775 "(.,.)n number lines",
meillo@0 2776 "N revert n and p",
meillo@0 2777 "(.)o[n] show n lines of context",
meillo@0 2778 "(.,.)p print lines",
meillo@0 2779 "P toggle prompt",
meillo@0 2780 "q quit",
meillo@0 2781 "Q force quit",
meillo@0 2782 "($)r read file",
meillo@0 2783 "(.,.)s/RE/repl/ search and replace",
meillo@0 2784 "(.,.)s/RE/rp/g replace all occurrences",
meillo@0 2785 "(.,.)s/RE/rp/n replace n-th occurrence",
meillo@0 2786 "(.,.)ta transfer lines to a",
meillo@0 2787 "u undo last change",
meillo@0 2788 "(1,$)v/RE/cmd reverse global",
meillo@0 2789 "(1,$)V/RE/ reverse i/a global",
meillo@0 2790 "(1,$)w [file] write file",
meillo@0 2791 "(1,$)W [file] append to file",
meillo@0 2792 "z write buffer and quit",
meillo@0 2793 "($)= print line number",
meillo@0 2794 "!command execute shell command",
meillo@0 2795 "(.+1)<newline> print one line",
meillo@0 2796 "/RE find RE forwards",
meillo@0 2797 "?RE find RE backwards",
meillo@0 2798 "1 first line",
meillo@0 2799 ". current line",
meillo@0 2800 "$ last line",
meillo@0 2801 ", 1,$",
meillo@0 2802 "; .,$",
meillo@0 2803 NULL
meillo@0 2804 };
meillo@0 2805 char line[100];
meillo@0 2806 int c, half, i, k;
meillo@0 2807
meillo@0 2808 half = (sizeof desc / sizeof *desc) / 2;
meillo@0 2809 for (i = 0; i < half && desc[i]; i++) {
meillo@0 2810 c = 0;
meillo@0 2811 for (k = 0; desc[i][k]; k++)
meillo@0 2812 line[c++] = desc[i][k];
meillo@0 2813 if (desc[i+half]) {
meillo@0 2814 while (c < 40)
meillo@0 2815 line[c++] = ' ';
meillo@0 2816 for (k = 0; desc[i+half][k]; k++)
meillo@0 2817 line[c++] = desc[i+half][k];
meillo@0 2818 }
meillo@0 2819 line[c] = 0;
meillo@0 2820 puts(line);
meillo@0 2821 }
meillo@0 2822 }