Annotation of src/usr.bin/vim/buffer.c, Revision 1.1
1.1 ! downsj 1: /* $OpenBSD$ */
! 2: /* vi:set ts=4 sw=4:
! 3: *
! 4: * VIM - Vi IMproved by Bram Moolenaar
! 5: *
! 6: * Do ":help uganda" in Vim to read copying and usage conditions.
! 7: * Do ":help credits" in Vim to see a list of people who contributed.
! 8: */
! 9:
! 10: /*
! 11: * buffer.c: functions for dealing with the buffer structure
! 12: */
! 13:
! 14: /*
! 15: * The buffer list is a double linked list of all buffers.
! 16: * Each buffer can be in one of these states:
! 17: * never loaded: b_neverloaded == TRUE, only the file name is valid
! 18: * not loaded: b_ml.ml_mfp == NULL, no memfile allocated
! 19: * hidden: b_nwindows == 0, loaded but not displayed in a window
! 20: * normal: loaded and displayed in a window
! 21: *
! 22: * Instead of storing file names all over the place, each file name is
! 23: * stored in the buffer list. It can be referenced by a number.
! 24: *
! 25: * The current implementation remembers all file names ever used.
! 26: */
! 27:
! 28: #include "vim.h"
! 29: #include "globals.h"
! 30: #include "proto.h"
! 31: #include "option.h"
! 32:
! 33: static void enter_buffer __ARGS((BUF *));
! 34: static void free_buf_options __ARGS((BUF *));
! 35: static char_u *buflist_match __ARGS((regexp *prog, BUF *buf));
! 36: static void buflist_setlnum __ARGS((BUF *, linenr_t));
! 37: static linenr_t buflist_findlnum __ARGS((BUF *));
! 38: static void append_arg_number __ARGS((char_u *, int));
! 39:
! 40: /*
! 41: * Open current buffer, that is: open the memfile and read the file into memory
! 42: * return FAIL for failure, OK otherwise
! 43: */
! 44: int
! 45: open_buffer()
! 46: {
! 47: int retval = OK;
! 48:
! 49: /*
! 50: * The 'readonly' flag is only set when b_neverloaded is being reset.
! 51: * When re-entering the same buffer, it should not change, because the
! 52: * user may have reset the flag by hand.
! 53: */
! 54: if (readonlymode && curbuf->b_filename != NULL && curbuf->b_neverloaded)
! 55: curbuf->b_p_ro = TRUE;
! 56:
! 57: if (ml_open() == FAIL)
! 58: {
! 59: /*
! 60: * There MUST be a memfile, otherwise we can't do anything
! 61: * If we can't create one for the current buffer, take another buffer
! 62: */
! 63: close_buffer(NULL, curbuf, FALSE, FALSE);
! 64: for (curbuf = firstbuf; curbuf != NULL; curbuf = curbuf->b_next)
! 65: if (curbuf->b_ml.ml_mfp != NULL)
! 66: break;
! 67: /*
! 68: * if there is no memfile at all, exit
! 69: * This is OK, since there are no changes to loose.
! 70: */
! 71: if (curbuf == NULL)
! 72: {
! 73: EMSG("Cannot allocate buffer, exiting...");
! 74: getout(2);
! 75: }
! 76: EMSG("Cannot allocate buffer, using other one...");
! 77: enter_buffer(curbuf);
! 78: return FAIL;
! 79: }
! 80: if (curbuf->b_filename != NULL)
! 81: retval = readfile(curbuf->b_filename, curbuf->b_sfilename,
! 82: (linenr_t)0, TRUE, (linenr_t)0, MAXLNUM, FALSE);
! 83: else
! 84: {
! 85: MSG("Empty Buffer");
! 86: msg_col = 0;
! 87: msg_didout = FALSE; /* overwrite this message whenever you like */
! 88: }
! 89:
! 90: /* if first time loading this buffer, init chartab */
! 91: if (curbuf->b_neverloaded)
! 92: init_chartab();
! 93:
! 94: /*
! 95: * Reset the Changed flag first, autocmds may change the buffer.
! 96: * Apply the automatic commands, before processing the modelines.
! 97: * So the modelines have priority over auto commands.
! 98: */
! 99: if (retval != FAIL)
! 100: UNCHANGED(curbuf);
! 101:
! 102: #ifdef AUTOCMD
! 103: apply_autocmds(EVENT_BUFENTER, NULL, NULL);
! 104: #endif
! 105:
! 106: if (retval != FAIL)
! 107: {
! 108: do_modelines();
! 109: curbuf->b_neverloaded = FALSE;
! 110: }
! 111:
! 112: return retval;
! 113: }
! 114:
! 115: /*
! 116: * Close the link to a buffer. If "free_buf" is TRUE free the buffer if it
! 117: * becomes unreferenced. The caller should get a new buffer very soon!
! 118: * if 'del_buf' is TRUE, remove the buffer from the buffer list.
! 119: */
! 120: void
! 121: close_buffer(win, buf, free_buf, del_buf)
! 122: WIN *win; /* if not NULL, set b_last_cursor */
! 123: BUF *buf;
! 124: int free_buf;
! 125: int del_buf;
! 126: {
! 127: if (buf->b_nwindows > 0)
! 128: --buf->b_nwindows;
! 129: if (buf->b_nwindows == 0 && win != NULL)
! 130: set_last_cursor(win); /* may set b_last_cursor */
! 131: if (buf->b_nwindows > 0 || !free_buf)
! 132: {
! 133: if (buf == curbuf)
! 134: u_sync(); /* sync undo before going to another buffer */
! 135: return;
! 136: }
! 137:
! 138: buf_freeall(buf); /* free all things allocated for this buffer */
! 139: /*
! 140: * If there is no file name, remove the buffer from the list
! 141: */
! 142: if (buf->b_filename == NULL || del_buf)
! 143: {
! 144: vim_free(buf->b_filename);
! 145: vim_free(buf->b_sfilename);
! 146: if (buf->b_prev == NULL)
! 147: firstbuf = buf->b_next;
! 148: else
! 149: buf->b_prev->b_next = buf->b_next;
! 150: if (buf->b_next == NULL)
! 151: lastbuf = buf->b_prev;
! 152: else
! 153: buf->b_next->b_prev = buf->b_prev;
! 154: free_buf_options(buf);
! 155: }
! 156: else
! 157: buf_clear(buf);
! 158: }
! 159:
! 160: /*
! 161: * buf_clear() - make buffer empty
! 162: */
! 163: void
! 164: buf_clear(buf)
! 165: BUF *buf;
! 166: {
! 167: buf->b_ml.ml_line_count = 1;
! 168: buf->b_changed = FALSE;
! 169: #ifndef SHORT_FNAME
! 170: buf->b_shortname = FALSE;
! 171: #endif
! 172: buf->b_p_eol = TRUE;
! 173: buf->b_ml.ml_mfp = NULL;
! 174: buf->b_ml.ml_flags = ML_EMPTY; /* empty buffer */
! 175: }
! 176:
! 177: /*
! 178: * buf_freeall() - free all things allocated for the buffer
! 179: */
! 180: void
! 181: buf_freeall(buf)
! 182: BUF *buf;
! 183: {
! 184: u_blockfree(buf); /* free the memory allocated for undo */
! 185: ml_close(buf, TRUE); /* close and delete the memline/memfile */
! 186: buf->b_ml.ml_line_count = 0; /* no lines in buffer */
! 187: u_clearall(buf); /* reset all undo information */
! 188: }
! 189:
! 190: /*
! 191: * do_bufdel() - delete or unload buffer(s)
! 192: *
! 193: * addr_count == 0: ":bdel" - delete current buffer
! 194: * addr_count == 1: ":N bdel" or ":bdel N [N ..] - first delete
! 195: * buffer "end_bnr", then any other arguments.
! 196: * addr_count == 2: ":N,N bdel" - delete buffers in range
! 197: *
! 198: * command can be DOBUF_UNLOAD (":bunload") or DOBUF_DEL (":bdel")
! 199: *
! 200: * Returns error message or NULL
! 201: */
! 202: char_u *
! 203: do_bufdel(command, arg, addr_count, start_bnr, end_bnr, forceit)
! 204: int command;
! 205: char_u *arg; /* pointer to extra arguments */
! 206: int addr_count;
! 207: int start_bnr; /* first buffer number in a range */
! 208: int end_bnr; /* buffer number or last buffer number in a range */
! 209: int forceit;
! 210: {
! 211: int do_current = 0; /* delete current buffer? */
! 212: int deleted = 0; /* number of buffers deleted */
! 213: char_u *errormsg = NULL; /* return value */
! 214: int bnr; /* buffer number */
! 215: char_u *p;
! 216:
! 217: if (addr_count == 0)
! 218: (void)do_buffer(command, DOBUF_CURRENT, FORWARD, 0, forceit);
! 219: else
! 220: {
! 221: if (addr_count == 2)
! 222: {
! 223: if (*arg) /* both range and argument is not allowed */
! 224: return e_trailing;
! 225: bnr = start_bnr;
! 226: }
! 227: else /* addr_count == 1 */
! 228: bnr = end_bnr;
! 229:
! 230: for ( ;!got_int; mch_breakcheck())
! 231: {
! 232: /*
! 233: * delete the current buffer last, otherwise when the
! 234: * current buffer is deleted, the next buffer becomes
! 235: * the current one and will be loaded, which may then
! 236: * also be deleted, etc.
! 237: */
! 238: if (bnr == curbuf->b_fnum)
! 239: do_current = bnr;
! 240: else if (do_buffer(command, DOBUF_FIRST, FORWARD, (int)bnr,
! 241: forceit) == OK)
! 242: ++deleted;
! 243:
! 244: /*
! 245: * find next buffer number to delete/unload
! 246: */
! 247: if (addr_count == 2)
! 248: {
! 249: if (++bnr > end_bnr)
! 250: break;
! 251: }
! 252: else /* addr_count == 1 */
! 253: {
! 254: arg = skipwhite(arg);
! 255: if (*arg == NUL)
! 256: break;
! 257: if (!isdigit(*arg))
! 258: {
! 259: p = skiptowhite_esc(arg);
! 260: bnr = buflist_findpat(arg, p);
! 261: if (bnr < 0) /* failed */
! 262: break;
! 263: arg = p;
! 264: }
! 265: else
! 266: bnr = getdigits(&arg);
! 267: }
! 268: }
! 269: if (!got_int && do_current && do_buffer(command, DOBUF_FIRST,
! 270: FORWARD, do_current, forceit) == OK)
! 271: ++deleted;
! 272:
! 273: if (deleted == 0)
! 274: {
! 275: sprintf((char *)IObuff, "No buffers were %s",
! 276: command == DOBUF_UNLOAD ? "unloaded" : "deleted");
! 277: errormsg = IObuff;
! 278: }
! 279: else
! 280: smsg((char_u *)"%d buffer%s %s", deleted,
! 281: plural((long)deleted),
! 282: command == DOBUF_UNLOAD ? "unloaded" : "deleted");
! 283: }
! 284:
! 285: return errormsg;
! 286: }
! 287:
! 288: /*
! 289: * Implementation of the command for the buffer list
! 290: *
! 291: * action == DOBUF_GOTO go to specified buffer
! 292: * action == DOBUF_SPLIT split window and go to specified buffer
! 293: * action == DOBUF_UNLOAD unload specified buffer(s)
! 294: * action == DOBUF_DEL delete specified buffer(s)
! 295: *
! 296: * start == DOBUF_CURRENT go to "count" buffer from current buffer
! 297: * start == DOBUF_FIRST go to "count" buffer from first buffer
! 298: * start == DOBUF_LAST go to "count" buffer from last buffer
! 299: * start == DOBUF_MOD go to "count" modified buffer from current buffer
! 300: *
! 301: * Return FAIL or OK.
! 302: */
! 303: int
! 304: do_buffer(action, start, dir, count, forceit)
! 305: int action;
! 306: int start;
! 307: int dir; /* FORWARD or BACKWARD */
! 308: int count; /* buffer number or number of buffers */
! 309: int forceit; /* TRUE for :bdelete! */
! 310: {
! 311: BUF *buf;
! 312: BUF *delbuf;
! 313: int retval;
! 314:
! 315: switch (start)
! 316: {
! 317: case DOBUF_FIRST: buf = firstbuf; break;
! 318: case DOBUF_LAST: buf = lastbuf; break;
! 319: default: buf = curbuf; break;
! 320: }
! 321: if (start == DOBUF_MOD) /* find next modified buffer */
! 322: {
! 323: while (count-- > 0)
! 324: {
! 325: do
! 326: {
! 327: buf = buf->b_next;
! 328: if (buf == NULL)
! 329: buf = firstbuf;
! 330: }
! 331: while (buf != curbuf && !buf->b_changed);
! 332: }
! 333: if (!buf->b_changed)
! 334: {
! 335: EMSG("No modified buffer found");
! 336: return FAIL;
! 337: }
! 338: }
! 339: else if (start == DOBUF_FIRST && count) /* find specified buffer number */
! 340: {
! 341: while (buf != NULL && buf->b_fnum != count)
! 342: buf = buf->b_next;
! 343: }
! 344: else
! 345: {
! 346: while (count-- > 0)
! 347: {
! 348: if (dir == FORWARD)
! 349: {
! 350: buf = buf->b_next;
! 351: if (buf == NULL)
! 352: buf = firstbuf;
! 353: }
! 354: else
! 355: {
! 356: buf = buf->b_prev;
! 357: if (buf == NULL)
! 358: buf = lastbuf;
! 359: }
! 360: }
! 361: }
! 362:
! 363: if (buf == NULL) /* could not find it */
! 364: {
! 365: if (start == DOBUF_FIRST)
! 366: {
! 367: /* don't warn when deleting */
! 368: if (action != DOBUF_UNLOAD && action != DOBUF_DEL)
! 369: EMSGN("Cannot go to buffer %ld", count);
! 370: }
! 371: else if (dir == FORWARD)
! 372: EMSG("Cannot go beyond last buffer");
! 373: else
! 374: EMSG("Cannot go before first buffer");
! 375: return FAIL;
! 376: }
! 377:
! 378: /*
! 379: * delete buffer buf from memory and/or the list
! 380: */
! 381: if (action == DOBUF_UNLOAD || action == DOBUF_DEL)
! 382: {
! 383: if (!forceit && buf->b_changed)
! 384: {
! 385: EMSGN("No write since last change for buffer %ld (use ! to override)",
! 386: buf->b_fnum);
! 387: return FAIL;
! 388: }
! 389:
! 390: /*
! 391: * If deleting last buffer, make it empty.
! 392: * The last buffer cannot be unloaded.
! 393: */
! 394: if (firstbuf->b_next == NULL)
! 395: {
! 396: if (action == DOBUF_UNLOAD)
! 397: {
! 398: EMSG("Cannot unload last buffer");
! 399: return FAIL;
! 400: }
! 401: /* Close any other windows on this buffer */
! 402: close_others(FALSE);
! 403: buf = curbuf;
! 404: setpcmark();
! 405: retval = do_ecmd(0, NULL, NULL, NULL, FALSE, (linenr_t)1, FALSE);
! 406: /*
! 407: * The do_ecmd() may create a new buffer, then we have to delete
! 408: * the old one. But do_ecmd() may have done that already, check
! 409: * if the buffer still exists (it will be the first or second in
! 410: * the buffer list).
! 411: */
! 412: if (buf != curbuf && (buf == firstbuf || buf == firstbuf->b_next))
! 413: close_buffer(NULL, buf, TRUE, TRUE);
! 414: return retval;
! 415: }
! 416:
! 417: /*
! 418: * If the deleted buffer is the current one, close the current window
! 419: * (unless it's the only window).
! 420: */
! 421: while (buf == curbuf && firstwin != lastwin)
! 422: close_window(curwin, FALSE);
! 423:
! 424: /*
! 425: * If the buffer to be deleted is not current one, delete it here.
! 426: */
! 427: if (buf != curbuf)
! 428: {
! 429: close_windows(buf);
! 430: close_buffer(NULL, buf, TRUE, action == DOBUF_DEL);
! 431: return OK;
! 432: }
! 433:
! 434: /*
! 435: * Deleting the current buffer: Need to find another buffer to go to.
! 436: * There must be another, otherwise it would have been handled above.
! 437: */
! 438: if (curbuf->b_next != NULL)
! 439: buf = curbuf->b_next;
! 440: else
! 441: buf = curbuf->b_prev;
! 442: }
! 443:
! 444: /*
! 445: * make buf current buffer
! 446: */
! 447: setpcmark();
! 448: if (action == DOBUF_SPLIT) /* split window first */
! 449: {
! 450: if (win_split(0, FALSE) == FAIL)
! 451: return FAIL;
! 452: }
! 453: curwin->w_alt_fnum = curbuf->b_fnum; /* remember alternate file */
! 454: buflist_altlnum(); /* remember curpos.lnum */
! 455:
! 456: #ifdef AUTOCMD
! 457: apply_autocmds(EVENT_BUFLEAVE, NULL, NULL);
! 458: #endif
! 459: delbuf = curbuf; /* close_windows() may change curbuf */
! 460: if (action == DOBUF_UNLOAD || action == DOBUF_DEL)
! 461: close_windows(curbuf);
! 462: close_buffer(NULL, delbuf, action == DOBUF_UNLOAD || action == DOBUF_DEL,
! 463: action == DOBUF_DEL);
! 464: enter_buffer(buf);
! 465: return OK;
! 466: }
! 467:
! 468: /*
! 469: * enter a new current buffer.
! 470: * (old curbuf must have been freed already)
! 471: */
! 472: static void
! 473: enter_buffer(buf)
! 474: BUF *buf;
! 475: {
! 476: buf_copy_options(curbuf, buf, TRUE);
! 477: curwin->w_buffer = buf;
! 478: curbuf = buf;
! 479: ++curbuf->b_nwindows;
! 480: if (curbuf->b_ml.ml_mfp == NULL) /* need to load the file */
! 481: open_buffer();
! 482: else
! 483: {
! 484: need_fileinfo = TRUE; /* display file info after redraw */
! 485: buf_check_timestamp(curbuf); /* check if file has changed */
! 486: #ifdef AUTOCMD
! 487: apply_autocmds(EVENT_BUFENTER, NULL, NULL);
! 488: #endif
! 489: }
! 490: buflist_getlnum(); /* restore curpos.lnum */
! 491: check_arg_idx(); /* check for valid arg_idx */
! 492: maketitle();
! 493: scroll_cursor_halfway(FALSE); /* redisplay at correct position */
! 494: updateScreen(NOT_VALID);
! 495: }
! 496:
! 497: /*
! 498: * functions for dealing with the buffer list
! 499: */
! 500:
! 501: /*
! 502: * Add a file name to the buffer list. Return a pointer to the buffer.
! 503: * If the same file name already exists return a pointer to that buffer.
! 504: * If it does not exist, or if fname == NULL, a new entry is created.
! 505: * If use_curbuf is TRUE, may use current buffer.
! 506: * This is the ONLY way to create a new buffer.
! 507: */
! 508: BUF *
! 509: buflist_new(fname, sfname, lnum, use_curbuf)
! 510: char_u *fname;
! 511: char_u *sfname;
! 512: linenr_t lnum;
! 513: int use_curbuf;
! 514: {
! 515: static int top_file_num = 1; /* highest file number */
! 516: BUF *buf;
! 517:
! 518: fname_expand(&fname, &sfname);
! 519:
! 520: /*
! 521: * If file name already exists in the list, update the entry
! 522: */
! 523: if (fname != NULL && (buf = buflist_findname(fname)) != NULL)
! 524: {
! 525: if (lnum != 0)
! 526: buflist_setlnum(buf, lnum);
! 527: /* copy the options now, if 'cpo' doesn't have 's' and not done
! 528: * already */
! 529: buf_copy_options(curbuf, buf, FALSE);
! 530: return buf;
! 531: }
! 532:
! 533: /*
! 534: * If the current buffer has no name and no contents, use the current buffer.
! 535: * Otherwise: Need to allocate a new buffer structure.
! 536: *
! 537: * This is the ONLY place where a new buffer structure is allocated!
! 538: */
! 539: if (use_curbuf && curbuf != NULL && curbuf->b_filename == NULL &&
! 540: curbuf->b_nwindows <= 1 &&
! 541: (curbuf->b_ml.ml_mfp == NULL || bufempty()))
! 542: buf = curbuf;
! 543: else
! 544: {
! 545: buf = (BUF *)alloc((unsigned)sizeof(BUF));
! 546: if (buf == NULL)
! 547: return NULL;
! 548: (void)vim_memset(buf, 0, sizeof(BUF));
! 549: }
! 550:
! 551: if (fname != NULL)
! 552: {
! 553: buf->b_filename = strsave(fname);
! 554: buf->b_sfilename = strsave(sfname);
! 555: }
! 556: if (buf->b_winlnum == NULL)
! 557: buf->b_winlnum = (WINLNUM *)alloc((unsigned)sizeof(WINLNUM));
! 558: if ((fname != NULL && (buf->b_filename == NULL ||
! 559: buf->b_sfilename == NULL)) || buf->b_winlnum == NULL)
! 560: {
! 561: vim_free(buf->b_filename);
! 562: buf->b_filename = NULL;
! 563: vim_free(buf->b_sfilename);
! 564: buf->b_sfilename = NULL;
! 565: if (buf != curbuf)
! 566: {
! 567: vim_free(buf->b_winlnum);
! 568: free_buf_options(buf);
! 569: }
! 570: return NULL;
! 571: }
! 572:
! 573: if (buf == curbuf)
! 574: {
! 575: buf_freeall(buf); /* free all things allocated for this buffer */
! 576: buf->b_nwindows = 0;
! 577: }
! 578: else
! 579: {
! 580: /*
! 581: * Copy the options from the current buffer.
! 582: */
! 583: buf_copy_options(curbuf, buf, FALSE);
! 584:
! 585: /*
! 586: * put new buffer at the end of the buffer list
! 587: */
! 588: buf->b_next = NULL;
! 589: if (firstbuf == NULL) /* buffer list is empty */
! 590: {
! 591: buf->b_prev = NULL;
! 592: firstbuf = buf;
! 593: }
! 594: else /* append new buffer at end of list */
! 595: {
! 596: lastbuf->b_next = buf;
! 597: buf->b_prev = lastbuf;
! 598: }
! 599: lastbuf = buf;
! 600:
! 601: buf->b_fnum = top_file_num++;
! 602: if (top_file_num < 0) /* wrap around (may cause duplicates) */
! 603: {
! 604: EMSG("Warning: List of file names overflow");
! 605: mch_delay(3000L, TRUE); /* make sure it is noticed */
! 606: top_file_num = 1;
! 607: }
! 608:
! 609: buf->b_winlnum->wl_lnum = lnum;
! 610: buf->b_winlnum->wl_next = NULL;
! 611: buf->b_winlnum->wl_prev = NULL;
! 612: buf->b_winlnum->wl_win = curwin;
! 613: }
! 614:
! 615: if (did_cd)
! 616: buf->b_xfilename = buf->b_filename;
! 617: else
! 618: buf->b_xfilename = buf->b_sfilename;
! 619: buf->b_u_synced = TRUE;
! 620: buf->b_neverloaded = TRUE;
! 621: buf_clear(buf);
! 622: clrallmarks(buf); /* clear marks */
! 623: fmarks_check_names(buf); /* check file marks for this file */
! 624:
! 625: return buf;
! 626: }
! 627:
! 628: /*
! 629: * Free the memory for a BUF structure and its options
! 630: */
! 631: static void
! 632: free_buf_options(buf)
! 633: BUF *buf;
! 634: {
! 635: free_string_option(buf->b_p_fo);
! 636: free_string_option(buf->b_p_isk);
! 637: free_string_option(buf->b_p_com);
! 638: #ifdef CINDENT
! 639: free_string_option(buf->b_p_cink);
! 640: free_string_option(buf->b_p_cino);
! 641: #endif
! 642: #if defined(CINDENT) || defined(SMARTINDENT)
! 643: free_string_option(buf->b_p_cinw);
! 644: #endif
! 645: vim_free(buf);
! 646: }
! 647:
! 648: /*
! 649: * get alternate file n
! 650: * set linenr to lnum or altlnum if lnum == 0
! 651: * if (options & GETF_SETMARK) call setpcmark()
! 652: * if (options & GETF_ALT) we are jumping to an alternate file.
! 653: *
! 654: * return FAIL for failure, OK for success
! 655: */
! 656: int
! 657: buflist_getfile(n, lnum, options)
! 658: int n;
! 659: linenr_t lnum;
! 660: int options;
! 661: {
! 662: BUF *buf;
! 663:
! 664: buf = buflist_findnr(n);
! 665: if (buf == NULL)
! 666: {
! 667: if ((options & GETF_ALT) && n == 0)
! 668: emsg(e_noalt);
! 669: else
! 670: EMSGN("buffer %ld not found", n);
! 671: return FAIL;
! 672: }
! 673:
! 674: /* if alternate file is the current buffer, nothing to do */
! 675: if (buf == curbuf)
! 676: return OK;
! 677:
! 678: /* altlnum may be changed by getfile(), get it now */
! 679: if (lnum == 0)
! 680: lnum = buflist_findlnum(buf);
! 681: ++RedrawingDisabled;
! 682: if (getfile(buf->b_fnum, NULL, NULL, (options & GETF_SETMARK), lnum) <= 0)
! 683: {
! 684: --RedrawingDisabled;
! 685: return OK;
! 686: }
! 687: --RedrawingDisabled;
! 688: return FAIL;
! 689: }
! 690:
! 691: /*
! 692: * go to the last know line number for the current buffer
! 693: */
! 694: void
! 695: buflist_getlnum()
! 696: {
! 697: linenr_t lnum;
! 698:
! 699: curwin->w_cursor.lnum = 1;
! 700: curwin->w_cursor.col = 0;
! 701: lnum = buflist_findlnum(curbuf);
! 702: if (lnum != 0 && lnum <= curbuf->b_ml.ml_line_count)
! 703: curwin->w_cursor.lnum = lnum;
! 704: }
! 705:
! 706: /*
! 707: * find file in buffer list by name (it has to be for the current window)
! 708: * 'fname' must have a full path.
! 709: */
! 710: BUF *
! 711: buflist_findname(fname)
! 712: char_u *fname;
! 713: {
! 714: BUF *buf;
! 715:
! 716: for (buf = firstbuf; buf != NULL; buf = buf->b_next)
! 717: if (buf->b_filename != NULL && fnamecmp(fname, buf->b_filename) == 0)
! 718: return (buf);
! 719: return NULL;
! 720: }
! 721:
! 722: /*
! 723: * Find file in buffer list by a regexppattern.
! 724: * Return fnum of the found buffer, < 0 for error.
! 725: */
! 726: int
! 727: buflist_findpat(pattern, pattern_end)
! 728: char_u *pattern;
! 729: char_u *pattern_end; /* pointer to first char after pattern */
! 730: {
! 731: BUF *buf;
! 732: regexp *prog;
! 733: int fnum = -1;
! 734: char_u *pat;
! 735: char_u *match;
! 736: int attempt;
! 737: char_u *p;
! 738:
! 739: if (pattern_end == pattern + 1 && (*pattern == '%' || *pattern == '#'))
! 740: {
! 741: if (*pattern == '%')
! 742: fnum = curbuf->b_fnum;
! 743: else
! 744: fnum = curwin->w_alt_fnum;
! 745: }
! 746:
! 747: /*
! 748: * Try four ways of matching:
! 749: * attempt == 0: without '^' or '$' (at any position)
! 750: * attempt == 1: with '^' at start (only at postion 0)
! 751: * attempt == 2: with '$' at end (only match at end)
! 752: * attempt == 3: with '^' at start and '$' at end (only full match)
! 753: */
! 754: else for (attempt = 0; attempt <= 3; ++attempt)
! 755: {
! 756: /* may add '^' and '$' */
! 757: pat = file_pat_to_reg_pat(pattern, pattern_end, NULL);
! 758: if (pat == NULL)
! 759: return -1;
! 760: if (attempt < 2)
! 761: {
! 762: p = pat + STRLEN(pat) - 1;
! 763: if (p > pat && *p == '$') /* remove '$' */
! 764: *p = NUL;
! 765: }
! 766: p = pat;
! 767: if (*p == '^' && !(attempt & 1)) /* remove '^' */
! 768: ++p;
! 769: prog = vim_regcomp(p);
! 770: vim_free(pat);
! 771: if (prog == NULL)
! 772: return -1;
! 773:
! 774: for (buf = firstbuf; buf != NULL; buf = buf->b_next)
! 775: {
! 776: match = buflist_match(prog, buf);
! 777: if (match != NULL)
! 778: {
! 779: if (fnum >= 0) /* already found a match */
! 780: {
! 781: fnum = -2;
! 782: break;
! 783: }
! 784: fnum = buf->b_fnum; /* remember first match */
! 785: }
! 786: }
! 787: vim_free(prog);
! 788: if (fnum >= 0) /* found one match */
! 789: break;
! 790: }
! 791:
! 792: if (fnum == -2)
! 793: EMSG2("More than one match for %s", pattern);
! 794: if (fnum < 1)
! 795: EMSG2("No matching buffer for %s", pattern);
! 796: return fnum;
! 797: }
! 798:
! 799: /*
! 800: * Find all buffer names that match.
! 801: * For command line expansion of ":buf" and ":sbuf".
! 802: * Return OK if matches found, FAIL otherwise.
! 803: */
! 804: int
! 805: ExpandBufnames(pat, num_file, file, options)
! 806: char_u *pat;
! 807: int *num_file;
! 808: char_u ***file;
! 809: int options;
! 810: {
! 811: int count = 0;
! 812: BUF *buf;
! 813: int round;
! 814: char_u *p;
! 815: int attempt;
! 816: regexp *prog;
! 817:
! 818: *num_file = 0; /* return values in case of FAIL */
! 819: *file = NULL;
! 820:
! 821: /*
! 822: * attempt == 1: try match with '^', match at start
! 823: * attempt == 2: try match without '^', match anywhere
! 824: */
! 825: for (attempt = 1; attempt <= 2; ++attempt)
! 826: {
! 827: if (attempt == 2)
! 828: {
! 829: if (*pat != '^') /* there's no '^', no need to try again */
! 830: break;
! 831: ++pat; /* skip the '^' */
! 832: }
! 833: prog = vim_regcomp(pat);
! 834: if (prog == NULL)
! 835: return FAIL;
! 836:
! 837: /*
! 838: * round == 1: Count the matches.
! 839: * round == 2: Build the array to keep the matches.
! 840: */
! 841: for (round = 1; round <= 2; ++round)
! 842: {
! 843: count = 0;
! 844: for (buf = firstbuf; buf != NULL; buf = buf->b_next)
! 845: {
! 846: p = buflist_match(prog, buf);
! 847: if (p != NULL)
! 848: {
! 849: if (round == 1)
! 850: ++count;
! 851: else
! 852: {
! 853: if (options & WILD_HOME_REPLACE)
! 854: p = home_replace_save(buf, p);
! 855: else
! 856: p = strsave(p);
! 857: (*file)[count++] = p;
! 858: }
! 859: }
! 860: }
! 861: if (count == 0) /* no match found, break here */
! 862: break;
! 863: if (round == 1)
! 864: {
! 865: *file = (char_u **)alloc((unsigned)(count * sizeof(char_u *)));
! 866: if (*file == NULL)
! 867: {
! 868: vim_free(prog);
! 869: return FAIL;
! 870: }
! 871: }
! 872: }
! 873: vim_free(prog);
! 874: if (count) /* match(es) found, break here */
! 875: break;
! 876: }
! 877:
! 878: *num_file = count;
! 879: return (count == 0 ? FAIL : OK);
! 880: }
! 881:
! 882: /*
! 883: * Check for a match on the file name for buffer "buf" with regex prog "prog".
! 884: */
! 885: static char_u *
! 886: buflist_match(prog, buf)
! 887: regexp *prog;
! 888: BUF *buf;
! 889: {
! 890: char_u *match = NULL;
! 891:
! 892: if (buf->b_sfilename != NULL &&
! 893: vim_regexec(prog, buf->b_sfilename, TRUE) != 0)
! 894: match = buf->b_sfilename;
! 895: else if (buf->b_filename != NULL)
! 896: {
! 897: if (vim_regexec(prog, buf->b_filename, TRUE) != 0)
! 898: match = buf->b_filename;
! 899: else
! 900: {
! 901: home_replace(NULL, buf->b_filename, NameBuff, MAXPATHL);
! 902: if (vim_regexec(prog, NameBuff, TRUE) != 0)
! 903: match = buf->b_filename;
! 904: }
! 905: }
! 906: return match;
! 907: }
! 908:
! 909: /*
! 910: * find file in buffer name list by number
! 911: */
! 912: BUF *
! 913: buflist_findnr(nr)
! 914: int nr;
! 915: {
! 916: BUF *buf;
! 917:
! 918: if (nr == 0)
! 919: nr = curwin->w_alt_fnum;
! 920: for (buf = firstbuf; buf != NULL; buf = buf->b_next)
! 921: if (buf->b_fnum == nr)
! 922: return (buf);
! 923: return NULL;
! 924: }
! 925:
! 926: /*
! 927: * get name of file 'n' in the buffer list
! 928: */
! 929: char_u *
! 930: buflist_nr2name(n, fullname, helptail)
! 931: int n;
! 932: int fullname;
! 933: int helptail; /* for help buffers return tail only */
! 934: {
! 935: BUF *buf;
! 936: char_u *fname;
! 937:
! 938: buf = buflist_findnr(n);
! 939: if (buf == NULL)
! 940: return NULL;
! 941: if (fullname)
! 942: fname = buf->b_filename;
! 943: else
! 944: fname = buf->b_xfilename;
! 945: home_replace(helptail ? buf : NULL, fname, NameBuff, MAXPATHL);
! 946: return NameBuff;
! 947: }
! 948:
! 949: /*
! 950: * set the lnum for the buffer 'buf' and the current window
! 951: */
! 952: static void
! 953: buflist_setlnum(buf, lnum)
! 954: BUF *buf;
! 955: linenr_t lnum;
! 956: {
! 957: WINLNUM *wlp;
! 958:
! 959: for (wlp = buf->b_winlnum; wlp != NULL; wlp = wlp->wl_next)
! 960: if (wlp->wl_win == curwin)
! 961: break;
! 962: if (wlp == NULL) /* make new entry */
! 963: {
! 964: wlp = (WINLNUM *)alloc((unsigned)sizeof(WINLNUM));
! 965: if (wlp == NULL)
! 966: return;
! 967: wlp->wl_win = curwin;
! 968: }
! 969: else /* remove entry from list */
! 970: {
! 971: if (wlp->wl_prev)
! 972: wlp->wl_prev->wl_next = wlp->wl_next;
! 973: else
! 974: buf->b_winlnum = wlp->wl_next;
! 975: if (wlp->wl_next)
! 976: wlp->wl_next->wl_prev = wlp->wl_prev;
! 977: }
! 978: wlp->wl_lnum = lnum;
! 979: /*
! 980: * insert entry in front of the list
! 981: */
! 982: wlp->wl_next = buf->b_winlnum;
! 983: buf->b_winlnum = wlp;
! 984: wlp->wl_prev = NULL;
! 985: if (wlp->wl_next)
! 986: wlp->wl_next->wl_prev = wlp;
! 987:
! 988: return;
! 989: }
! 990:
! 991: /*
! 992: * find the lnum for the buffer 'buf' for the current window
! 993: */
! 994: static linenr_t
! 995: buflist_findlnum(buf)
! 996: BUF *buf;
! 997: {
! 998: WINLNUM *wlp;
! 999:
! 1000: for (wlp = buf->b_winlnum; wlp != NULL; wlp = wlp->wl_next)
! 1001: if (wlp->wl_win == curwin)
! 1002: break;
! 1003:
! 1004: if (wlp == NULL) /* if no lnum for curwin, use the first in the list */
! 1005: wlp = buf->b_winlnum;
! 1006:
! 1007: if (wlp)
! 1008: return wlp->wl_lnum;
! 1009: else
! 1010: return (linenr_t)1;
! 1011: }
! 1012:
! 1013: /*
! 1014: * list all know file names (for :files and :buffers command)
! 1015: */
! 1016: void
! 1017: buflist_list()
! 1018: {
! 1019: BUF *buf;
! 1020: int len;
! 1021:
! 1022: for (buf = firstbuf; buf != NULL && !got_int; buf = buf->b_next)
! 1023: {
! 1024: msg_outchar('\n');
! 1025: if (buf->b_xfilename == NULL)
! 1026: STRCPY(NameBuff, "No File");
! 1027: else
! 1028: /* careful: home_replace calls vim_getenv(), which uses IObuff! */
! 1029: home_replace(buf, buf->b_xfilename, NameBuff, MAXPATHL);
! 1030:
! 1031: sprintf((char *)IObuff, "%3d %c%c%c \"",
! 1032: buf->b_fnum,
! 1033: buf == curbuf ? '%' :
! 1034: (curwin->w_alt_fnum == buf->b_fnum ? '#' : ' '),
! 1035: buf->b_ml.ml_mfp == NULL ? '-' :
! 1036: (buf->b_nwindows == 0 ? 'h' : ' '),
! 1037: buf->b_changed ? '+' : ' ');
! 1038:
! 1039: len = STRLEN(IObuff);
! 1040: STRNCPY(IObuff + len, NameBuff, IOSIZE - 20 - len);
! 1041:
! 1042: len = STRLEN(IObuff);
! 1043: IObuff[len++] = '"';
! 1044: /*
! 1045: * try to put the "line" strings in column 40
! 1046: */
! 1047: do
! 1048: {
! 1049: IObuff[len++] = ' ';
! 1050: } while (len < 40 && len < IOSIZE - 18);
! 1051: sprintf((char *)IObuff + len, "line %ld",
! 1052: buf == curbuf ? curwin->w_cursor.lnum :
! 1053: (long)buflist_findlnum(buf));
! 1054: msg_outtrans(IObuff);
! 1055: flushbuf(); /* output one line at a time */
! 1056: mch_breakcheck();
! 1057: }
! 1058: }
! 1059:
! 1060: /*
! 1061: * get file name and line number for file 'fnum'
! 1062: * used by DoOneCmd() for translating '%' and '#'
! 1063: * return FAIL if not found, OK for success
! 1064: */
! 1065: int
! 1066: buflist_name_nr(fnum, fname, lnum)
! 1067: int fnum;
! 1068: char_u **fname;
! 1069: linenr_t *lnum;
! 1070: {
! 1071: BUF *buf;
! 1072:
! 1073: buf = buflist_findnr(fnum);
! 1074: if (buf == NULL || buf->b_filename == NULL)
! 1075: return FAIL;
! 1076:
! 1077: if (did_cd)
! 1078: *fname = buf->b_filename;
! 1079: else
! 1080: *fname = buf->b_sfilename;
! 1081: *lnum = buflist_findlnum(buf);
! 1082:
! 1083: return OK;
! 1084: }
! 1085:
! 1086: /*
! 1087: * Set the current file name to 's', short file name to 'ss'.
! 1088: * The file name with the full path is also remembered, for when :cd is used.
! 1089: * Returns FAIL for failure (file name already in use by other buffer)
! 1090: * OK otherwise.
! 1091: */
! 1092: int
! 1093: setfname(fname, sfname, message)
! 1094: char_u *fname, *sfname;
! 1095: int message;
! 1096: {
! 1097: BUF *buf;
! 1098:
! 1099: if (fname == NULL || *fname == NUL)
! 1100: {
! 1101: vim_free(curbuf->b_filename);
! 1102: vim_free(curbuf->b_sfilename);
! 1103: curbuf->b_filename = NULL;
! 1104: curbuf->b_sfilename = NULL;
! 1105: }
! 1106: else
! 1107: {
! 1108: fname_expand(&fname, &sfname);
! 1109: #ifdef USE_FNAME_CASE
! 1110: # ifdef USE_LONG_FNAME
! 1111: if (USE_LONG_FNAME)
! 1112: # endif
! 1113: fname_case(sfname); /* set correct case for short filename */
! 1114: #endif
! 1115: /*
! 1116: * if the file name is already used in another buffer:
! 1117: * - if the buffer is loaded, fail
! 1118: * - if the buffer is not loaded, delete it from the list
! 1119: */
! 1120: buf = buflist_findname(fname);
! 1121: if (buf != NULL && buf != curbuf)
! 1122: {
! 1123: if (buf->b_ml.ml_mfp != NULL) /* it's loaded, fail */
! 1124: {
! 1125: if (message)
! 1126: EMSG("Buffer with this name already exists");
! 1127: return FAIL;
! 1128: }
! 1129: close_buffer(NULL, buf, TRUE, TRUE); /* delete from the list */
! 1130: }
! 1131: fname = strsave(fname);
! 1132: sfname = strsave(sfname);
! 1133: if (fname == NULL || sfname == NULL)
! 1134: {
! 1135: vim_free(sfname);
! 1136: vim_free(fname);
! 1137: return FAIL;
! 1138: }
! 1139: vim_free(curbuf->b_filename);
! 1140: vim_free(curbuf->b_sfilename);
! 1141: curbuf->b_filename = fname;
! 1142: curbuf->b_sfilename = sfname;
! 1143: }
! 1144: if (did_cd)
! 1145: curbuf->b_xfilename = curbuf->b_filename;
! 1146: else
! 1147: curbuf->b_xfilename = curbuf->b_sfilename;
! 1148:
! 1149: #ifndef SHORT_FNAME
! 1150: curbuf->b_shortname = FALSE;
! 1151: #endif
! 1152: /*
! 1153: * If the file name changed, also change the name of the swapfile
! 1154: */
! 1155: if (curbuf->b_ml.ml_mfp != NULL)
! 1156: ml_setname();
! 1157:
! 1158: check_arg_idx(); /* check file name for arg list */
! 1159: maketitle(); /* set window title */
! 1160: status_redraw_all(); /* status lines need to be redrawn */
! 1161: fmarks_check_names(curbuf); /* check named file marks */
! 1162: ml_timestamp(curbuf); /* reset timestamp */
! 1163: return OK;
! 1164: }
! 1165:
! 1166: /*
! 1167: * set alternate file name for current window
! 1168: *
! 1169: * used by dowrite() and do_ecmd()
! 1170: */
! 1171: void
! 1172: setaltfname(fname, sfname, lnum)
! 1173: char_u *fname;
! 1174: char_u *sfname;
! 1175: linenr_t lnum;
! 1176: {
! 1177: BUF *buf;
! 1178:
! 1179: buf = buflist_new(fname, sfname, lnum, FALSE);
! 1180: if (buf != NULL)
! 1181: curwin->w_alt_fnum = buf->b_fnum;
! 1182: }
! 1183:
! 1184: /*
! 1185: * add a file name to the buflist and return its number
! 1186: *
! 1187: * used by qf_init(), main() and doarglist()
! 1188: */
! 1189: int
! 1190: buflist_add(fname)
! 1191: char_u *fname;
! 1192: {
! 1193: BUF *buf;
! 1194:
! 1195: buf = buflist_new(fname, NULL, (linenr_t)0, FALSE);
! 1196: if (buf != NULL)
! 1197: return buf->b_fnum;
! 1198: return 0;
! 1199: }
! 1200:
! 1201: /*
! 1202: * set alternate lnum for current window
! 1203: */
! 1204: void
! 1205: buflist_altlnum()
! 1206: {
! 1207: buflist_setlnum(curbuf, curwin->w_cursor.lnum);
! 1208: }
! 1209:
! 1210: /*
! 1211: * return nonzero if 'fname' is not the same file as current file
! 1212: * fname must have a full path (expanded by FullName)
! 1213: */
! 1214: int
! 1215: otherfile(fname)
! 1216: char_u *fname;
! 1217: { /* no name is different */
! 1218: if (fname == NULL || *fname == NUL || curbuf->b_filename == NULL)
! 1219: return TRUE;
! 1220: return fnamecmp(fname, curbuf->b_filename);
! 1221: }
! 1222:
! 1223: void
! 1224: fileinfo(fullname, shorthelp, dont_truncate)
! 1225: int fullname;
! 1226: int shorthelp;
! 1227: int dont_truncate;
! 1228: {
! 1229: char_u *name;
! 1230: int n;
! 1231: char_u *p;
! 1232: char_u *buffer;
! 1233:
! 1234: buffer = alloc(IOSIZE);
! 1235: if (buffer == NULL)
! 1236: return;
! 1237:
! 1238: if (fullname > 1) /* 2 CTRL-G: include buffer number */
! 1239: {
! 1240: sprintf((char *)buffer, "buf %d: ", curbuf->b_fnum);
! 1241: p = buffer + STRLEN(buffer);
! 1242: }
! 1243: else
! 1244: p = buffer;
! 1245:
! 1246: *p++ = '"';
! 1247: if (curbuf->b_filename == NULL)
! 1248: STRCPY(p, "No File");
! 1249: else
! 1250: {
! 1251: if (!fullname && curbuf->b_sfilename != NULL)
! 1252: name = curbuf->b_sfilename;
! 1253: else
! 1254: name = curbuf->b_filename;
! 1255: home_replace(shorthelp ? curbuf : NULL, name, p,
! 1256: (int)(IOSIZE - (p - buffer)));
! 1257: }
! 1258:
! 1259: sprintf((char *)buffer + STRLEN(buffer),
! 1260: "\"%s%s%s%s",
! 1261: curbuf->b_changed ? (shortmess(SHM_MOD) ?
! 1262: " [+]" : " [Modified]") : " ",
! 1263: curbuf->b_notedited ? "[Not edited]" : "",
! 1264: curbuf->b_p_ro ? (shortmess(SHM_RO) ? "[RO]" : "[readonly]") : "",
! 1265: (curbuf->b_changed || curbuf->b_notedited || curbuf->b_p_ro) ?
! 1266: " " : "");
! 1267: n = (int)(((long)curwin->w_cursor.lnum * 100L) /
! 1268: (long)curbuf->b_ml.ml_line_count);
! 1269: if (curbuf->b_ml.ml_flags & ML_EMPTY)
! 1270: {
! 1271: STRCPY(buffer + STRLEN(buffer), no_lines_msg);
! 1272: }
! 1273: else if (p_ru)
! 1274: {
! 1275: /* Current line and column are already on the screen -- webb */
! 1276: sprintf((char *)buffer + STRLEN(buffer),
! 1277: "%ld line%s --%d%%--",
! 1278: (long)curbuf->b_ml.ml_line_count,
! 1279: plural((long)curbuf->b_ml.ml_line_count),
! 1280: n);
! 1281: }
! 1282: else
! 1283: {
! 1284: sprintf((char *)buffer + STRLEN(buffer),
! 1285: "line %ld of %ld --%d%%-- col ",
! 1286: (long)curwin->w_cursor.lnum,
! 1287: (long)curbuf->b_ml.ml_line_count,
! 1288: n);
! 1289: col_print(buffer + STRLEN(buffer),
! 1290: (int)curwin->w_cursor.col + 1, (int)curwin->w_virtcol + 1);
! 1291: }
! 1292:
! 1293: append_arg_number(buffer, !shortmess(SHM_FILE));
! 1294:
! 1295: if (dont_truncate)
! 1296: msg(buffer);
! 1297: else
! 1298: msg_trunc(buffer);
! 1299:
! 1300: vim_free(buffer);
! 1301: }
! 1302:
! 1303: /*
! 1304: * Give some info about the position of the cursor (for "g CTRL-G").
! 1305: */
! 1306: void
! 1307: cursor_pos_info()
! 1308: {
! 1309: char_u *p;
! 1310: char_u buf1[20];
! 1311: char_u buf2[20];
! 1312: linenr_t lnum;
! 1313: long char_count = 0;
! 1314: long char_count_cursor = 0;
! 1315: int eol_size;
! 1316:
! 1317: /*
! 1318: * Compute the length of the file in characters.
! 1319: */
! 1320: if (curbuf->b_ml.ml_flags & ML_EMPTY)
! 1321: {
! 1322: MSG(no_lines_msg);
! 1323: }
! 1324: else
! 1325: {
! 1326: if (curbuf->b_p_tx)
! 1327: eol_size = 2;
! 1328: else
! 1329: eol_size = 1;
! 1330: for (lnum = 1; lnum <= curbuf->b_ml.ml_line_count; ++lnum)
! 1331: {
! 1332: if (lnum == curwin->w_cursor.lnum)
! 1333: char_count_cursor = char_count + curwin->w_cursor.col + 1;
! 1334: char_count += STRLEN(ml_get(lnum)) + eol_size;
! 1335: }
! 1336: if (!curbuf->b_p_eol && curbuf->b_p_bin)
! 1337: char_count -= eol_size;
! 1338:
! 1339: p = ml_get_curline();
! 1340: col_print(buf1, (int)curwin->w_cursor.col + 1, (int)curwin->w_virtcol + 1);
! 1341: col_print(buf2, (int)STRLEN(p), linetabsize(p));
! 1342:
! 1343: sprintf((char *)IObuff, "Col %s of %s; Line %ld of %ld; Char %ld of %ld",
! 1344: (char *)buf1, (char *)buf2,
! 1345: (long)curwin->w_cursor.lnum, (long)curbuf->b_ml.ml_line_count,
! 1346: char_count_cursor, char_count);
! 1347: msg(IObuff);
! 1348: }
! 1349: }
! 1350:
! 1351: void
! 1352: col_print(buf, col, vcol)
! 1353: char_u *buf;
! 1354: int col;
! 1355: int vcol;
! 1356: {
! 1357: if (col == vcol)
! 1358: sprintf((char *)buf, "%d", col);
! 1359: else
! 1360: sprintf((char *)buf, "%d-%d", col, vcol);
! 1361: }
! 1362:
! 1363: /*
! 1364: * put filename in title bar of window and in icon title
! 1365: */
! 1366:
! 1367: static char_u *lasttitle = NULL;
! 1368: static char_u *lasticon = NULL;
! 1369:
! 1370: void
! 1371: maketitle()
! 1372: {
! 1373: char_u *t_name;
! 1374: char_u *i_name;
! 1375:
! 1376: if (curbuf->b_filename == NULL)
! 1377: {
! 1378: t_name = (char_u *)"";
! 1379: i_name = (char_u *)"No File";
! 1380: }
! 1381: else
! 1382: {
! 1383: home_replace(curbuf, curbuf->b_filename, IObuff, IOSIZE);
! 1384: append_arg_number(IObuff, FALSE);
! 1385: t_name = IObuff;
! 1386: i_name = gettail(curbuf->b_filename); /* use filename only for icon */
! 1387: }
! 1388:
! 1389: vim_free(lasttitle);
! 1390: if (p_title && (lasttitle = alloc((unsigned)(strsize(t_name) + 7))) != NULL)
! 1391: {
! 1392: STRCPY(lasttitle, "VIM - ");
! 1393: while (*t_name)
! 1394: STRCAT(lasttitle, transchar(*t_name++));
! 1395: }
! 1396: else
! 1397: lasttitle = NULL;
! 1398:
! 1399: vim_free(lasticon);
! 1400: if (p_icon && (lasticon = alloc((unsigned)(strsize(i_name) + 1))) != NULL)
! 1401: {
! 1402: *lasticon = NUL;
! 1403: while (*i_name)
! 1404: STRCAT(lasticon, transchar(*i_name++));
! 1405: }
! 1406: else
! 1407: lasticon = NULL;
! 1408:
! 1409: resettitle();
! 1410: }
! 1411:
! 1412: /*
! 1413: * Append (file 2 of 8) to 'buf'.
! 1414: */
! 1415: static void
! 1416: append_arg_number(buf, add_file)
! 1417: char_u *buf;
! 1418: int add_file; /* Add "file" before the arg number */
! 1419: {
! 1420: if (arg_count <= 1) /* nothing to do */
! 1421: return;
! 1422:
! 1423: buf += STRLEN(buf); /* go to the end of the buffer */
! 1424: *buf++ = ' ';
! 1425: *buf++ = '(';
! 1426: if (add_file)
! 1427: {
! 1428: STRCPY(buf, "file ");
! 1429: buf += 5;
! 1430: }
! 1431: sprintf((char *)buf, curwin->w_arg_idx_invalid ? "(%d) of %d)" :
! 1432: "%d of %d)", curwin->w_arg_idx + 1, arg_count);
! 1433: }
! 1434:
! 1435: /*
! 1436: * Put current window title back (used after calling a shell)
! 1437: */
! 1438: void
! 1439: resettitle()
! 1440: {
! 1441: mch_settitle(lasttitle, lasticon);
! 1442: }
! 1443:
! 1444: /*
! 1445: * If fname is not a full path, make it a full path
! 1446: */
! 1447: char_u *
! 1448: fix_fname(fname)
! 1449: char_u *fname;
! 1450: {
! 1451: if (fname != NameBuff) /* if not already expanded */
! 1452: {
! 1453: if (!isFullName(fname))
! 1454: {
! 1455: (void)FullName(fname, NameBuff, MAXPATHL, FALSE);
! 1456: fname = NameBuff;
! 1457: }
! 1458: #ifdef USE_FNAME_CASE
! 1459: else
! 1460: # ifdef USE_LONG_FNAME
! 1461: if (USE_LONG_FNAME)
! 1462: # endif
! 1463: {
! 1464: STRNCPY(NameBuff, fname, MAXPATHL); /* make copy, it may change */
! 1465: fname = NameBuff;
! 1466: fname_case(fname); /* set correct case for filename */
! 1467: }
! 1468: #endif
! 1469: }
! 1470: return fname;
! 1471: }
! 1472:
! 1473: /*
! 1474: * make fname a full file name, set sfname to fname if not NULL
! 1475: */
! 1476: void
! 1477: fname_expand(fname, sfname)
! 1478: char_u **fname;
! 1479: char_u **sfname;
! 1480: {
! 1481: if (*fname == NULL) /* if no file name given, nothing to do */
! 1482: return;
! 1483: if (*sfname == NULL) /* if no short file name given, use fname */
! 1484: *sfname = *fname;
! 1485: *fname = fix_fname(*fname); /* expand to full path */
! 1486: }
! 1487:
! 1488: /*
! 1489: * do_arg_all: open up to 'count' windows, one for each argument
! 1490: */
! 1491: void
! 1492: do_arg_all(count)
! 1493: int count;
! 1494: {
! 1495: int i;
! 1496:
! 1497: if (arg_count <= 1)
! 1498: {
! 1499: /* Don't give this obvious error message. We don't want it when the
! 1500: * ":all" command is in the .vimrc. */
! 1501: /* EMSG("Argument list contains less than 2 files"); */
! 1502: return;
! 1503: }
! 1504: /*
! 1505: * 1. close all but first window
! 1506: * 2. make the desired number of windows
! 1507: * 3. start editing in the windows
! 1508: */
! 1509: setpcmark();
! 1510: close_others(FALSE);
! 1511: curwin->w_arg_idx = 0;
! 1512: if (count > arg_count || count <= 0)
! 1513: count = arg_count;
! 1514: count = make_windows(count);
! 1515: for (i = 0; i < count; ++i)
! 1516: {
! 1517: /* edit file i */
! 1518: (void)do_ecmd(0, arg_files[i], NULL, NULL, TRUE, (linenr_t)1, FALSE);
! 1519: curwin->w_arg_idx = i;
! 1520: if (i == arg_count - 1)
! 1521: arg_had_last = TRUE;
! 1522: if (curwin->w_next == NULL) /* just checking */
! 1523: break;
! 1524: win_enter(curwin->w_next, FALSE);
! 1525: }
! 1526: win_enter(firstwin, FALSE); /* back to first window */
! 1527: }
! 1528:
! 1529: /*
! 1530: * do_arg_all: open a window for each buffer
! 1531: *
! 1532: * 'count' is the maximum number of windows to open.
! 1533: * when 'all' is TRUE, also load inactive buffers
! 1534: */
! 1535: void
! 1536: do_buffer_all(count, all)
! 1537: int count;
! 1538: int all;
! 1539: {
! 1540: int buf_count;
! 1541: BUF *buf;
! 1542: int i;
! 1543:
! 1544: /*
! 1545: * count number of desired windows
! 1546: */
! 1547: buf_count = 0;
! 1548: for (buf = firstbuf; buf != NULL; buf = buf->b_next)
! 1549: if (all || buf->b_ml.ml_mfp != NULL)
! 1550: ++buf_count;
! 1551:
! 1552: if (buf_count == 0) /* Cannot happen? */
! 1553: {
! 1554: EMSG("No relevant entries in buffer list");
! 1555: return;
! 1556: }
! 1557:
! 1558: /*
! 1559: * 1. close all but first window
! 1560: * 2. make the desired number of windows
! 1561: * 3. stuff commands to fill the windows
! 1562: */
! 1563: close_others(FALSE);
! 1564: curwin->w_arg_idx = 0;
! 1565: if (buf_count > count)
! 1566: buf_count = count;
! 1567: buf_count = make_windows(buf_count);
! 1568: buf = firstbuf;
! 1569: for (i = 0; i < buf_count; ++i)
! 1570: {
! 1571: for ( ; buf != NULL; buf = buf->b_next)
! 1572: if (all || buf->b_ml.ml_mfp != NULL)
! 1573: break;
! 1574: if (buf == NULL) /* Cannot happen? */
! 1575: break;
! 1576: if (i != 0)
! 1577: stuffReadbuff((char_u *)"\n\027\027:"); /* CTRL-W CTRL-W */
! 1578: stuffReadbuff((char_u *)":buf "); /* edit Nth buffer */
! 1579: stuffnumReadbuff((long)buf->b_fnum);
! 1580: buf = buf->b_next;
! 1581: }
! 1582: stuffReadbuff((char_u *)"\n100\027k"); /* back to first window */
! 1583: }
! 1584:
! 1585: /*
! 1586: * do_modelines() - process mode lines for the current file
! 1587: *
! 1588: * Returns immediately if the "ml" option isn't set.
! 1589: */
! 1590: static int chk_modeline __ARGS((linenr_t));
! 1591:
! 1592: void
! 1593: do_modelines()
! 1594: {
! 1595: linenr_t lnum;
! 1596: int nmlines;
! 1597:
! 1598: if (!curbuf->b_p_ml || (nmlines = (int)p_mls) == 0)
! 1599: return;
! 1600:
! 1601: for (lnum = 1; lnum <= curbuf->b_ml.ml_line_count && lnum <= nmlines;
! 1602: ++lnum)
! 1603: if (chk_modeline(lnum) == FAIL)
! 1604: nmlines = 0;
! 1605:
! 1606: for (lnum = curbuf->b_ml.ml_line_count; lnum > 0 && lnum > nmlines &&
! 1607: lnum > curbuf->b_ml.ml_line_count - nmlines; --lnum)
! 1608: if (chk_modeline(lnum) == FAIL)
! 1609: nmlines = 0;
! 1610: }
! 1611:
! 1612: /*
! 1613: * chk_modeline() - check a single line for a mode string
! 1614: * Return FAIL if an error encountered.
! 1615: */
! 1616: static int
! 1617: chk_modeline(lnum)
! 1618: linenr_t lnum;
! 1619: {
! 1620: register char_u *s;
! 1621: register char_u *e;
! 1622: char_u *linecopy; /* local copy of any modeline found */
! 1623: int prev;
! 1624: int end;
! 1625: int retval = OK;
! 1626: char_u *save_sourcing_name;
! 1627:
! 1628: prev = -1;
! 1629: for (s = ml_get(lnum); *s != NUL; ++s)
! 1630: {
! 1631: if (prev == -1 || vim_isspace(prev))
! 1632: {
! 1633: if ((prev != -1 && STRNCMP(s, "ex:", (size_t)3) == 0) ||
! 1634: STRNCMP(s, "vi:", (size_t)3) == 0 ||
! 1635: STRNCMP(s, "vim:", (size_t)4) == 0)
! 1636: break;
! 1637: }
! 1638: prev = *s;
! 1639: }
! 1640:
! 1641: if (*s)
! 1642: {
! 1643: do /* skip over "ex:", "vi:" or "vim:" */
! 1644: ++s;
! 1645: while (s[-1] != ':');
! 1646:
! 1647: s = linecopy = strsave(s); /* copy the line, it will change */
! 1648: if (linecopy == NULL)
! 1649: return FAIL;
! 1650:
! 1651: sourcing_lnum = lnum; /* prepare for emsg() */
! 1652: save_sourcing_name = sourcing_name;
! 1653: sourcing_name = (char_u *)"modelines";
! 1654:
! 1655: end = FALSE;
! 1656: while (end == FALSE)
! 1657: {
! 1658: s = skipwhite(s);
! 1659: if (*s == NUL)
! 1660: break;
! 1661:
! 1662: /*
! 1663: * Find end of set command: ':' or end of line.
! 1664: */
! 1665: for (e = s; (*e != ':' || *(e - 1) == '\\') && *e != NUL; ++e)
! 1666: ;
! 1667: if (*e == NUL)
! 1668: end = TRUE;
! 1669:
! 1670: /*
! 1671: * If there is a "set" command, require a terminating ':' and
! 1672: * ignore the stuff after the ':'.
! 1673: * "vi:set opt opt opt: foo" -- foo not interpreted
! 1674: * "vi:opt opt opt: foo" -- foo interpreted
! 1675: */
! 1676: if (STRNCMP(s, "set ", (size_t)4) == 0)
! 1677: {
! 1678: if (*e != ':') /* no terminating ':'? */
! 1679: break;
! 1680: end = TRUE;
! 1681: s += 4;
! 1682: }
! 1683:
! 1684: *e = NUL; /* truncate the set command */
! 1685: if (do_set(s) == FAIL) /* stop if error found */
! 1686: {
! 1687: retval = FAIL;
! 1688: break;
! 1689: }
! 1690: s = e + 1; /* advance to next part */
! 1691: }
! 1692:
! 1693: sourcing_lnum = 0;
! 1694: sourcing_name = save_sourcing_name;
! 1695:
! 1696: vim_free(linecopy);
! 1697: }
! 1698: return retval;
! 1699: }
![[BACK]](/icons/back.gif){kind=icon}
Return to buffer.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / vim