![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to buf.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / new / jove|
Return to buf.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / jove |
1.1 ! root 1: /*************************************************************************** ! 2: * This program is Copyright (C) 1986, 1987, 1988 by Jonathan Payne. JOVE * ! 3: * is provided to you without charge, and with no warranty. You may give * ! 4: * away copies of JOVE, including sources, provided that this notice is * ! 5: * included in all the files. * ! 6: ***************************************************************************/ ! 7: ! 8: /* Contains commands that deal with creating, selecting, killing and ! 9: listing buffers, and buffer modes, and find-file, etc. */ ! 10: ! 11: #include "jove.h" ! 12: ! 13: #ifdef MAC ! 14: # include "mac.h" ! 15: #else ! 16: # include <sys/stat.h> ! 17: #endif ! 18: ! 19: #ifdef MAC ! 20: # undef private ! 21: # define private ! 22: #endif ! 23: ! 24: #ifdef LINT_ARGS ! 25: private Buffer ! 26: * buf_alloc(void), ! 27: * mak_buf(void); ! 28: ! 29: private char * line_cnt(Buffer *, char *); ! 30: ! 31: private void ! 32: BufNSelect(int), ! 33: defb_wind(Buffer *), ! 34: kill_buf(Buffer *), ! 35: mkbuflist(char **); ! 36: #else ! 37: private Buffer ! 38: * buf_alloc(), ! 39: * mak_buf(); ! 40: ! 41: private char * line_cnt(); ! 42: ! 43: private void ! 44: BufNSelect(), ! 45: defb_wind(), ! 46: kill_buf(), ! 47: mkbuflist(); ! 48: #endif /* LINT_ARGS */ ! 49: ! 50: #ifdef MAC ! 51: # undef private ! 52: # define private static ! 53: #endif ! 54: ! 55: char *Mainbuf = "Main", ! 56: *NoName = "Sans un nom!"; ! 57: ! 58: Buffer *world = 0, /* First in the list */ ! 59: *curbuf = 0, ! 60: *lastbuf = 0; /* Last buffer we were in so we have a default ! 61: buffer during a select buffer. */ ! 62: ! 63: /* Toggle BIT in the current buffer's minor mode flags. If argument is ! 64: supplied, a positive one always turns on the mode and zero argument ! 65: always turns it off. */ ! 66: ! 67: void ! 68: TogMinor(bit) ! 69: { ! 70: if (is_an_arg()) { ! 71: if (arg_value() == 0) ! 72: curbuf->b_minor &= ~bit; ! 73: else ! 74: curbuf->b_minor |= bit; ! 75: } else ! 76: curbuf->b_minor ^= bit; ! 77: UpdModLine = YES; ! 78: } ! 79: ! 80: /* Creates a new buffer, links it at the end of the buffer chain, and ! 81: returns it. */ ! 82: ! 83: static Buffer * ! 84: buf_alloc() ! 85: { ! 86: register Buffer *b, ! 87: *lastbp; ! 88: ! 89: lastbp = 0; ! 90: for (b = world; b != 0; lastbp = b, b = b->b_next) ! 91: ; ! 92: ! 93: b = (Buffer *) emalloc(sizeof (Buffer)); ! 94: if (lastbp) ! 95: lastbp->b_next = b; ! 96: else ! 97: world = b; ! 98: b->b_first = 0; ! 99: b->b_next = 0; ! 100: #ifdef MAC ! 101: b->Type = BUFFER; /* kludge, but simplifies menu handlers */ ! 102: b->Name = 0; ! 103: #endif ! 104: return b; ! 105: } ! 106: ! 107: /* Makes a buffer and initializes it. Obsolete. Used to take two ! 108: arguments, a buffer name and a file name. */ ! 109: ! 110: static Buffer * ! 111: mak_buf() ! 112: { ! 113: register Buffer *newb; ! 114: register int i; ! 115: ! 116: newb = buf_alloc(); ! 117: newb->b_fname = 0; ! 118: newb->b_name = NoName; ! 119: set_ino(newb); ! 120: newb->b_marks = 0; ! 121: newb->b_themark = 0; /* Index into markring */ ! 122: /* No marks yet */ ! 123: for (i = 0; i < NMARKS; i++) ! 124: newb->b_markring[i] = 0; ! 125: newb->b_modified = 0; ! 126: newb->b_type = B_FILE; /* File until proven SCRATCH */ ! 127: newb->b_ntbf = 0; ! 128: newb->b_minor = 0; ! 129: newb->b_major = TEXT; ! 130: newb->b_first = 0; ! 131: newb->b_keybinds = 0; ! 132: #ifdef IPROCS ! 133: newb->b_process = 0; ! 134: #endif ! 135: initlist(newb); ! 136: #ifdef MAC ! 137: Bufchange = 1; ! 138: #endif ! 139: return newb; ! 140: } ! 141: ! 142: void ! 143: ReNamBuf() ! 144: { ! 145: register char *new = 0, ! 146: *prompt = ProcFmt, ! 147: *second = "%s already exists; new name? "; ! 148: ! 149: for (;;) { ! 150: new = ask((char *) 0, prompt, new); ! 151: if (!buf_exists(new)) ! 152: break; ! 153: prompt = second; ! 154: } ! 155: setbname(curbuf, new); ! 156: } ! 157: ! 158: void ! 159: FindFile() ! 160: { ! 161: register char *name; ! 162: char fnamebuf[FILESIZE]; ! 163: ! 164: name = ask_file((char *) 0, curbuf->b_fname, fnamebuf); ! 165: SetABuf(curbuf); ! 166: SetBuf(do_find(curwind, name, 0)); ! 167: } ! 168: ! 169: private void ! 170: mkbuflist(bnamp) ! 171: register char **bnamp; ! 172: { ! 173: register Buffer *b; ! 174: ! 175: for (b = world; b != 0; b = b->b_next) ! 176: if (b->b_name != 0) ! 177: *bnamp++ = b->b_name; ! 178: *bnamp = 0; ! 179: } ! 180: ! 181: char * ! 182: ask_buf(def) ! 183: Buffer *def; ! 184: { ! 185: char *bnames[100]; ! 186: register char *bname; ! 187: register int offset; ! 188: char prompt[100]; ! 189: ! 190: if (def != 0 && def->b_name != 0) ! 191: sprintf(prompt, ": %f (default %s) ", def->b_name); ! 192: else ! 193: sprintf(prompt, ProcFmt); ! 194: mkbuflist(bnames); ! 195: offset = complete(bnames, prompt, RET_STATE); ! 196: if (offset == EOF) ! 197: complain((char *) 0); ! 198: if (offset == ORIGINAL || offset == AMBIGUOUS) ! 199: bname = Minibuf; ! 200: else if (offset == NULLSTRING) { ! 201: if (def) ! 202: bname = def->b_name; ! 203: else ! 204: complain((char *) 0); ! 205: } else if (offset < 0) ! 206: complain((char *) 0); ! 207: else ! 208: bname = bnames[offset]; ! 209: ! 210: return bname; ! 211: } ! 212: ! 213: void ! 214: BufSelect() ! 215: { ! 216: register char *bname; ! 217: ! 218: bname = ask_buf(lastbuf); ! 219: SetABuf(curbuf); ! 220: SetBuf(do_select(curwind, bname)); ! 221: } ! 222: ! 223: #ifdef MSDOS ! 224: ! 225: private void ! 226: BufNSelect(n) ! 227: { ! 228: char *bnames[100]; ! 229: char *bname; ! 230: int i; ! 231: ! 232: mkbuflist(bnames); ! 233: for (i=0; i<n; i++) ! 234: if (bnames[i] == 0) ! 235: complain("[No such buffer]"); ! 236: bname = bnames[n-1]; ! 237: SetABuf(curbuf); ! 238: SetBuf(do_select(curwind, bname)); ! 239: } ! 240: ! 241: void Buf1Select() { BufNSelect(1); } ! 242: void Buf2Select() { BufNSelect(2); } ! 243: void Buf3Select() { BufNSelect(3); } ! 244: void Buf4Select() { BufNSelect(4); } ! 245: void Buf5Select() { BufNSelect(5); } ! 246: void Buf6Select() { BufNSelect(6); } ! 247: void Buf7Select() { BufNSelect(7); } ! 248: void Buf8Select() { BufNSelect(8); } ! 249: void Buf9Select() { BufNSelect(9); } ! 250: void Buf10Select() { BufNSelect(10); } ! 251: ! 252: #endif /* MSDOS */ ! 253: ! 254: private void ! 255: defb_wind(b) ! 256: register Buffer *b; ! 257: { ! 258: register Window *w = fwind; ! 259: char *alt; ! 260: ! 261: if (lastbuf == b || lastbuf == 0) { ! 262: lastbuf = 0; ! 263: alt = (b->b_next != 0) ? b->b_next->b_name : Mainbuf; ! 264: } else ! 265: alt = lastbuf->b_name; ! 266: ! 267: do { ! 268: if (w->w_bufp == b) { ! 269: if (one_windp() || alt != Mainbuf) ! 270: (void) do_select(w, alt); ! 271: else { ! 272: Window *save = w->w_next; ! 273: del_wind(w); ! 274: w = save->w_prev; ! 275: } ! 276: } ! 277: w = w->w_next; ! 278: } while (w != fwind || w->w_bufp == b); ! 279: } ! 280: ! 281: Buffer * ! 282: getNMbuf() ! 283: { ! 284: register Buffer *delbuf; ! 285: register char *bname; ! 286: ! 287: bname = ask_buf(curbuf); ! 288: if ((delbuf = buf_exists(bname)) == 0) ! 289: complain("[No such buffer]"); ! 290: if (delbuf->b_modified) ! 291: confirm("%s modified, are you sure? ", bname); ! 292: return delbuf; ! 293: } ! 294: ! 295: void ! 296: BufErase() ! 297: { ! 298: register Buffer *delbuf; ! 299: ! 300: if (delbuf = getNMbuf()) { ! 301: initlist(delbuf); ! 302: delbuf->b_modified = 0; ! 303: } ! 304: } ! 305: ! 306: private void ! 307: kill_buf(delbuf) ! 308: register Buffer *delbuf; ! 309: { ! 310: register Buffer *b, ! 311: *lastb = 0; ! 312: #ifndef MAC ! 313: extern Buffer *perr_buf; ! 314: #endif ! 315: ! 316: #ifdef IPROCS ! 317: pbuftiedp(delbuf); /* check for lingering processes */ ! 318: #endif ! 319: for (b = world; b != 0; lastb = b, b = b->b_next) ! 320: if (b == delbuf) ! 321: break; ! 322: if (lastb) ! 323: lastb->b_next = delbuf->b_next; ! 324: else ! 325: world = delbuf->b_next; ! 326: ! 327: #define okay_free(ptr) if (ptr) free(ptr) ! 328: ! 329: lfreelist(delbuf->b_first); ! 330: okay_free(delbuf->b_name); ! 331: okay_free(delbuf->b_fname); ! 332: flush_marks(delbuf); ! 333: free((char *) delbuf); ! 334: ! 335: if (delbuf == lastbuf) ! 336: SetABuf(curbuf); ! 337: #ifndef MAC ! 338: if (perr_buf == delbuf) { ! 339: ErrFree(); ! 340: perr_buf = 0; ! 341: } ! 342: #endif ! 343: defb_wind(delbuf); ! 344: if (curbuf == delbuf) ! 345: SetBuf(curwind->w_bufp); ! 346: #ifdef MAC ! 347: Bufchange = 1; ! 348: #endif ! 349: } ! 350: ! 351: /* offer to kill some buffers */ ! 352: ! 353: void ! 354: KillSome() ! 355: { ! 356: register Buffer *b, ! 357: *next; ! 358: Buffer *oldb; ! 359: register char *y_or_n; ! 360: ! 361: for (b = world; b != 0; b = next) { ! 362: next = b->b_next; ! 363: if (yes_or_no_p("Kill %s? ", b->b_name) == NO) ! 364: continue; ! 365: if (IsModified(b)) { ! 366: y_or_n = ask("No", "%s modified; should I save it? ", b->b_name); ! 367: if (CharUpcase(*y_or_n) == 'Y') { ! 368: oldb = curbuf; ! 369: SetBuf(b); ! 370: SaveFile(); ! 371: SetBuf(oldb); ! 372: } ! 373: } ! 374: kill_buf(b); ! 375: } ! 376: } ! 377: ! 378: void ! 379: BufKill() ! 380: { ! 381: Buffer *b; ! 382: ! 383: if ((b = getNMbuf()) == 0) ! 384: return; ! 385: kill_buf(b); ! 386: } ! 387: ! 388: private char * ! 389: line_cnt(b, buf) ! 390: register Buffer *b; ! 391: char *buf; ! 392: { ! 393: register int nlines = 0; ! 394: register Line *lp; ! 395: ! 396: for (lp = b->b_first; lp != 0; lp = lp->l_next, nlines++) ! 397: ; ! 398: sprintf(buf, "%d", nlines); ! 399: return buf; ! 400: } ! 401: ! 402: private char *TypeNames[] = { ! 403: 0, ! 404: "Scratch", ! 405: "File", ! 406: "Process", ! 407: }; ! 408: ! 409: void ! 410: BufList() ! 411: { ! 412: register char *format = "%-2s %-5s %-11s %-1s %-*s %-s"; ! 413: register Buffer *b; ! 414: int bcount = 1, /* To give each buffer a number */ ! 415: buf_width = 11; ! 416: char nbuf[10]; ! 417: ! 418: for (b = world; b != 0; b = b->b_next) ! 419: buf_width = max(buf_width, strlen(b->b_name)); ! 420: ! 421: TOstart("Buffer list", TRUE); /* true means auto-newline */ ! 422: ! 423: Typeout("(* means buffer needs saving)"); ! 424: Typeout("(+ means file hasn't been read yet)"); ! 425: Typeout(NullStr); ! 426: Typeout(format, "NO", "Lines", "Type", NullStr, buf_width, "Name", "File"); ! 427: Typeout(format, "--", "-----", "----", NullStr, buf_width, "----", "----"); ! 428: for (b = world; b != 0; b = b->b_next) { ! 429: Typeout(format, itoa(bcount++), ! 430: line_cnt(b, nbuf), ! 431: TypeNames[b->b_type], ! 432: IsModified(b) ? "*" : ! 433: b->b_ntbf ? "+" : NullStr, ! 434: buf_width, ! 435: /* For the * (variable length field) */ ! 436: b->b_name, ! 437: filename(b)); ! 438: ! 439: if (TOabort) ! 440: break; ! 441: } ! 442: TOstop(); ! 443: } ! 444: ! 445: void ! 446: bufname(b) ! 447: register Buffer *b; ! 448: { ! 449: char tmp[100], ! 450: *cp; ! 451: int try = 1; ! 452: ! 453: if (b->b_fname == 0) ! 454: complain("[No file name]"); ! 455: cp = basename(b->b_fname); ! 456: strcpy(tmp, cp); ! 457: while (buf_exists(tmp)) { ! 458: sprintf(tmp, "%s.%d", cp, try); ! 459: try += 1; ! 460: } ! 461: setbname(b, tmp); ! 462: } ! 463: ! 464: void ! 465: initlist(b) ! 466: register Buffer *b; ! 467: { ! 468: lfreelist(b->b_first); ! 469: b->b_first = b->b_dot = b->b_last = 0; ! 470: (void) listput(b, b->b_first); ! 471: ! 472: SavLine(b->b_dot, NullStr); ! 473: b->b_char = 0; ! 474: AllMarkSet(b, b->b_dot, 0); ! 475: if (b == curbuf) ! 476: getDOT(); ! 477: } ! 478: ! 479: /* Returns pointer to buffer with name NAME, or if NAME is a string of digits ! 480: returns the buffer whose number equals those digits. Otherwise, returns ! 481: 0. */ ! 482: ! 483: Buffer * ! 484: buf_exists(name) ! 485: register char *name; ! 486: { ! 487: register Buffer *bp; ! 488: int n; ! 489: ! 490: if (name == 0) ! 491: return 0; ! 492: ! 493: for (bp = world; bp != 0; bp = bp->b_next) ! 494: if (strcmp(bp->b_name, name) == 0) ! 495: return bp; ! 496: ! 497: /* Doesn't match any names. Try for a buffer number... */ ! 498: ! 499: if (chr_to_int(name, 10, YES, &n) != INT_BAD) { ! 500: for (bp = world; n > 1; bp = bp->b_next) { ! 501: if (bp == 0) ! 502: break; ! 503: n -= 1; ! 504: } ! 505: return bp; ! 506: } ! 507: ! 508: return 0; ! 509: } ! 510: ! 511: /* Returns buffer pointer with a file name NAME, if one exists. Stat's the ! 512: file and compares inodes, in case NAME is a link, as well as the actual ! 513: characters that make up the file name. */ ! 514: ! 515: Buffer * ! 516: file_exists(name) ! 517: register char *name; ! 518: { ! 519: struct stat stbuf; ! 520: register struct stat *s = &stbuf; ! 521: register Buffer *b = 0; ! 522: char fnamebuf[FILESIZE]; ! 523: ! 524: #ifdef MSDOS ! 525: strlwr(name); ! 526: #endif /* MSDOS */ ! 527: if (name) { ! 528: PathParse(name, fnamebuf); ! 529: if (stat(fnamebuf, s) == -1) ! 530: s->st_ino = 0; ! 531: for (b = world; b != 0; b = b->b_next) { ! 532: if ( ! 533: #ifndef MSDOS ! 534: (b->b_ino != 0 && b->b_ino == s->st_ino && ! 535: b->b_dev != 0 && b->b_dev == s->st_dev) || ! 536: #endif /* MSDOS */ ! 537: (strcmp(b->b_fname, fnamebuf) == 0)) ! 538: break; ! 539: } ! 540: } ! 541: return b; ! 542: } ! 543: ! 544: char * ! 545: ralloc(obj, size) ! 546: register char *obj; ! 547: { ! 548: register char *new; ! 549: ! 550: if (obj) ! 551: new = realloc(obj, (unsigned) size); ! 552: if (new == 0 || !obj) ! 553: new = emalloc(size); ! 554: return new; ! 555: } ! 556: ! 557: void ! 558: setbname(b, name) ! 559: register Buffer *b; ! 560: register char *name; ! 561: { ! 562: UpdModLine = YES; /* Kludge ... but speeds things up considerably */ ! 563: if (name) { ! 564: if (b->b_name == NoName) ! 565: b->b_name = 0; ! 566: b->b_name = ralloc(b->b_name, strlen(name) + 1); ! 567: strcpy(b->b_name, name); ! 568: } else ! 569: b->b_name = 0; ! 570: #ifdef MAC ! 571: Bufchange = 1; ! 572: #endif ! 573: } ! 574: ! 575: void ! 576: setfname(b, name) ! 577: register Buffer *b; ! 578: register char *name; ! 579: { ! 580: char wholename[FILESIZE], ! 581: oldname[FILESIZE], ! 582: *oldptr = oldname; ! 583: Buffer *save = curbuf; ! 584: ! 585: SetBuf(b); ! 586: UpdModLine = YES; /* Kludge ... but speeds things up considerably */ ! 587: if (b->b_fname == 0) ! 588: oldptr = 0; ! 589: else ! 590: strcpy(oldname, b->b_fname); ! 591: if (name) { ! 592: #ifdef MSDOS ! 593: strlwr(name); ! 594: #endif /* MSDOS */ ! 595: PathParse(name, wholename); ! 596: curbuf->b_fname = ralloc(curbuf->b_fname, strlen(wholename) + 1); ! 597: strcpy(curbuf->b_fname, wholename); ! 598: } else ! 599: b->b_fname = 0; ! 600: DoAutoExec(curbuf->b_fname, oldptr); ! 601: curbuf->b_mtime = curbuf->b_dev = curbuf->b_ino = 0; /* until they're known. */ ! 602: SetBuf(save); ! 603: #ifdef MAC ! 604: Bufchange = 1; ! 605: #endif ! 606: } ! 607: ! 608: void ! 609: set_ino(b) ! 610: register Buffer *b; ! 611: { ! 612: struct stat stbuf; ! 613: ! 614: if (b->b_fname == 0 || stat(pr_name(b->b_fname, NO), &stbuf) == -1) { ! 615: b->b_dev = 0; ! 616: b->b_ino = 0; ! 617: b->b_mtime = 0; ! 618: } else { ! 619: b->b_dev = stbuf.st_dev; ! 620: b->b_ino = stbuf.st_ino; ! 621: b->b_mtime = stbuf.st_mtime; ! 622: } ! 623: } ! 624: ! 625: /* Find the file `fname' into buf and put in in window `w' */ ! 626: ! 627: Buffer * ! 628: do_find(w, fname, force) ! 629: register Window *w; ! 630: register char *fname; ! 631: { ! 632: register Buffer *b; ! 633: ! 634: b = file_exists(fname); ! 635: if (b == 0) { ! 636: b = mak_buf(); ! 637: setfname(b, fname); ! 638: bufname(b); ! 639: set_ino(b); ! 640: b->b_ntbf = 1; ! 641: } ! 642: if (force) { ! 643: Buffer *oldb = curbuf; ! 644: ! 645: SetBuf(b); /* this'll read the file */ ! 646: SetBuf(oldb); ! 647: } ! 648: if (w) ! 649: tiewind(w, b); ! 650: return b; ! 651: } ! 652: ! 653: /* set alternate buffer */ ! 654: ! 655: void ! 656: SetABuf(b) ! 657: Buffer *b; ! 658: { ! 659: if (b != 0) ! 660: lastbuf = b; ! 661: } ! 662: ! 663: ! 664: /* check to see if BP is a valid buffer pointer */ ! 665: int ! 666: valid_bp(bp) ! 667: register Buffer *bp; ! 668: { ! 669: register Buffer *b; ! 670: ! 671: for (b = world; b != 0; b = b->b_next) ! 672: if (b == bp) ! 673: break; ! 674: return b != 0; ! 675: } ! 676: ! 677: void ! 678: SetBuf(newbuf) ! 679: register Buffer *newbuf; ! 680: { ! 681: register Buffer *oldb = curbuf, ! 682: *b; ! 683: ! 684: if (newbuf == curbuf || newbuf == 0) ! 685: return; ! 686: ! 687: if (!valid_bp(newbuf)) ! 688: complain("Internal error: (0x%x) is not a valid buffer pointer!", newbuf); ! 689: lsave(); ! 690: curbuf = newbuf; ! 691: curline = newbuf->b_dot; ! 692: curchar = newbuf->b_char; ! 693: getDOT(); ! 694: /* do the read now ... */ ! 695: if (curbuf->b_ntbf) ! 696: read_file(curbuf->b_fname, 0); ! 697: #ifdef MAC ! 698: Modechange = 1; ! 699: #endif ! 700: ! 701: #ifdef IPROCS ! 702: if (oldb != 0 && ((oldb->b_process == 0) != (curbuf->b_process == 0))) { ! 703: if (curbuf->b_process) ! 704: PushPBs(); /* Push process bindings */ ! 705: else if (oldb->b_process) ! 706: PopPBs(); ! 707: } ! 708: #endif ! 709: } ! 710: ! 711: Buffer * ! 712: do_select(w, name) ! 713: register Window *w; ! 714: register char *name; ! 715: { ! 716: register Buffer *new; ! 717: ! 718: if ((new = buf_exists(name)) == 0) { ! 719: new = mak_buf(); ! 720: setfname(new, (char *) 0); ! 721: setbname(new, name); ! 722: } ! 723: if (w) ! 724: tiewind(w, new); ! 725: return new; ! 726: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.