![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to io.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / jove|
Return to io.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / jove |
1.1 ! root 1: /************************************************************************* ! 2: * This program is copyright (C) 1985, 1986 by Jonathan Payne. It is * ! 3: * provided to you without charge for use only on a licensed Unix * ! 4: * system. You may copy JOVE provided that this notice is included with * ! 5: * the copy. You may not sell copies of this program or versions * ! 6: * modified for use on microcomputer systems, unless the copies are * ! 7: * included with a Unix system distribution and the source is provided. * ! 8: *************************************************************************/ ! 9: ! 10: #include "jove.h" ! 11: #include "io.h" ! 12: #include "termcap.h" ! 13: ! 14: #ifdef IPROCS ! 15: # include <signal.h> ! 16: #endif ! 17: ! 18: #include <sys/stat.h> ! 19: #include <sys/file.h> ! 20: #include <errno.h> ! 21: ! 22: long io_chars; /* number of chars in this open_file */ ! 23: int io_lines; /* number of lines in this open_file */ ! 24: private int tellall; /* display file io info? */ ! 25: ! 26: #ifdef VMUNIX ! 27: char iobuff[LBSIZE], ! 28: genbuf[LBSIZE], ! 29: linebuf[LBSIZE]; ! 30: #else ! 31: char *iobuff, ! 32: *genbuf, ! 33: *linebuf; ! 34: #endif ! 35: ! 36: #ifdef BACKUPFILES ! 37: int BkupOnWrite = 0; ! 38: #endif ! 39: ! 40: close_file(fp) ! 41: File *fp; ! 42: { ! 43: if (fp) { ! 44: f_close(fp); ! 45: if (tellall != QUIET) ! 46: add_mess(" %d lines, %D characters.", ! 47: io_lines, ! 48: io_chars); ! 49: } ! 50: } ! 51: ! 52: /* Write the region from line1/char1 to line2/char2 to FP. This ! 53: never CLOSES the file since we don't know if we want to. */ ! 54: ! 55: int EndWNewline = 1; ! 56: ! 57: putreg(fp, line1, char1, line2, char2, makesure) ! 58: register File *fp; ! 59: Line *line1, ! 60: *line2; ! 61: { ! 62: register int c; ! 63: register char *lp; ! 64: ! 65: if (makesure) ! 66: (void) fixorder(&line1, &char1, &line2, &char2); ! 67: while (line1 != line2->l_next) { ! 68: lp = lcontents(line1) + char1; ! 69: if (line1 == line2) ! 70: fputnchar(lp, (char2 - char1), fp); ! 71: else while (c = *lp++) { ! 72: putc(c, fp); ! 73: io_chars++; ! 74: } ! 75: if (line1 != line2) { ! 76: io_lines++; ! 77: io_chars++; ! 78: putc('\n', fp); ! 79: } ! 80: line1 = line1->l_next; ! 81: char1 = 0; ! 82: } ! 83: flush(fp); ! 84: } ! 85: ! 86: read_file(file, is_insert) ! 87: char *file; ! 88: { ! 89: Bufpos save; ! 90: File *fp; ! 91: ! 92: if (!is_insert) { ! 93: curbuf->b_ntbf = 0; ! 94: set_ino(curbuf); ! 95: } ! 96: fp = open_file(file, iobuff, F_READ, !COMPLAIN, !QUIET); ! 97: if (fp == NIL) { ! 98: if (!is_insert && errno == ENOENT) ! 99: s_mess("(new file)"); ! 100: else ! 101: s_mess(IOerr("open", file)); ! 102: return; ! 103: } ! 104: DOTsave(&save); ! 105: dofread(fp); ! 106: SetDot(&save); ! 107: if (is_insert && io_chars > 0) ! 108: modify(); ! 109: getDOT(); ! 110: close_file(fp); ! 111: } ! 112: ! 113: dofread(fp) ! 114: register File *fp; ! 115: { ! 116: char end[LBSIZE]; ! 117: int xeof = 0; ! 118: Line *savel = curline; ! 119: int savec = curchar; ! 120: ! 121: strcpy(end, linebuf + curchar); ! 122: xeof = f_gets(fp, linebuf + curchar, LBSIZE - curchar); ! 123: SavLine(curline, linebuf); ! 124: if (!xeof) do { ! 125: xeof = f_gets(fp, linebuf, LBSIZE); ! 126: curline = listput(curbuf, curline); ! 127: curline->l_dline = putline(linebuf) | DIRTY; ! 128: } while (!xeof); ! 129: linecopy(linebuf, (curchar = strlen(linebuf)), end); ! 130: SavLine(curline, linebuf); ! 131: IFixMarks(savel, savec, curline, curchar); ! 132: } ! 133: ! 134: SaveFile() ! 135: { ! 136: if (IsModified(curbuf)) { ! 137: if (curbuf->b_fname == 0) ! 138: WriteFile(); ! 139: else { ! 140: filemunge(curbuf->b_fname); ! 141: chk_mtime(curbuf->b_fname, "save"); ! 142: file_write(curbuf->b_fname, 0); ! 143: unmodify(); ! 144: } ! 145: } else ! 146: message("No changes need to be written."); ! 147: } ! 148: ! 149: char *HomeDir; /* home directory */ ! 150: int HomeLen = -1; /* length of home directory string */ ! 151: ! 152: #ifndef CHDIR ! 153: ! 154: char * ! 155: pr_name(fname) ! 156: char *fname; ! 157: { ! 158: if (fname == 0) ! 159: return 0; ! 160: ! 161: if (strncmp(fname, HomeDir, HomeLen) == 0) { ! 162: static char name_buf[100]; ! 163: ! 164: sprintf(name_buf, "~%s", fname + HomeLen); ! 165: return name_buf; ! 166: } ! 167: ! 168: return fname; ! 169: } ! 170: ! 171: #else ! 172: ! 173: #define NDIRS 5 ! 174: ! 175: private char *DirStack[NDIRS] = {0}; ! 176: private int DirSP = 0; /* Directory stack pointer */ ! 177: #define PWD (DirStack[DirSP]) ! 178: ! 179: char * ! 180: pwd() ! 181: { ! 182: return PWD; ! 183: } ! 184: ! 185: char * ! 186: pr_name(fname) ! 187: char *fname; ! 188: { ! 189: int n; ! 190: ! 191: if (fname == 0) ! 192: return 0; ! 193: n = numcomp(fname, PWD); ! 194: ! 195: if ((PWD[n] == 0) && /* Matched to end of PWD */ ! 196: (fname[n] == '/')) ! 197: return fname + n + 1; ! 198: ! 199: if (strcmp(HomeDir, "/") != 0 && strncmp(fname, HomeDir, HomeLen) == 0) { ! 200: static char name_buf[100]; ! 201: ! 202: sprintf(name_buf, "~%s", fname + HomeLen); ! 203: return name_buf; ! 204: } ! 205: ! 206: return fname; /* return entire path name */ ! 207: } ! 208: ! 209: Chdir() ! 210: { ! 211: char dirbuf[FILESIZE]; ! 212: ! 213: (void) ask_file(PWD, dirbuf); ! 214: if (chdir(dirbuf) == -1) { ! 215: s_mess("cd: cannot change into %s.", dirbuf); ! 216: return; ! 217: } ! 218: UpdModLine++; ! 219: setCWD(dirbuf); ! 220: } ! 221: ! 222: #ifndef JOB_CONTROL ! 223: char * ! 224: getwd() ! 225: { ! 226: Buffer *old = curbuf; ! 227: char *ret_val; ! 228: ! 229: SetBuf(do_select((Window *) 0, "pwd-output")); ! 230: curbuf->b_type = B_PROCESS; ! 231: (void) UnixToBuf("pwd-output", NO, 0, YES, "/bin/pwd", "pwd", 0); ! 232: ToFirst(); ! 233: ret_val = sprint(linebuf); ! 234: SetBuf(old); ! 235: return ret_val; ! 236: } ! 237: #endif ! 238: ! 239: setCWD(d) ! 240: char *d; ! 241: { ! 242: if (PWD == 0) ! 243: PWD = malloc((unsigned) strlen(d) + 1); ! 244: else { ! 245: extern char *ralloc(); ! 246: ! 247: PWD = ralloc(PWD, strlen(d) + 1); ! 248: } ! 249: strcpy(PWD, d); ! 250: } ! 251: ! 252: getCWD() ! 253: { ! 254: char *cwd = getenv("CWD"); ! 255: #ifdef JOB_CONTROL ! 256: extern char *getwd(); ! 257: char pathname[FILESIZE]; ! 258: #endif ! 259: ! 260: if (cwd == 0) ! 261: #ifdef JOB_CONTROL ! 262: cwd = getwd(pathname); ! 263: #else ! 264: cwd = getwd(); ! 265: #endif ! 266: ! 267: setCWD(cwd); ! 268: } ! 269: ! 270: prDIRS() ! 271: { ! 272: register int i; ! 273: ! 274: s_mess(": %f "); ! 275: for (i = DirSP; i >= 0; i--) ! 276: add_mess("%s ", pr_name(DirStack[i])); ! 277: } ! 278: ! 279: prCWD() ! 280: { ! 281: s_mess(": %f => \"%s\"", PWD); ! 282: } ! 283: ! 284: Pushd() ! 285: { ! 286: char *newdir, ! 287: dirbuf[FILESIZE]; ! 288: ! 289: newdir = ask_file(NullStr, dirbuf); /* Parses directories ... */ ! 290: UpdModLine++; ! 291: if (*newdir == 0) { /* Wants to swap top two entries */ ! 292: char *old_top; ! 293: ! 294: if (DirSP == 0) ! 295: complain("pushd: no other directory."); ! 296: old_top = PWD; ! 297: DirStack[DirSP] = DirStack[DirSP - 1]; ! 298: DirStack[DirSP - 1] = old_top; ! 299: (void) chdir(PWD); ! 300: } else { ! 301: if (chdir(dirbuf) == -1) { ! 302: s_mess("pushd: cannot change into %s.", dirbuf); ! 303: return; ! 304: } ! 305: ! 306: if (DirSP + 1 >= NDIRS) ! 307: complain("pushd: full stack; max of %d pushes.", NDIRS); ! 308: DirSP++; ! 309: setCWD(dirbuf); ! 310: } ! 311: prDIRS(); ! 312: } ! 313: ! 314: Popd() ! 315: { ! 316: if (DirSP == 0) ! 317: complain("popd: directory stack is empty."); ! 318: UpdModLine++; ! 319: free(PWD); ! 320: PWD = 0; ! 321: DirSP--; ! 322: (void) chdir(PWD); /* If this doesn't work, we's in deep shit. */ ! 323: prDIRS(); ! 324: } ! 325: ! 326: private char * ! 327: dbackup(base, offset, c) ! 328: register char *base, ! 329: *offset, ! 330: c; ! 331: { ! 332: while (offset > base && *--offset != c) ! 333: ; ! 334: return offset; ! 335: } ! 336: ! 337: dfollow(file, into) ! 338: char *file, ! 339: *into; ! 340: { ! 341: char *dp, ! 342: *sp; ! 343: ! 344: if (*file == '/') { /* Absolute pathname */ ! 345: strcpy(into, "/"); ! 346: file++; ! 347: } else ! 348: strcpy(into, PWD); ! 349: dp = into + strlen(into); ! 350: ! 351: sp = file; ! 352: do { ! 353: if (*file == 0) ! 354: break; ! 355: if (sp = index(file, '/')) ! 356: *sp = 0; ! 357: if (strcmp(file, ".") == 0) ! 358: ; /* So it will get to the end of the loop */ ! 359: else if (strcmp(file, "..") == 0) { ! 360: *(dp = dbackup(into, dp, '/')) = 0; ! 361: if (dp == into) ! 362: strcpy(into, "/"), dp = into + 1; ! 363: } else { ! 364: if (into[strlen(into) - 1] != '/') ! 365: (void) strcat(into, "/"); ! 366: (void) strcat(into, file); ! 367: dp += strlen(file); /* stay at the end */ ! 368: } ! 369: file = sp + 1; ! 370: } while (sp != 0); ! 371: } ! 372: ! 373: #endif CHDIR ! 374: ! 375: get_hdir(user, buf) ! 376: register char *user, ! 377: *buf; ! 378: { ! 379: char fbuf[LBSIZE], ! 380: pattern[100]; ! 381: register int u_len; ! 382: File *fp; ! 383: ! 384: u_len = strlen(user); ! 385: fp = open_file("/etc/passwd", fbuf, F_READ, COMPLAIN, QUIET); ! 386: sprintf(pattern, "%s:[^:]*:[^:]*:[^:]*:[^:]*:\\([^:]*\\):", user); ! 387: while (f_gets(fp, genbuf, LBSIZE) != EOF) ! 388: if ((strncmp(genbuf, user, u_len) == 0) && ! 389: (LookingAt(pattern, genbuf, 0))) { ! 390: putmatch(1, buf, FILESIZE); ! 391: close_file(fp); ! 392: return; ! 393: } ! 394: f_close(fp); ! 395: complain("[unknown user: %s]", user); ! 396: } ! 397: ! 398: PathParse(name, intobuf) ! 399: char *name, ! 400: *intobuf; ! 401: { ! 402: char localbuf[FILESIZE]; ! 403: ! 404: intobuf[0] = localbuf[0] = '\0'; ! 405: if (*name == '\0') ! 406: return; ! 407: if (*name == '~') { ! 408: if (name[1] == '/' || name[1] == '\0') { ! 409: strcpy(localbuf, HomeDir); ! 410: name++; ! 411: } else { ! 412: char *uendp = index(name, '/'), ! 413: unamebuf[30]; ! 414: ! 415: if (uendp == 0) ! 416: uendp = name + strlen(name); ! 417: name = name + 1; ! 418: null_ncpy(unamebuf, name, uendp - name); ! 419: get_hdir(unamebuf, localbuf); ! 420: name = uendp; ! 421: } ! 422: } else if (*name == '\\') ! 423: name++; ! 424: (void) strcat(localbuf, name); ! 425: #ifdef CHDIR ! 426: dfollow(localbuf, intobuf); ! 427: #else ! 428: strcpy(intobuf, localbuf); ! 429: #endif ! 430: } ! 431: ! 432: filemunge(newname) ! 433: char *newname; ! 434: { ! 435: struct stat stbuf; ! 436: ! 437: if (newname == 0) ! 438: return; ! 439: if (stat(newname, &stbuf)) ! 440: return; ! 441: if ((stbuf.st_ino != curbuf->b_ino) && ! 442: ((stbuf.st_mode & S_IFMT) != S_IFCHR) && ! 443: (strcmp(newname, curbuf->b_fname) != 0)) { ! 444: rbell(); ! 445: confirm("\"%s\" already exists; overwrite it? ", newname); ! 446: } ! 447: } ! 448: ! 449: WrtReg() ! 450: { ! 451: DoWriteReg(0); ! 452: } ! 453: ! 454: AppReg() ! 455: { ! 456: DoWriteReg(1); ! 457: } ! 458: ! 459: int CreatMode = DFLT_MODE; ! 460: ! 461: DoWriteReg(app) ! 462: { ! 463: char fnamebuf[FILESIZE], ! 464: *fname; ! 465: Mark *mp = CurMark(); ! 466: File *fp; ! 467: ! 468: /* Won't get here if there isn't a Mark */ ! 469: fname = ask_file((char *) 0, fnamebuf); ! 470: ! 471: #ifdef BACKUPFILES ! 472: if (!app) { ! 473: filemunge(fname); ! 474: ! 475: if (BkupOnWrite) ! 476: file_backup(fname); ! 477: } ! 478: #else ! 479: if (!app) ! 480: filemunge(fname); ! 481: #endif ! 482: ! 483: fp = open_file(fname, iobuff, app ? F_APPEND : F_WRITE, COMPLAIN, !QUIET); ! 484: putreg(fp, mp->m_line, mp->m_char, curline, curchar, YES); ! 485: close_file(fp); ! 486: } ! 487: ! 488: int OkayBadChars = 0; ! 489: ! 490: WriteFile() ! 491: { ! 492: char *fname, ! 493: fnamebuf[FILESIZE]; ! 494: ! 495: fname = ask_file(curbuf->b_fname, fnamebuf); ! 496: /* Don't allow bad characters when creating new files. */ ! 497: if (!OkayBadChars && strcmp(curbuf->b_fname, fnamebuf) != 0) { ! 498: static char *badchars = "!$^&*()~`{}\"'\\|<>? "; ! 499: register char *cp = fnamebuf; ! 500: register int c; ! 501: ! 502: while (c = *cp++) ! 503: if (c < ' ' || c == '\177' || index(badchars, c)) ! 504: complain("'%p': bad character in filename.", c); ! 505: } ! 506: ! 507: chk_mtime(fname, "write"); ! 508: filemunge(fname); ! 509: if (curbuf->b_type != B_IPROCESS) ! 510: curbuf->b_type = B_FILE; /* In case it wasn't before. */ ! 511: setfname(curbuf, fname); ! 512: file_write(fname, 0); ! 513: unmodify(); ! 514: } ! 515: ! 516: File * ! 517: open_file(fname, buf, how, ifbad, loudness) ! 518: register char *fname; ! 519: char *buf; ! 520: register int how; ! 521: { ! 522: register File *fp; ! 523: ! 524: io_chars = 0; ! 525: io_lines = 0; ! 526: tellall = loudness; ! 527: ! 528: fp = f_open(fname, how, buf, LBSIZE); ! 529: if (fp == NIL) { ! 530: message(IOerr((how == F_READ) ? "open" : "create", fname)); ! 531: if (ifbad == COMPLAIN) ! 532: complain((char *) 0); ! 533: } else { ! 534: int readonly = FALSE; ! 535: ! 536: if (access(fname, W_OK) == -1 && errno != ENOENT) ! 537: readonly = TRUE; ! 538: ! 539: if (loudness != QUIET) ! 540: f_mess("\"%s\"%s", pr_name(fname), ! 541: readonly ? " [Read only]" : NullStr); ! 542: } ! 543: return fp; ! 544: } ! 545: ! 546: /* Check to see if the file has been modified since it was ! 547: last written. If so, make sure they know what they're ! 548: doing. ! 549: ! 550: I hate to use another stat(), but to use confirm we gotta ! 551: do this before we open the file. */ ! 552: ! 553: chk_mtime(fname, how) ! 554: char *fname, ! 555: *how; ! 556: { ! 557: struct stat stbuf; ! 558: Buffer *b; ! 559: char *mesg = "Shall I go ahead and %s anyway? "; ! 560: ! 561: if ((curbuf->b_mtime != 0) && /* if we care ... */ ! 562: (b = file_exists(fname)) && /* we already have this file */ ! 563: (b == curbuf) && /* and it's the current buffer */ ! 564: (stat(fname, &stbuf) != -1) && /* and we can stat it */ ! 565: (stbuf.st_mtime != b->b_mtime)) { /* and there's trouble. */ ! 566: rbell(); ! 567: redisplay(); /* Ring that bell! */ ! 568: TOstart("Warning", TRUE); ! 569: Typeout("\"%s\" now saved on disk is not what you last", pr_name(fname)); ! 570: Typeout("visited or saved. Probably someone else is editing"); ! 571: Typeout("your file at the same time. Type \"y\" if I should"); ! 572: Typeout("%s anyway.", how); ! 573: f_mess(mesg, how); ! 574: TOstop(); ! 575: confirm(mesg, how); ! 576: } ! 577: } ! 578: ! 579: file_write(fname, app) ! 580: char *fname; ! 581: { ! 582: File *fp; ! 583: ! 584: #ifdef BACKUPFILES ! 585: if (!app && BkupOnWrite) ! 586: file_backup(fname); ! 587: #endif ! 588: ! 589: fp = open_file(fname, iobuff, app ? F_APPEND : F_WRITE, COMPLAIN, !QUIET); ! 590: ! 591: if (EndWNewline) { /* Make sure file ends with a newLine */ ! 592: Bufpos save; ! 593: ! 594: DOTsave(&save); ! 595: ToLast(); ! 596: if (length(curline)) /* Not a blank Line */ ! 597: DoTimes(LineInsert(), 1); /* Make it blank */ ! 598: SetDot(&save); ! 599: } ! 600: putreg(fp, curbuf->b_first, 0, curbuf->b_last, length(curbuf->b_last), NO); ! 601: set_ino(curbuf); ! 602: close_file(fp); ! 603: } ! 604: ! 605: ReadFile() ! 606: { ! 607: char *fname, ! 608: fnamebuf[FILESIZE]; ! 609: ! 610: fname = ask_file(curbuf->b_fname, fnamebuf); ! 611: chk_mtime(fname, "read"); ! 612: ! 613: if (IsModified(curbuf)) { ! 614: char *y_or_n; ! 615: int c; ! 616: ! 617: for (;;) { ! 618: rbell(); ! 619: y_or_n = ask(NullStr, "Shall I make your changes to \"%s\" permanent? ", curbuf->b_name); ! 620: c = Upper(*y_or_n); ! 621: if (c == 'Y' || c == 'N') ! 622: break; ! 623: } ! 624: if (c == 'Y') ! 625: SaveFile(); ! 626: } ! 627: ! 628: unmodify(); ! 629: initlist(curbuf); ! 630: setfname(curbuf, fname); ! 631: read_file(fname, 0); ! 632: } ! 633: ! 634: InsFile() ! 635: { ! 636: char *fname, ! 637: fnamebuf[FILESIZE]; ! 638: ! 639: fname = ask_file(curbuf->b_fname, fnamebuf); ! 640: read_file(fname, 1); ! 641: } ! 642: ! 643: #include "temp.h" ! 644: ! 645: int DOLsave = 0; /* Do Lsave flag. If lines aren't being save ! 646: when you think they should have been, this ! 647: flag is probably not being set, or is being ! 648: cleared before lsave() was called. */ ! 649: ! 650: int nleft, /* Number of good characters left in current block */ ! 651: tmpfd; ! 652: disk_line tline; /* Pointer to end of tmp file */ ! 653: ! 654: char *tfname; ! 655: ! 656: tmpinit() ! 657: { ! 658: tfname = mktemp(TMPFILE); ! 659: (void) close(creat(tfname, 0600)); ! 660: tmpfd = open(tfname, 2); ! 661: if (tmpfd == -1) { ! 662: printf("%s?\n", tfname); ! 663: finish(0); ! 664: } ! 665: block_init(); ! 666: tline = 2; ! 667: } ! 668: ! 669: tmpclose() ! 670: { ! 671: (void) close(tmpfd); ! 672: tmpfd = -1; ! 673: (void) unlink(tfname); ! 674: } ! 675: ! 676: /* Get a line at `tl' in the tmp file into `buf' which should be LBSIZE ! 677: long. */ ! 678: ! 679: int Jr_Len; /* Length of Just Read Line. */ ! 680: ! 681: char * ! 682: getline(tl, buf) ! 683: disk_line tl; ! 684: char *buf; ! 685: { ! 686: register char *bp, ! 687: *lp; ! 688: register int nl; ! 689: ! 690: lp = buf; ! 691: bp = getblock(tl, READ); ! 692: nl = nleft; ! 693: tl &= ~OFFMSK; ! 694: ! 695: while (*lp++ = *bp++) { ! 696: if (--nl == 0) { ! 697: /* += INCRMT moves tl to the next block in ! 698: the tmp file. */ ! 699: bp = getblock(tl += INCRMT, READ); ! 700: nl = nleft; ! 701: } ! 702: } ! 703: Jr_Len = (lp - buf) - 1; ! 704: ! 705: return buf; ! 706: } ! 707: ! 708: /* Put `buf' and return the disk address */ ! 709: ! 710: int nretries = 0; ! 711: ! 712: disk_line ! 713: putline(buf) ! 714: char *buf; ! 715: { ! 716: register char *bp, ! 717: *lp; ! 718: register int nl; ! 719: disk_line tl; ! 720: ! 721: lp = buf; ! 722: tl = tline; ! 723: bp = getblock(tl, WRITE); ! 724: nl = nleft; ! 725: tl &= ~OFFMSK; ! 726: while (*bp = *lp++) { ! 727: if (*bp++ == '\n') { ! 728: *--bp = 0; ! 729: break; ! 730: } ! 731: if (--nl == 0) { ! 732: tline = (tl += INCRMT); ! 733: bp = getblock(tl, WRITE); ! 734: lp = buf; /* start over ... */ ! 735: nretries++; ! 736: nl = nleft; ! 737: } ! 738: } ! 739: tl = tline; ! 740: tline += (((lp - buf) + BNDRY - 1) >> SHFT) & 077776; ! 741: ! 742: return tl; ! 743: } ! 744: ! 745: typedef struct block { ! 746: short b_dirty, ! 747: b_bno; ! 748: char b_buf[BUFSIZ]; ! 749: struct block ! 750: *b_LRUnext, ! 751: *b_LRUprev, ! 752: *b_HASHnext; ! 753: } Block; ! 754: ! 755: #define HASHSIZE 7 /* Primes work best (so I'm told) */ ! 756: #define B_HASH(bno) (bno % HASHSIZE) ! 757: ! 758: private Block b_cache[NBUF], ! 759: *bht[HASHSIZE] = {0}, /* Block hash table */ ! 760: *f_block = 0, ! 761: *l_block = 0; ! 762: private int max_bno = -1, ! 763: NBlocks; ! 764: ! 765: private ! 766: block_init() ! 767: { ! 768: register Block *bp, /* Block pointer */ ! 769: **hp; /* Hash pointer */ ! 770: register short bno; ! 771: ! 772: for (bp = b_cache, bno = NBUF; --bno >= 0; bp++) { ! 773: NBlocks++; ! 774: bp->b_dirty = 0; ! 775: bp->b_bno = bno; ! 776: if (l_block == 0) ! 777: l_block = bp; ! 778: bp->b_LRUprev = 0; ! 779: bp->b_LRUnext = f_block; ! 780: if (f_block != 0) ! 781: f_block->b_LRUprev = bp; ! 782: f_block = bp; ! 783: ! 784: bp->b_HASHnext = *(hp = &bht[B_HASH(bno)]); ! 785: *hp = bp; ! 786: } ! 787: } ! 788: ! 789: private Block * ! 790: lookup(bno) ! 791: register short bno; ! 792: { ! 793: register Block *bp; ! 794: ! 795: for (bp = bht[B_HASH(bno)]; bp != 0; bp = bp->b_HASHnext) ! 796: if (bp->b_bno == bno) ! 797: break; ! 798: return bp; ! 799: } ! 800: ! 801: private ! 802: LRUunlink(b) ! 803: register Block *b; ! 804: { ! 805: if (b->b_LRUprev == 0) ! 806: f_block = b->b_LRUnext; ! 807: else ! 808: b->b_LRUprev->b_LRUnext = b->b_LRUnext; ! 809: if (b->b_LRUnext == 0) ! 810: l_block = b->b_LRUprev; ! 811: else ! 812: b->b_LRUnext->b_LRUprev = b->b_LRUprev; ! 813: } ! 814: ! 815: private Block * ! 816: b_unlink(bp) ! 817: register Block *bp; ! 818: { ! 819: register Block *hp, ! 820: *prev = 0; ! 821: ! 822: LRUunlink(bp); ! 823: /* Now that we have the block, we remove it from its position ! 824: in the hash table, so we can THEN put it somewhere else with ! 825: it's new block assignment. */ ! 826: ! 827: for (hp = bht[B_HASH(bp->b_bno)]; hp != 0; prev = hp, hp = hp->b_HASHnext) ! 828: if (hp == bp) ! 829: break; ! 830: if (hp == 0) { ! 831: printf("\rBlock %d missing!", bp->b_bno); ! 832: finish(0); ! 833: } ! 834: if (prev) ! 835: prev->b_HASHnext = hp->b_HASHnext; ! 836: else ! 837: bht[B_HASH(bp->b_bno)] = hp->b_HASHnext; ! 838: ! 839: if (bp->b_dirty) { /* Do, now, the delayed write */ ! 840: blkio(bp, write); ! 841: bp->b_dirty = 0; ! 842: } ! 843: ! 844: return bp; ! 845: } ! 846: ! 847: /* Get a block which contains at least part of the line with the address ! 848: atl. Returns a pointer to the block and sets the global variable ! 849: nleft (number of good characters left in the buffer). */ ! 850: ! 851: char * ! 852: getblock(atl, iof) ! 853: disk_line atl; ! 854: { ! 855: register int bno, ! 856: off; ! 857: register Block *bp; ! 858: static Block *lastb = 0; ! 859: ! 860: bno = (atl >> OFFBTS) & BLKMSK; ! 861: off = (atl << SHFT) & LBTMSK; ! 862: if (bno >= NMBLKS) ! 863: error("Tmp file too large. Get help!"); ! 864: nleft = BUFSIZ - off; ! 865: if (lastb != 0 && lastb->b_bno == bno) ! 866: return lastb->b_buf + off; ! 867: ! 868: /* The requested block already lives in memory, so we move ! 869: it to the end of the LRU list (making it Most Recently Used) ! 870: and then return a pointer to it. */ ! 871: ! 872: if (bp = lookup(bno)) { ! 873: if (bp != l_block) { ! 874: LRUunlink(bp); ! 875: if (l_block == 0) ! 876: f_block = l_block = bp; ! 877: else ! 878: l_block->b_LRUnext = bp; ! 879: bp->b_LRUprev = l_block; ! 880: l_block = bp; ! 881: bp->b_LRUnext = 0; ! 882: } ! 883: if (bp->b_bno > max_bno) ! 884: max_bno = bp->b_bno; ! 885: bp->b_dirty |= iof; ! 886: lastb = bp; ! 887: return bp->b_buf + off; ! 888: } ! 889: ! 890: /* The block we want doesn't reside in memory so we take the ! 891: least recently used clean block (if there is one) and use ! 892: it. */ ! 893: ! 894: bp = f_block; ! 895: if (bp->b_dirty) /* The best block is dirty ... */ ! 896: SyncTmp(); ! 897: ! 898: bp = b_unlink(bp); ! 899: if (l_block == 0) ! 900: l_block = f_block = bp; ! 901: else ! 902: l_block->b_LRUnext = bp; /* Place it at the end ... */ ! 903: bp->b_LRUprev = l_block; ! 904: l_block = bp; ! 905: bp->b_LRUnext = 0; /* so it's Most Recently Used */ ! 906: ! 907: bp->b_dirty = iof; ! 908: bp->b_bno = bno; ! 909: bp->b_HASHnext = bht[B_HASH(bno)]; ! 910: bht[B_HASH(bno)] = bp; ! 911: ! 912: /* Get the current contents of the block UNLESS this is a new ! 913: block that's never been looked at before, i.e., it's past ! 914: the end of the tmp file. */ ! 915: ! 916: if (bp->b_bno <= max_bno) ! 917: blkio(bp, read); ! 918: else ! 919: max_bno = bno; ! 920: ! 921: lastb = bp; ! 922: return bp->b_buf + off; ! 923: } ! 924: ! 925: char * ! 926: lbptr(line) ! 927: Line *line; ! 928: { ! 929: return getblock(line->l_dline, READ); ! 930: } ! 931: ! 932: private ! 933: blkio(b, iofcn) ! 934: register Block *b; ! 935: register int (*iofcn)(); ! 936: { ! 937: (void) lseek(tmpfd, (long) ((unsigned) b->b_bno) * BUFSIZ, 0); ! 938: if ((*iofcn)(tmpfd, b->b_buf, BUFSIZ) != BUFSIZ) ! 939: error("Tmp file %s error.", (iofcn == read) ? "read" : "write"); ! 940: } ! 941: ! 942: SyncTmp() ! 943: { ! 944: register Block *b; ! 945: ! 946: for (b = f_block; b != 0; b = b->b_LRUnext) ! 947: if (b->b_dirty) { ! 948: blkio(b, write); ! 949: b->b_dirty = 0; ! 950: } ! 951: } ! 952: ! 953: /* save the current contents of linebuf, if it has changed */ ! 954: ! 955: lsave() ! 956: { ! 957: if (curbuf == 0 || !DOLsave) /* Nothing modified recently */ ! 958: return; ! 959: ! 960: if (strcmp(lbptr(curline), linebuf) != 0) ! 961: SavLine(curline, linebuf); /* Put linebuf on the disk. */ ! 962: DOLsave = 0; ! 963: } ! 964: ! 965: #ifdef BACKUPFILES ! 966: file_backup(fname) ! 967: char *fname; ! 968: { ! 969: char *s; ! 970: register int i; ! 971: int fd1, ! 972: fd2; ! 973: char tmp1[BUFSIZ], ! 974: tmp2[BUFSIZ]; ! 975: ! 976: strcpy(tmp1, fname); ! 977: ! 978: if ((s = rindex(tmp1, '/')) == NULL) ! 979: sprintf(tmp2, "#%s", fname); ! 980: else { ! 981: *s++ = NULL; ! 982: sprintf(tmp2, "%s/#%s", tmp1, s); ! 983: } ! 984: ! 985: if ((fd1 = open(fname, 0)) < 0) ! 986: return; ! 987: ! 988: if ((fd2 = creat(tmp2, CreatMode)) < 0) { ! 989: (void) close(fd1); ! 990: return; ! 991: } ! 992: ! 993: while ((i = read(fd1, tmp1, sizeof(tmp1))) > 0) ! 994: write(fd2, tmp1, i); ! 995: ! 996: #ifdef BSD4_2 ! 997: (void) fsync(fd2); ! 998: #endif ! 999: (void) close(fd2); ! 1000: (void) close(fd1); ! 1001: } ! 1002: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.