![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ex_io.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / ucb / ex|
Return to ex_io.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / ucb / ex |
1.1 ! root 1: /* ! 2: * Copyright (c) 1980 Regents of the University of California. ! 3: * All rights reserved. The Berkeley software License Agreement ! 4: * specifies the terms and conditions for redistribution. ! 5: */ ! 6: ! 7: #ifndef lint ! 8: static char *sccsid = "@(#)ex_io.c 7.17 (Berkeley) 1/2/88"; ! 9: #endif not lint ! 10: ! 11: #include "ex.h" ! 12: #include "ex_argv.h" ! 13: #include "ex_temp.h" ! 14: #include "ex_tty.h" ! 15: #include "ex_vis.h" ! 16: #include <sys/file.h> ! 17: #include <sys/exec.h> ! 18: ! 19: /* ! 20: * File input/output, source, preserve and recover ! 21: */ ! 22: ! 23: /* ! 24: * Following remember where . was in the previous file for return ! 25: * on file switching. ! 26: */ ! 27: int altdot; ! 28: int oldadot; ! 29: bool wasalt; ! 30: short isalt; ! 31: ! 32: long cntch; /* Count of characters on unit io */ ! 33: #ifndef VMUNIX ! 34: short cntln; /* Count of lines " */ ! 35: #else ! 36: int cntln; ! 37: #endif ! 38: long cntnull; /* Count of nulls " */ ! 39: long cntodd; /* Count of non-ascii characters " */ ! 40: ! 41: #ifdef FLOCKFILE ! 42: /* ! 43: * The alternate, saved and current file are locked the extent of the ! 44: * time that they are active. If the saved file is exchanged ! 45: * with the alternate file, the file descriptors are exchanged ! 46: * and the lock is not released. ! 47: */ ! 48: int io_savedfile, io_altfile, io_curr ; ! 49: int lock_savedfile, lock_altfile, lock_curr ; ! 50: #endif FLOCKFILE ! 51: ! 52: /* ! 53: * Parse file name for command encoded by comm. ! 54: * If comm is E then command is doomed and we are ! 55: * parsing just so user won't have to retype the name. ! 56: */ ! 57: filename(comm) ! 58: int comm; ! 59: { ! 60: register int c = comm, d; ! 61: register int i; ! 62: #ifdef FLOCKFILE ! 63: int lock ; ! 64: ! 65: lock = 0 ; ! 66: #endif FLOCKFILE ! 67: ! 68: d = ex_getchar(); ! 69: if (endcmd(d)) { ! 70: if (savedfile[0] == 0 && comm != 'f') ! 71: error("No file|No current filename"); ! 72: CP(file, savedfile); ! 73: #ifdef FLOCKFILE ! 74: if (io_curr && io_curr != io_savedfile) close(io_curr) ; ! 75: lock = lock_curr = lock_savedfile ; ! 76: io_curr = io_savedfile ; ! 77: #endif FLOCKFILE ! 78: wasalt = (isalt > 0) ? isalt-1 : 0; ! 79: isalt = 0; ! 80: oldadot = altdot; ! 81: if (c == 'e' || c == 'E') ! 82: altdot = lineDOT(); ! 83: if (d == EOF) ! 84: ungetchar(d); ! 85: } else { ! 86: ungetchar(d); ! 87: getone(); ! 88: eol(); ! 89: if (savedfile[0] == 0 && c != 'E' && c != 'e') { ! 90: c = 'e'; ! 91: edited = 0; ! 92: } ! 93: wasalt = strcmp(file, altfile) == 0; ! 94: oldadot = altdot; ! 95: switch (c) { ! 96: ! 97: case 'f': ! 98: edited = 0; ! 99: /* fall into ... */ ! 100: ! 101: case 'e': ! 102: if (savedfile[0]) { ! 103: #ifdef FLOCKFILE ! 104: if (strcmp(file,savedfile) == 0) break ; ! 105: #endif FLOCKFILE ! 106: altdot = lineDOT(); ! 107: CP(altfile, savedfile); ! 108: #ifdef FLOCKFILE ! 109: if (io_altfile) close (io_altfile) ; ! 110: io_altfile = io_savedfile ; ! 111: lock_altfile = lock_savedfile ; ! 112: io_savedfile = 0 ; ! 113: #endif FLOCKFILE ! 114: } ! 115: CP(savedfile, file); ! 116: #ifdef FLOCKFILE ! 117: io_savedfile = io_curr ; ! 118: lock_savedfile = lock_curr ; ! 119: io_curr = 0 ; lock = lock_curr = 0 ; ! 120: #endif FLOCKFILE ! 121: break; ! 122: ! 123: default: ! 124: if (file[0]) { ! 125: #ifdef FLOCKFILE ! 126: if (wasalt) break ; ! 127: #endif ! 128: if (c != 'E') ! 129: altdot = lineDOT(); ! 130: CP(altfile, file); ! 131: #ifdef FLOCKFILE ! 132: if (io_altfile ! 133: && io_altfile != io_curr) close (io_altfile) ; ! 134: io_altfile = io_curr ; ! 135: lock_altfile = lock_curr ; ! 136: io_curr = 0 ; lock = lock_curr = 0 ; ! 137: #endif FLOCKFILE ! 138: } ! 139: break; ! 140: } ! 141: } ! 142: if (hush && comm != 'f' || comm == 'E') ! 143: return; ! 144: if (file[0] != 0) { ! 145: lprintf("\"%s\"", file); ! 146: if (comm == 'f') { ! 147: if (value(READONLY)) ! 148: ex_printf(" [Read only]"); ! 149: if (!edited) ! 150: ex_printf(" [Not edited]"); ! 151: if (tchng) ! 152: ex_printf(" [Modified]"); ! 153: #ifdef FLOCKFILE ! 154: if (lock == LOCK_SH) ! 155: ex_printf(" [Shared lock]") ; ! 156: else if (lock == LOCK_EX) ! 157: ex_printf(" [Exclusive lock]") ; ! 158: #endif FLOCKFILE ! 159: } ! 160: flush(); ! 161: } else ! 162: ex_printf("No file "); ! 163: if (comm == 'f') { ! 164: if (!(i = lineDOL())) ! 165: i++; ! 166: ex_printf(" line %d of %d --%ld%%--", lineDOT(), lineDOL(), ! 167: (long) 100 * lineDOT() / i); ! 168: } ! 169: } ! 170: ! 171: /* ! 172: * Get the argument words for a command into genbuf ! 173: * expanding # and %. ! 174: */ ! 175: getargs() ! 176: { ! 177: register int c; ! 178: register char *cp, *fp; ! 179: static char fpatbuf[32]; /* hence limit on :next +/pat */ ! 180: ! 181: pastwh(); ! 182: if (peekchar() == '+') { ! 183: for (cp = fpatbuf;;) { ! 184: c = *cp++ = ex_getchar(); ! 185: if (cp >= &fpatbuf[sizeof(fpatbuf)]) ! 186: error("Pattern too long"); ! 187: if (c == '\\' && isspace(peekchar())) ! 188: c = ex_getchar(); ! 189: if (c == EOF || isspace(c)) { ! 190: ungetchar(c); ! 191: *--cp = 0; ! 192: firstpat = &fpatbuf[1]; ! 193: break; ! 194: } ! 195: } ! 196: } ! 197: if (skipend()) ! 198: return (0); ! 199: CP(genbuf, "echo "); cp = &genbuf[5]; ! 200: for (;;) { ! 201: c = ex_getchar(); ! 202: if (endcmd(c)) { ! 203: ungetchar(c); ! 204: break; ! 205: } ! 206: switch (c) { ! 207: ! 208: case '\\': ! 209: if (any(peekchar(), "#%|")) ! 210: c = ex_getchar(); ! 211: /* fall into... */ ! 212: ! 213: default: ! 214: if (cp > &genbuf[LBSIZE - 2]) ! 215: flong: ! 216: error("Argument buffer overflow"); ! 217: *cp++ = c; ! 218: break; ! 219: ! 220: case '#': ! 221: fp = altfile; ! 222: if (*fp == 0) ! 223: error("No alternate filename@to substitute for #"); ! 224: goto filexp; ! 225: ! 226: case '%': ! 227: fp = savedfile; ! 228: if (*fp == 0) ! 229: error("No current filename@to substitute for %%"); ! 230: filexp: ! 231: while (*fp) { ! 232: if (cp > &genbuf[LBSIZE - 2]) ! 233: goto flong; ! 234: *cp++ = *fp++; ! 235: } ! 236: break; ! 237: } ! 238: } ! 239: *cp = 0; ! 240: return (1); ! 241: } ! 242: ! 243: /* ! 244: * Glob the argument words in genbuf, or if no globbing ! 245: * is implied, just split them up directly. ! 246: */ ! 247: glob(gp) ! 248: struct glob *gp; ! 249: { ! 250: int pvec[2]; ! 251: register char **argv = gp->argv; ! 252: register char *cp = gp->argspac; ! 253: register int c; ! 254: char ch; ! 255: int nleft = NCARGS; ! 256: ! 257: gp->argc0 = 0; ! 258: if (gscan() == 0) { ! 259: register char *v = genbuf + 5; /* strlen("echo ") */ ! 260: ! 261: for (;;) { ! 262: while (isspace(*v)) ! 263: v++; ! 264: if (!*v) ! 265: break; ! 266: *argv++ = cp; ! 267: while (*v && !isspace(*v)) ! 268: *cp++ = *v++; ! 269: *cp++ = 0; ! 270: gp->argc0++; ! 271: } ! 272: *argv = 0; ! 273: return; ! 274: } ! 275: if (pipe(pvec) < 0) ! 276: error("Can't make pipe to glob"); ! 277: pid = vfork(); ! 278: io = pvec[0]; ! 279: if (pid < 0) { ! 280: close(pvec[1]); ! 281: error("Can't fork to do glob"); ! 282: } ! 283: if (pid == 0) { ! 284: int oerrno; ! 285: ! 286: close(1); ! 287: dup(pvec[1]); ! 288: close(pvec[0]); ! 289: close(2); /* so errors don't mess up the screen */ ! 290: ignore(open("/dev/null", 1)); ! 291: execl(svalue(SHELL), "sh", "-c", genbuf, 0); ! 292: oerrno = errno; ! 293: close(1); ! 294: dup(2); ! 295: errno = oerrno; ! 296: filioerr(svalue(SHELL)); ! 297: } ! 298: close(pvec[1]); ! 299: do { ! 300: *argv = cp; ! 301: for (;;) { ! 302: if (read(io, &ch, 1) != 1) { ! 303: close(io); ! 304: c = -1; ! 305: } else ! 306: c = ch & TRIM; ! 307: if (c <= 0 || isspace(c)) ! 308: break; ! 309: *cp++ = c; ! 310: if (--nleft <= 0) ! 311: error("Arg list too long"); ! 312: } ! 313: if (cp != *argv) { ! 314: --nleft; ! 315: *cp++ = 0; ! 316: gp->argc0++; ! 317: if (gp->argc0 >= NARGS) ! 318: error("Arg list too long"); ! 319: argv++; ! 320: } ! 321: } while (c >= 0); ! 322: waitfor(); ! 323: if (gp->argc0 == 0) ! 324: error("No match"); ! 325: } ! 326: ! 327: /* ! 328: * Scan genbuf for shell metacharacters. ! 329: * Set is union of v7 shell and csh metas. ! 330: */ ! 331: gscan() ! 332: { ! 333: #ifndef vms /* Never have meta-characters in vms */ ! 334: register char *cp; ! 335: ! 336: for (cp = genbuf; *cp; cp++) ! 337: if (any(*cp, "~{[*?$`'\"\\")) ! 338: return (1); ! 339: #endif ! 340: return (0); ! 341: } ! 342: ! 343: /* ! 344: * Parse one filename into file. ! 345: */ ! 346: struct glob G; ! 347: getone() ! 348: { ! 349: register char *str; ! 350: ! 351: if (getargs() == 0) ! 352: error("Missing filename"); ! 353: glob(&G); ! 354: if (G.argc0 > 1) ! 355: error("Ambiguous|Too many file names"); ! 356: str = G.argv[G.argc0 - 1]; ! 357: if (strlen(str) > FNSIZE - 4) ! 358: error("Filename too long"); ! 359: CP(file, str); ! 360: } ! 361: ! 362: /* ! 363: * Read a file from the world. ! 364: * C is command, 'e' if this really an edit (or a recover). ! 365: */ ! 366: rop(c) ! 367: int c; ! 368: { ! 369: register int i; ! 370: struct stat stbuf; ! 371: struct exec head; ! 372: static int ovro; /* old value(READONLY) */ ! 373: static int denied; /* 1 if READONLY was set due to file permissions */ ! 374: #ifdef FLOCKFILE ! 375: int *lp, *iop; ! 376: #endif FLOCKFILE ! 377: ! 378: io = open(file, 0); ! 379: if (io < 0) { ! 380: if (c == 'e' && errno == ENOENT) { ! 381: edited++; ! 382: /* ! 383: * If the user just did "ex foo" he is probably ! 384: * creating a new file. Don't be an error, since ! 385: * this is ugly, and it screws up the + option. ! 386: */ ! 387: if (!seenprompt) { ! 388: ex_printf(" [New file]"); ! 389: noonl(); ! 390: return; ! 391: } ! 392: } ! 393: syserror(); ! 394: } ! 395: if (fstat(io, &stbuf)) ! 396: syserror(); ! 397: switch (stbuf.st_mode & S_IFMT) { ! 398: ! 399: case S_IFBLK: ! 400: error(" Block special file"); ! 401: ! 402: case S_IFCHR: ! 403: if (isatty(io)) ! 404: error(" Teletype"); ! 405: if (samei(&stbuf, "/dev/null")) ! 406: break; ! 407: error(" Character special file"); ! 408: ! 409: case S_IFDIR: ! 410: error(" Directory"); ! 411: ! 412: case S_IFREG: ! 413: #ifdef CRYPT ! 414: if (xflag) ! 415: break; ! 416: #endif ! 417: i = read(io, (char *)&head, sizeof(head)); ! 418: (void)lseek(io, 0L, L_SET); ! 419: if (i != sizeof(head)) ! 420: break; ! 421: #ifndef vms ! 422: switch ((int)head.a_magic) { ! 423: ! 424: case 0405: /* data overlay on exec */ ! 425: case OMAGIC: /* unshared */ ! 426: case NMAGIC: /* shared text */ ! 427: case 0411: /* separate I/D */ ! 428: case ZMAGIC: /* VM/Unix demand paged */ ! 429: case 0430: /* PDP-11 Overlay shared */ ! 430: case 0431: /* PDP-11 Overlay sep I/D */ ! 431: error(" Executable"); ! 432: ! 433: /* ! 434: * We do not forbid the editing of portable archives ! 435: * because it is reasonable to edit them, especially ! 436: * if they are archives of text files. This is ! 437: * especially useful if you archive source files together ! 438: * and copy them to another system with ~%take, since ! 439: * the files sometimes show up munged and must be fixed. ! 440: */ ! 441: case 0177545: ! 442: case 0177555: ! 443: error(" Archive"); ! 444: case 070707: ! 445: error(" Cpio file"); ! 446: ! 447: default: ! 448: { ! 449: char *bp = (char *)&head; ! 450: if ((u_char)bp[0] == (u_char)'\037' && ! 451: (u_char)bp[1] == (u_char)'\235') ! 452: error(" Compressed file"); ! 453: if (!strncmp(bp, "!<arch>\n__.SYMDEF", 17) ! 454: || !strncmp(bp, "!<arch>\n", 8)) ! 455: error(" Archive"); ! 456: } ! 457: break; ! 458: } ! 459: #endif ! 460: } ! 461: if (c != 'r') { ! 462: if (value(READONLY) && denied) { ! 463: value(READONLY) = ovro; ! 464: denied = 0; ! 465: } ! 466: if ((stbuf.st_mode & 0222) == 0 || access(file, 2) < 0) { ! 467: ovro = value(READONLY); ! 468: denied = 1; ! 469: value(READONLY) = 1; ! 470: } ! 471: } ! 472: if (value(READONLY)) { ! 473: ex_printf(" [Read only]"); ! 474: flush(); ! 475: } ! 476: #ifdef FLOCKFILE ! 477: /* ! 478: * Attempt to lock the file. We use an sharable lock if reading ! 479: * the file, and an exclusive lock if editting a file. ! 480: * The lock will be released when the file is no longer being ! 481: * referenced. At any time, the editor can have as many as ! 482: * three files locked, and with different lock statuses. ! 483: */ ! 484: /* ! 485: * if this is either the saved or alternate file or current file, ! 486: * point to the appropriate descriptor and file lock status. ! 487: */ ! 488: if (strcmp (file,savedfile) == 0) { ! 489: if (!io_savedfile) io_savedfile = dup(io) ; ! 490: lp = &lock_savedfile ; iop = &io_savedfile ; ! 491: } else if (strcmp (file,altfile) == 0) { ! 492: if (!io_altfile) io_altfile = dup(io) ; ! 493: lp = &lock_altfile ; iop = &io_altfile ; ! 494: } else { ! 495: /* throw away current lock, accquire new current lock */ ! 496: if (io_curr) close (io_curr) ; ! 497: io_curr = dup(io) ; ! 498: lp = &lock_curr ; iop = &io_curr ; ! 499: lock_curr = 0 ; ! 500: } ! 501: if (c == 'r' || value(READONLY) || *lp == 0) { ! 502: /* if we have a lock already, don't bother */ ! 503: if (!*lp) { ! 504: /* try for a shared lock */ ! 505: if (flock(*iop, LOCK_SH|LOCK_NB) < 0 ! 506: && errno == EWOULDBLOCK) { ! 507: ex_printf ( ! 508: " [FILE BEING MODIFIED BY ANOTHER PROCESS]") ; ! 509: flush(); ! 510: goto fail_lock ; ! 511: } else *lp = LOCK_SH ; ! 512: } ! 513: } ! 514: if ( c != 'r' && !value(READONLY) && *lp != LOCK_EX) { ! 515: /* if we are editting the file, upgrade to an exclusive lock. */ ! 516: if (flock(*iop, LOCK_EX|LOCK_NB) < 0 && errno == EWOULDBLOCK) { ! 517: ex_printf (" [File open by another process]") ; ! 518: flush(); ! 519: } else *lp = LOCK_EX ; ! 520: } ! 521: fail_lock: ! 522: #endif FLOCKFILE ! 523: if (c == 'r') ! 524: setdot(); ! 525: else ! 526: setall(); ! 527: if (FIXUNDO && inopen && c == 'r') ! 528: undap1 = undap2 = dot + 1; ! 529: rop2(); ! 530: rop3(c); ! 531: } ! 532: ! 533: rop2() ! 534: { ! 535: line *first, *last, *a; ! 536: struct stat statb; ! 537: ! 538: deletenone(); ! 539: clrstats(); ! 540: first = addr2 + 1; ! 541: if (fstat(io, &statb) < 0) ! 542: bsize = LBSIZE; ! 543: else { ! 544: bsize = statb.st_blksize; ! 545: if (bsize <= 0) ! 546: bsize = LBSIZE; ! 547: } ! 548: ignore(append(getfile, addr2)); ! 549: last = dot; ! 550: /* ! 551: * if the modeline variable is set, ! 552: * check the first and last five lines of the file ! 553: * for a mode line. ! 554: */ ! 555: if (value(MODELINE)) { ! 556: for (a=first; a<=last; a++) { ! 557: if (a==first+5 && last-first > 10) ! 558: a = last - 4; ! 559: getline(*a); ! 560: checkmodeline(linebuf); ! 561: } ! 562: } ! 563: } ! 564: ! 565: rop3(c) ! 566: int c; ! 567: { ! 568: ! 569: if (iostats() == 0 && c == 'e') ! 570: edited++; ! 571: if (c == 'e') { ! 572: if (wasalt || firstpat) { ! 573: register line *addr = zero + oldadot; ! 574: ! 575: if (addr > dol) ! 576: addr = dol; ! 577: if (firstpat) { ! 578: globp = (*firstpat) ? firstpat : "$"; ! 579: commands(1,1); ! 580: firstpat = 0; ! 581: } else if (addr >= one) { ! 582: if (inopen) ! 583: dot = addr; ! 584: markpr(addr); ! 585: } else ! 586: goto other; ! 587: } else ! 588: other: ! 589: if (dol > zero) { ! 590: if (inopen) ! 591: dot = one; ! 592: markpr(one); ! 593: } ! 594: if(FIXUNDO) ! 595: undkind = UNDNONE; ! 596: if (inopen) { ! 597: vcline = 0; ! 598: vreplace(0, LINES, lineDOL()); ! 599: } ! 600: } ! 601: } ! 602: ! 603: /* ! 604: * Are these two really the same inode? ! 605: */ ! 606: samei(sp, cp) ! 607: struct stat *sp; ! 608: char *cp; ! 609: { ! 610: struct stat stb; ! 611: ! 612: if (stat(cp, &stb) < 0 || sp->st_dev != stb.st_dev) ! 613: return (0); ! 614: return (sp->st_ino == stb.st_ino); ! 615: } ! 616: ! 617: /* Returns from edited() */ ! 618: #define EDF 0 /* Edited file */ ! 619: #define NOTEDF -1 /* Not edited file */ ! 620: #define PARTBUF 1 /* Write of partial buffer to Edited file */ ! 621: ! 622: /* ! 623: * Write a file. ! 624: */ ! 625: wop(dofname) ! 626: bool dofname; /* if 1 call filename, else use savedfile */ ! 627: { ! 628: register int c, exclam, nonexist; ! 629: line *saddr1, *saddr2; ! 630: struct stat stbuf; ! 631: #ifdef FLOCKFILE ! 632: int *lp, *iop ; ! 633: #endif FLOCKFILE ! 634: ! 635: c = 0; ! 636: exclam = 0; ! 637: if (dofname) { ! 638: if (peekchar() == '!') ! 639: exclam++, ignchar(); ! 640: ignore(skipwh()); ! 641: while (peekchar() == '>') ! 642: ignchar(), c++, ignore(skipwh()); ! 643: if (c != 0 && c != 2) ! 644: error("Write forms are 'w' and 'w>>'"); ! 645: filename('w'); ! 646: } else { ! 647: if (savedfile[0] == 0) ! 648: error("No file|No current filename"); ! 649: saddr1=addr1; ! 650: saddr2=addr2; ! 651: addr1=one; ! 652: addr2=dol; ! 653: CP(file, savedfile); ! 654: if (inopen) { ! 655: vclrech(0); ! 656: splitw++; ! 657: } ! 658: lprintf("\"%s\"", file); ! 659: } ! 660: nonexist = stat(file, &stbuf); ! 661: #ifdef FLOCKFILE ! 662: /* ! 663: * if this is either the saved or alternate file or current file, ! 664: * point to the appropriate descriptor and file lock status. ! 665: */ ! 666: if (strcmp (file,savedfile) == 0) { ! 667: lp = &lock_savedfile ; iop = &io_savedfile ; ! 668: } else if (strcmp (file,altfile) == 0) { ! 669: lp = &lock_altfile ; iop = &io_altfile ; ! 670: } else { ! 671: lp = &lock_curr ; iop = &io_curr ; ! 672: } ! 673: if (!*iop && !nonexist){ ! 674: *lp = 0 ; ! 675: if ((*iop = open(file, 1)) < 0) *iop = 0 ; ! 676: } ! 677: #endif FLOCKFILE ! 678: switch (c) { ! 679: ! 680: case 0: ! 681: if (!exclam && (!value(WRITEANY) || value(READONLY))) ! 682: switch (edfile()) { ! 683: ! 684: case NOTEDF: ! 685: if (nonexist) ! 686: break; ! 687: if ((stbuf.st_mode & S_IFMT) == S_IFCHR) { ! 688: if (samei(&stbuf, "/dev/null")) ! 689: break; ! 690: if (samei(&stbuf, "/dev/tty")) ! 691: break; ! 692: } ! 693: io = open(file, 1); ! 694: if (io < 0) ! 695: syserror(); ! 696: if (!isatty(io)) ! 697: serror(" File exists| File exists - use \"w! %s\" to overwrite", file); ! 698: close(io); ! 699: break; ! 700: ! 701: case EDF: ! 702: if (value(READONLY)) ! 703: error(" File is read only"); ! 704: break; ! 705: ! 706: case PARTBUF: ! 707: if (value(READONLY)) ! 708: error(" File is read only"); ! 709: error(" Use \"w!\" to write partial buffer"); ! 710: } ! 711: cre: ! 712: /* ! 713: synctmp(); ! 714: */ ! 715: #ifdef FLOCKFILE ! 716: if (*iop && !*lp != LOCK_EX && !exclam) { ! 717: /* ! 718: * upgrade to a exclusive lock. if can't get, someone else ! 719: * has the exclusive lock. bitch to the user. ! 720: */ ! 721: if (flock(*iop, LOCK_EX|LOCK_NB) < 0 && errno == EWOULDBLOCK) ! 722: error (" File being modified by another process - use \"w!\" to write"); ! 723: else *lp = LOCK_EX ; ! 724: } ! 725: #endif FLOCKFILE ! 726: #ifdef V6 ! 727: io = creat(file, 0644); ! 728: #else ! 729: io = creat(file, 0666); ! 730: #ifdef vms /* to retain file protection modes on newer version of file */ ! 731: if (!nonexist) ! 732: chmod(file, stbuf.st_mode & 0777); ! 733: #endif ! 734: #endif ! 735: if (io < 0) ! 736: syserror(); ! 737: writing = 1; ! 738: if (hush == 0) ! 739: if (nonexist) ! 740: ex_printf(" [New file]"); ! 741: else if (value(WRITEANY) && edfile() != EDF) ! 742: ex_printf(" [Existing file]"); ! 743: #ifdef FLOCKFILE ! 744: if (!*iop) ! 745: *iop = dup(io) ; ! 746: #endif FLOCKFILE ! 747: break; ! 748: ! 749: case 2: ! 750: io = open(file, 1); ! 751: if (io < 0) { ! 752: if (exclam || value(WRITEANY)) ! 753: goto cre; ! 754: syserror(); ! 755: } ! 756: lseek(io, 0l, 2); ! 757: #ifdef FLOCKFILE ! 758: if (!*iop) *iop = dup(io) ; ! 759: if (*lp != LOCK_EX && !exclam) { ! 760: /* ! 761: * upgrade to a exclusive lock. if can't get, ! 762: * someone else has the exclusive lock. ! 763: * bitch to the user. ! 764: */ ! 765: if (flock(*iop, LOCK_SH|LOCK_NB) < 0 ! 766: && errno == EWOULDBLOCK) ! 767: error ( ! 768: " File being modified by another process - use \"w!>>\" to write"); ! 769: else *lp = LOCK_EX ; ! 770: } ! 771: #endif FLOCKFILE ! 772: break; ! 773: } ! 774: #ifdef FLOCKFILE ! 775: if (flock(*iop, LOCK_EX|LOCK_NB) >= 0) ! 776: *lp = LOCK_EX ; ! 777: #endif FLOCKFILE ! 778: putfile(0); ! 779: #ifndef vms ! 780: (void) fsync(io); ! 781: #endif ! 782: ignore(iostats()); ! 783: if (c != 2 && addr1 == one && addr2 == dol) { ! 784: if (eq(file, savedfile)) ! 785: edited = 1; ! 786: ex_sync(); ! 787: } ! 788: if (!dofname) { ! 789: addr1 = saddr1; ! 790: addr2 = saddr2; ! 791: } ! 792: writing = 0; ! 793: } ! 794: ! 795: /* ! 796: * Is file the edited file? ! 797: * Work here is that it is not considered edited ! 798: * if this is a partial buffer, and distinguish ! 799: * all cases. ! 800: */ ! 801: edfile() ! 802: { ! 803: ! 804: if (!edited || !eq(file, savedfile)) ! 805: return (NOTEDF); ! 806: return (addr1 == one && addr2 == dol ? EDF : PARTBUF); ! 807: } ! 808: ! 809: /* ! 810: * Extract the next line from the io stream. ! 811: */ ! 812: char *nextip; ! 813: ! 814: getfile() ! 815: { ! 816: register short c; ! 817: register char *lp, *fp; ! 818: ! 819: lp = linebuf; ! 820: fp = nextip; ! 821: do { ! 822: if (--ninbuf < 0) { ! 823: ninbuf = read(io, genbuf, (int) bsize) - 1; ! 824: if (ninbuf < 0) { ! 825: if (lp != linebuf) { ! 826: lp++; ! 827: ex_printf(" [Incomplete last line]"); ! 828: break; ! 829: } ! 830: return (EOF); ! 831: } ! 832: #ifdef CRYPT ! 833: if (kflag) { ! 834: fp = genbuf; ! 835: while(fp < &genbuf[ninbuf]) { ! 836: if (*fp++ & 0200) { ! 837: crblock(perm, genbuf, ninbuf+1, ! 838: cntch); ! 839: break; ! 840: } ! 841: } ! 842: } ! 843: #endif ! 844: fp = genbuf; ! 845: cntch += ninbuf+1; ! 846: } ! 847: if (lp >= &linebuf[LBSIZE]) { ! 848: error(" Line too long"); ! 849: } ! 850: c = *fp++; ! 851: if (c == 0) { ! 852: cntnull++; ! 853: continue; ! 854: } ! 855: if (c & QUOTE) { ! 856: cntodd++; ! 857: c &= TRIM; ! 858: if (c == 0) ! 859: continue; ! 860: } ! 861: *lp++ = c; ! 862: } while (c != '\n'); ! 863: *--lp = 0; ! 864: nextip = fp; ! 865: cntln++; ! 866: return (0); ! 867: } ! 868: ! 869: /* ! 870: * Write a range onto the io stream. ! 871: */ ! 872: /* ARGSUSED */ ! 873: putfile(isfilter) ! 874: int isfilter; ! 875: { ! 876: line *a1; ! 877: register char *fp, *lp; ! 878: register int nib; ! 879: struct stat statb; ! 880: ! 881: a1 = addr1; ! 882: clrstats(); ! 883: cntln = addr2 - a1 + 1; ! 884: if (cntln == 0) ! 885: return; ! 886: if (fstat(io, &statb) < 0) ! 887: bsize = LBSIZE; ! 888: else { ! 889: bsize = statb.st_blksize; ! 890: if (bsize <= 0) ! 891: bsize = LBSIZE; ! 892: } ! 893: nib = bsize; ! 894: fp = genbuf; ! 895: do { ! 896: getline(*a1++); ! 897: lp = linebuf; ! 898: for (;;) { ! 899: if (--nib < 0) { ! 900: nib = fp - genbuf; ! 901: #ifdef CRYPT ! 902: if(kflag && !isfilter) ! 903: crblock(perm, genbuf, nib, cntch); ! 904: #endif ! 905: if (write(io, genbuf, nib) != nib) { ! 906: wrerror(); ! 907: } ! 908: cntch += nib; ! 909: nib = bsize - 1; ! 910: fp = genbuf; ! 911: } ! 912: if ((*fp++ = *lp++) == 0) { ! 913: fp[-1] = '\n'; ! 914: break; ! 915: } ! 916: } ! 917: } while (a1 <= addr2); ! 918: nib = fp - genbuf; ! 919: #ifdef CRYPT ! 920: if(kflag && !isfilter) ! 921: crblock(perm, genbuf, nib, cntch); ! 922: #endif ! 923: if (write(io, genbuf, nib) != nib) { ! 924: wrerror(); ! 925: } ! 926: cntch += nib; ! 927: } ! 928: ! 929: /* ! 930: * A write error has occurred; if the file being written was ! 931: * the edited file then we consider it to have changed since it is ! 932: * now likely scrambled. ! 933: */ ! 934: wrerror() ! 935: { ! 936: ! 937: if (eq(file, savedfile) && edited) ! 938: change(); ! 939: syserror(); ! 940: } ! 941: ! 942: /* ! 943: * Source command, handles nested sources. ! 944: * Traps errors since it mungs unit 0 during the source. ! 945: */ ! 946: short slevel; ! 947: short ttyindes; ! 948: ! 949: source(fil, okfail) ! 950: char *fil; ! 951: bool okfail; ! 952: { ! 953: jmp_buf osetexit; ! 954: register int saveinp, ointty, oerrno; ! 955: char *saveglobp; ! 956: short savepeekc; ! 957: ! 958: signal(SIGINT, SIG_IGN); ! 959: saveinp = dup(0); ! 960: savepeekc = peekc; ! 961: saveglobp = globp; ! 962: peekc = 0; globp = 0; ! 963: if (saveinp < 0) ! 964: error("Too many nested sources"); ! 965: if (slevel <= 0) ! 966: ttyindes = saveinp; ! 967: close(0); ! 968: if (open(fil, 0) < 0) { ! 969: oerrno = errno; ! 970: setrupt(); ! 971: dup(saveinp); ! 972: close(saveinp); ! 973: errno = oerrno; ! 974: if (!okfail) ! 975: filioerr(fil); ! 976: return; ! 977: } ! 978: slevel++; ! 979: ointty = intty; ! 980: intty = isatty(0); ! 981: oprompt = value(PROMPT); ! 982: value(PROMPT) &= intty; ! 983: getexit(osetexit); ! 984: setrupt(); ! 985: if (setexit() == 0) ! 986: commands(1, 1); ! 987: else if (slevel > 1) { ! 988: close(0); ! 989: dup(saveinp); ! 990: close(saveinp); ! 991: slevel--; ! 992: resexit(osetexit); ! 993: reset(); ! 994: } ! 995: intty = ointty; ! 996: value(PROMPT) = oprompt; ! 997: close(0); ! 998: dup(saveinp); ! 999: close(saveinp); ! 1000: globp = saveglobp; ! 1001: peekc = savepeekc; ! 1002: slevel--; ! 1003: resexit(osetexit); ! 1004: } ! 1005: ! 1006: /* ! 1007: * Clear io statistics before a read or write. ! 1008: */ ! 1009: clrstats() ! 1010: { ! 1011: ! 1012: ninbuf = 0; ! 1013: cntch = 0; ! 1014: cntln = 0; ! 1015: cntnull = 0; ! 1016: cntodd = 0; ! 1017: } ! 1018: ! 1019: /* ! 1020: * Io is finished, close the unit and print statistics. ! 1021: */ ! 1022: iostats() ! 1023: { ! 1024: ! 1025: close(io); ! 1026: io = -1; ! 1027: if (hush == 0) { ! 1028: if (value(TERSE)) ! 1029: ex_printf(" %d/%D", cntln, cntch); ! 1030: else ! 1031: ex_printf(" %d line%s, %D character%s", cntln, plural((long) cntln), ! 1032: cntch, plural(cntch)); ! 1033: if (cntnull || cntodd) { ! 1034: ex_printf(" ("); ! 1035: if (cntnull) { ! 1036: ex_printf("%D null", cntnull); ! 1037: if (cntodd) ! 1038: ex_printf(", "); ! 1039: } ! 1040: if (cntodd) ! 1041: ex_printf("%D non-ASCII", cntodd); ! 1042: ex_putchar(')'); ! 1043: } ! 1044: noonl(); ! 1045: flush(); ! 1046: } ! 1047: return (cntnull != 0 || cntodd != 0); ! 1048: } ! 1049: ! 1050: #ifdef USG ! 1051: # define index strchr ! 1052: # define rindex strrchr ! 1053: #endif ! 1054: #ifdef USG3TTY ! 1055: # define index strchr ! 1056: # define rindex strrchr ! 1057: #endif ! 1058: #ifdef vms ! 1059: # define index strchr ! 1060: # define rindex strrchr ! 1061: #endif ! 1062: ! 1063: checkmodeline(l) ! 1064: char *l; ! 1065: { ! 1066: char *beg, *end; ! 1067: char cmdbuf[1024]; ! 1068: char *index(), *rindex(), *strncpy(); ! 1069: ! 1070: beg = index(l, ':'); ! 1071: if (beg == NULL) ! 1072: return; ! 1073: if (&beg[-3] < l) ! 1074: return; ! 1075: if (!( ( (beg[-3] == ' ' || beg[-3] == '\t') ! 1076: && beg[-2] == 'e' ! 1077: && beg[-1] == 'x') ! 1078: || ( (beg[-3] == ' ' || beg[-3] == '\t') ! 1079: && beg[-2] == 'v' ! 1080: && beg[-1] == 'i'))) return; ! 1081: strncpy(cmdbuf, beg+1, sizeof cmdbuf); ! 1082: end = rindex(cmdbuf, ':'); ! 1083: if (end == NULL) ! 1084: return; ! 1085: *end = 0; ! 1086: globp = cmdbuf; ! 1087: commands(1, 1); ! 1088: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.