1 /* vi:set ts=8 sts=4 sw=4 noet: 2 * 3 * VIM - Vi IMproved by Bram Moolenaar 4 * 5 * Do ":help uganda" in Vim to read copying and usage conditions. 6 * Do ":help credits" in Vim to see a list of people who contributed. 7 * See README.txt for an overview of the Vim source code. 8 */ 9 10 /* 11 * session.c: session related functions 12 */ 13 14 #include "vim.h" 15 16 #if defined(FEAT_SESSION) || defined(PROTO) 17 18 static int did_lcd; // whether ":lcd" was produced for a session 19 20 /* 21 * Write a file name to the session file. 22 * Takes care of the "slash" option in 'sessionoptions' and escapes special 23 * characters. 24 * Returns FAIL if writing fails or out of memory. 25 */ 26 static int 27 ses_put_fname(FILE *fd, char_u *name, unsigned *flagp) 28 { 29 char_u *sname; 30 char_u *p; 31 int retval = OK; 32 33 sname = home_replace_save(NULL, name); 34 if (sname == NULL) 35 return FAIL; 36 37 if (*flagp & SSOP_SLASH) 38 { 39 // change all backslashes to forward slashes 40 for (p = sname; *p != NUL; MB_PTR_ADV(p)) 41 if (*p == '\\') 42 *p = '/'; 43 } 44 45 // escape special characters 46 p = vim_strsave_fnameescape(sname, FALSE); 47 vim_free(sname); 48 if (p == NULL) 49 return FAIL; 50 51 // write the result 52 if (fputs((char *)p, fd) < 0) 53 retval = FAIL; 54 55 vim_free(p); 56 return retval; 57 } 58 59 /* 60 * Write a buffer name to the session file. 61 * Also ends the line, if "add_eol" is TRUE. 62 * Returns FAIL if writing fails. 63 */ 64 static int 65 ses_fname(FILE *fd, buf_T *buf, unsigned *flagp, int add_eol) 66 { 67 char_u *name; 68 69 // Use the short file name if the current directory is known at the time 70 // the session file will be sourced. 71 // Don't do this for ":mkview", we don't know the current directory. 72 // Don't do this after ":lcd", we don't keep track of what the current 73 // directory is. 74 if (buf->b_sfname != NULL 75 && flagp == &ssop_flags 76 && (ssop_flags & (SSOP_CURDIR | SSOP_SESDIR)) 77 #ifdef FEAT_AUTOCHDIR 78 && !p_acd 79 #endif 80 && !did_lcd) 81 name = buf->b_sfname; 82 else 83 name = buf->b_ffname; 84 if (ses_put_fname(fd, name, flagp) == FAIL 85 || (add_eol && put_eol(fd) == FAIL)) 86 return FAIL; 87 return OK; 88 } 89 90 /* 91 * Write an argument list to the session file. 92 * Returns FAIL if writing fails. 93 */ 94 static int 95 ses_arglist( 96 FILE *fd, 97 char *cmd, 98 garray_T *gap, 99 int fullname, // TRUE: use full path name 100 unsigned *flagp) 101 { 102 int i; 103 char_u *buf = NULL; 104 char_u *s; 105 106 if (fputs(cmd, fd) < 0 || put_eol(fd) == FAIL) 107 return FAIL; 108 if (put_line(fd, "%argdel") == FAIL) 109 return FAIL; 110 for (i = 0; i < gap->ga_len; ++i) 111 { 112 // NULL file names are skipped (only happens when out of memory). 113 s = alist_name(&((aentry_T *)gap->ga_data)[i]); 114 if (s != NULL) 115 { 116 if (fullname) 117 { 118 buf = alloc(MAXPATHL); 119 if (buf != NULL) 120 { 121 (void)vim_FullName(s, buf, MAXPATHL, FALSE); 122 s = buf; 123 } 124 } 125 if (fputs("$argadd ", fd) < 0 126 || ses_put_fname(fd, s, flagp) == FAIL 127 || put_eol(fd) == FAIL) 128 { 129 vim_free(buf); 130 return FAIL; 131 } 132 vim_free(buf); 133 } 134 } 135 return OK; 136 } 137 138 /* 139 * Return non-zero if window "wp" is to be stored in the Session. 140 */ 141 static int 142 ses_do_win(win_T *wp) 143 { 144 #ifdef FEAT_TERMINAL 145 if (bt_terminal(wp->w_buffer)) 146 return !term_is_finished(wp->w_buffer) 147 && (ssop_flags & SSOP_TERMINAL) 148 && term_should_restore(wp->w_buffer); 149 #endif 150 if (wp->w_buffer->b_fname == NULL 151 #ifdef FEAT_QUICKFIX 152 // When 'buftype' is "nofile" can't restore the window contents. 153 || bt_nofilename(wp->w_buffer) 154 #endif 155 ) 156 return (ssop_flags & SSOP_BLANK); 157 if (bt_help(wp->w_buffer)) 158 return (ssop_flags & SSOP_HELP); 159 return TRUE; 160 } 161 162 /* 163 * Return TRUE if frame "fr" has a window somewhere that we want to save in 164 * the Session. 165 */ 166 static int 167 ses_do_frame(frame_T *fr) 168 { 169 frame_T *frc; 170 171 if (fr->fr_layout == FR_LEAF) 172 return ses_do_win(fr->fr_win); 173 FOR_ALL_FRAMES(frc, fr->fr_child) 174 if (ses_do_frame(frc)) 175 return TRUE; 176 return FALSE; 177 } 178 179 /* 180 * Skip frames that don't contain windows we want to save in the Session. 181 * Returns NULL when there none. 182 */ 183 static frame_T * 184 ses_skipframe(frame_T *fr) 185 { 186 frame_T *frc; 187 188 FOR_ALL_FRAMES(frc, fr) 189 if (ses_do_frame(frc)) 190 break; 191 return frc; 192 } 193 194 /* 195 * Write commands to "fd" to recursively create windows for frame "fr", 196 * horizontally and vertically split. 197 * After the commands the last window in the frame is the current window. 198 * Returns FAIL when writing the commands to "fd" fails. 199 */ 200 static int 201 ses_win_rec(FILE *fd, frame_T *fr) 202 { 203 frame_T *frc; 204 int count = 0; 205 206 if (fr->fr_layout != FR_LEAF) 207 { 208 // Find first frame that's not skipped and then create a window for 209 // each following one (first frame is already there). 210 frc = ses_skipframe(fr->fr_child); 211 if (frc != NULL) 212 while ((frc = ses_skipframe(frc->fr_next)) != NULL) 213 { 214 // Make window as big as possible so that we have lots of room 215 // to split. 216 if (put_line(fd, "wincmd _ | wincmd |") == FAIL 217 || put_line(fd, fr->fr_layout == FR_COL 218 ? "split" : "vsplit") == FAIL) 219 return FAIL; 220 ++count; 221 } 222 223 // Go back to the first window. 224 if (count > 0 && (fprintf(fd, fr->fr_layout == FR_COL 225 ? "%dwincmd k" : "%dwincmd h", count) < 0 226 || put_eol(fd) == FAIL)) 227 return FAIL; 228 229 // Recursively create frames/windows in each window of this column or 230 // row. 231 frc = ses_skipframe(fr->fr_child); 232 while (frc != NULL) 233 { 234 ses_win_rec(fd, frc); 235 frc = ses_skipframe(frc->fr_next); 236 // Go to next window. 237 if (frc != NULL && put_line(fd, "wincmd w") == FAIL) 238 return FAIL; 239 } 240 } 241 return OK; 242 } 243 244 static int 245 ses_winsizes( 246 FILE *fd, 247 int restore_size, 248 win_T *tab_firstwin) 249 { 250 int n = 0; 251 win_T *wp; 252 253 if (restore_size && (ssop_flags & SSOP_WINSIZE)) 254 { 255 for (wp = tab_firstwin; wp != NULL; wp = wp->w_next) 256 { 257 if (!ses_do_win(wp)) 258 continue; 259 ++n; 260 261 // restore height when not full height 262 if (wp->w_height + wp->w_status_height < topframe->fr_height 263 && (fprintf(fd, 264 "exe '%dresize ' . ((&lines * %ld + %ld) / %ld)", 265 n, (long)wp->w_height, Rows / 2, Rows) < 0 266 || put_eol(fd) == FAIL)) 267 return FAIL; 268 269 // restore width when not full width 270 if (wp->w_width < Columns && (fprintf(fd, 271 "exe 'vert %dresize ' . ((&columns * %ld + %ld) / %ld)", 272 n, (long)wp->w_width, Columns / 2, Columns) < 0 273 || put_eol(fd) == FAIL)) 274 return FAIL; 275 } 276 } 277 else 278 { 279 // Just equalise window sizes 280 if (put_line(fd, "wincmd =") == FAIL) 281 return FAIL; 282 } 283 return OK; 284 } 285 286 static int 287 put_view_curpos(FILE *fd, win_T *wp, char *spaces) 288 { 289 int r; 290 291 if (wp->w_curswant == MAXCOL) 292 r = fprintf(fd, "%snormal! $", spaces); 293 else 294 r = fprintf(fd, "%snormal! 0%d|", spaces, wp->w_virtcol + 1); 295 return r < 0 || put_eol(fd) == FAIL ? FALSE : OK; 296 } 297 298 /* 299 * Write commands to "fd" to restore the view of a window. 300 * Caller must make sure 'scrolloff' is zero. 301 */ 302 static int 303 put_view( 304 FILE *fd, 305 win_T *wp, 306 int add_edit, // add ":edit" command to view 307 unsigned *flagp, // vop_flags or ssop_flags 308 int current_arg_idx, // current argument index of the window, 309 // use -1 if unknown 310 hashtab_T *terminal_bufs UNUSED) // already encountered terminal buffers, 311 // can be NULL 312 { 313 win_T *save_curwin; 314 int f; 315 int do_cursor; 316 int did_next = FALSE; 317 318 // Always restore cursor position for ":mksession". For ":mkview" only 319 // when 'viewoptions' contains "cursor". 320 do_cursor = (flagp == &ssop_flags || *flagp & SSOP_CURSOR); 321 322 // Local argument list. 323 if (wp->w_alist == &global_alist) 324 { 325 if (put_line(fd, "argglobal") == FAIL) 326 return FAIL; 327 } 328 else 329 { 330 if (ses_arglist(fd, "arglocal", &wp->w_alist->al_ga, 331 flagp == &vop_flags 332 || !(*flagp & SSOP_CURDIR) 333 || wp->w_localdir != NULL, flagp) == FAIL) 334 return FAIL; 335 } 336 337 // Only when part of a session: restore the argument index. Some 338 // arguments may have been deleted, check if the index is valid. 339 if (wp->w_arg_idx != current_arg_idx && wp->w_arg_idx < WARGCOUNT(wp) 340 && flagp == &ssop_flags) 341 { 342 if (fprintf(fd, "%ldargu", (long)wp->w_arg_idx + 1) < 0 343 || put_eol(fd) == FAIL) 344 return FAIL; 345 did_next = TRUE; 346 } 347 348 // Edit the file. Skip this when ":next" already did it. 349 if (add_edit && (!did_next || wp->w_arg_idx_invalid)) 350 { 351 # ifdef FEAT_TERMINAL 352 if (bt_terminal(wp->w_buffer)) 353 { 354 if (term_write_session(fd, wp, terminal_bufs) == FAIL) 355 return FAIL; 356 } 357 else 358 # endif 359 // Load the file. 360 if (wp->w_buffer->b_ffname != NULL 361 # ifdef FEAT_QUICKFIX 362 && !bt_nofilename(wp->w_buffer) 363 # endif 364 ) 365 { 366 // Editing a file in this buffer: use ":edit file". 367 // This may have side effects! (e.g., compressed or network file). 368 // 369 // Note, if a buffer for that file already exists, use :badd to 370 // edit that buffer, to not lose folding information (:edit resets 371 // folds in other buffers) 372 if (fputs("if bufexists(\"", fd) < 0 373 || ses_fname(fd, wp->w_buffer, flagp, FALSE) == FAIL 374 || fputs("\") | buffer ", fd) < 0 375 || ses_fname(fd, wp->w_buffer, flagp, FALSE) == FAIL 376 || fputs(" | else | edit ", fd) < 0 377 || ses_fname(fd, wp->w_buffer, flagp, FALSE) == FAIL 378 || fputs(" | endif", fd) < 0 379 || put_eol(fd) == FAIL) 380 return FAIL; 381 } 382 else 383 { 384 // No file in this buffer, just make it empty. 385 if (put_line(fd, "enew") == FAIL) 386 return FAIL; 387 #ifdef FEAT_QUICKFIX 388 if (wp->w_buffer->b_ffname != NULL) 389 { 390 // The buffer does have a name, but it's not a file name. 391 if (fputs("file ", fd) < 0 392 || ses_fname(fd, wp->w_buffer, flagp, TRUE) == FAIL) 393 return FAIL; 394 } 395 #endif 396 do_cursor = FALSE; 397 } 398 } 399 400 // Local mappings and abbreviations. 401 if ((*flagp & (SSOP_OPTIONS | SSOP_LOCALOPTIONS)) 402 && makemap(fd, wp->w_buffer) == FAIL) 403 return FAIL; 404 405 // Local options. Need to go to the window temporarily. 406 // Store only local values when using ":mkview" and when ":mksession" is 407 // used and 'sessionoptions' doesn't include "options". 408 // Some folding options are always stored when "folds" is included, 409 // otherwise the folds would not be restored correctly. 410 save_curwin = curwin; 411 curwin = wp; 412 curbuf = curwin->w_buffer; 413 if (*flagp & (SSOP_OPTIONS | SSOP_LOCALOPTIONS)) 414 f = makeset(fd, OPT_LOCAL, 415 flagp == &vop_flags || !(*flagp & SSOP_OPTIONS)); 416 #ifdef FEAT_FOLDING 417 else if (*flagp & SSOP_FOLDS) 418 f = makefoldset(fd); 419 #endif 420 else 421 f = OK; 422 curwin = save_curwin; 423 curbuf = curwin->w_buffer; 424 if (f == FAIL) 425 return FAIL; 426 427 #ifdef FEAT_FOLDING 428 // Save Folds when 'buftype' is empty and for help files. 429 if ((*flagp & SSOP_FOLDS) 430 && wp->w_buffer->b_ffname != NULL 431 && (bt_normal(wp->w_buffer) || bt_help(wp->w_buffer))) 432 { 433 if (put_folds(fd, wp) == FAIL) 434 return FAIL; 435 } 436 #endif 437 438 // Set the cursor after creating folds, since that moves the cursor. 439 if (do_cursor) 440 { 441 442 // Restore the cursor line in the file and relatively in the 443 // window. Don't use "G", it changes the jumplist. 444 if (fprintf(fd, "let s:l = %ld - ((%ld * winheight(0) + %ld) / %ld)", 445 (long)wp->w_cursor.lnum, 446 (long)(wp->w_cursor.lnum - wp->w_topline), 447 (long)wp->w_height / 2, (long)wp->w_height) < 0 448 || put_eol(fd) == FAIL 449 || put_line(fd, "if s:l < 1 | let s:l = 1 | endif") == FAIL 450 || put_line(fd, "exe s:l") == FAIL 451 || put_line(fd, "normal! zt") == FAIL 452 || fprintf(fd, "%ld", (long)wp->w_cursor.lnum) < 0 453 || put_eol(fd) == FAIL) 454 return FAIL; 455 // Restore the cursor column and left offset when not wrapping. 456 if (wp->w_cursor.col == 0) 457 { 458 if (put_line(fd, "normal! 0") == FAIL) 459 return FAIL; 460 } 461 else 462 { 463 if (!wp->w_p_wrap && wp->w_leftcol > 0 && wp->w_width > 0) 464 { 465 if (fprintf(fd, 466 "let s:c = %ld - ((%ld * winwidth(0) + %ld) / %ld)", 467 (long)wp->w_virtcol + 1, 468 (long)(wp->w_virtcol - wp->w_leftcol), 469 (long)wp->w_width / 2, (long)wp->w_width) < 0 470 || put_eol(fd) == FAIL 471 || put_line(fd, "if s:c > 0") == FAIL 472 || fprintf(fd, 473 " exe 'normal! ' . s:c . '|zs' . %ld . '|'", 474 (long)wp->w_virtcol + 1) < 0 475 || put_eol(fd) == FAIL 476 || put_line(fd, "else") == FAIL 477 || put_view_curpos(fd, wp, " ") == FAIL 478 || put_line(fd, "endif") == FAIL) 479 return FAIL; 480 } 481 else if (put_view_curpos(fd, wp, "") == FAIL) 482 return FAIL; 483 } 484 } 485 486 // Local directory, if the current flag is not view options or the "curdir" 487 // option is included. 488 if (wp->w_localdir != NULL 489 && (flagp != &vop_flags || (*flagp & SSOP_CURDIR))) 490 { 491 if (fputs("lcd ", fd) < 0 492 || ses_put_fname(fd, wp->w_localdir, flagp) == FAIL 493 || put_eol(fd) == FAIL) 494 return FAIL; 495 did_lcd = TRUE; 496 } 497 498 return OK; 499 } 500 501 #ifdef FEAT_EVAL 502 static int 503 store_session_globals(FILE *fd) 504 { 505 hashtab_T *gvht = get_globvar_ht(); 506 hashitem_T *hi; 507 dictitem_T *this_var; 508 int todo; 509 char_u *p, *t; 510 511 todo = (int)gvht->ht_used; 512 for (hi = gvht->ht_array; todo > 0; ++hi) 513 { 514 if (!HASHITEM_EMPTY(hi)) 515 { 516 --todo; 517 this_var = HI2DI(hi); 518 if ((this_var->di_tv.v_type == VAR_NUMBER 519 || this_var->di_tv.v_type == VAR_STRING) 520 && var_flavour(this_var->di_key) == VAR_FLAVOUR_SESSION) 521 { 522 // Escape special characters with a backslash. Turn a LF and 523 // CR into \n and \r. 524 p = vim_strsave_escaped(tv_get_string(&this_var->di_tv), 525 (char_u *)"\\\"\n\r"); 526 if (p == NULL) // out of memory 527 break; 528 for (t = p; *t != NUL; ++t) 529 if (*t == '\n') 530 *t = 'n'; 531 else if (*t == '\r') 532 *t = 'r'; 533 if ((fprintf(fd, "let %s = %c%s%c", 534 this_var->di_key, 535 (this_var->di_tv.v_type == VAR_STRING) ? '"' 536 : ' ', 537 p, 538 (this_var->di_tv.v_type == VAR_STRING) ? '"' 539 : ' ') < 0) 540 || put_eol(fd) == FAIL) 541 { 542 vim_free(p); 543 return FAIL; 544 } 545 vim_free(p); 546 } 547 #ifdef FEAT_FLOAT 548 else if (this_var->di_tv.v_type == VAR_FLOAT 549 && var_flavour(this_var->di_key) == VAR_FLAVOUR_SESSION) 550 { 551 float_T f = this_var->di_tv.vval.v_float; 552 int sign = ' '; 553 554 if (f < 0) 555 { 556 f = -f; 557 sign = '-'; 558 } 559 if ((fprintf(fd, "let %s = %c%f", 560 this_var->di_key, sign, f) < 0) 561 || put_eol(fd) == FAIL) 562 return FAIL; 563 } 564 #endif 565 } 566 } 567 return OK; 568 } 569 #endif 570 571 /* 572 * Write openfile commands for the current buffers to an .exrc file. 573 * Return FAIL on error, OK otherwise. 574 */ 575 static int 576 makeopens( 577 FILE *fd, 578 char_u *dirnow) // Current directory name 579 { 580 buf_T *buf; 581 int only_save_windows = TRUE; 582 int nr; 583 int restore_size = TRUE; 584 win_T *wp; 585 char_u *sname; 586 win_T *edited_win = NULL; 587 int tabnr; 588 int restore_stal = FALSE; 589 win_T *tab_firstwin; 590 frame_T *tab_topframe; 591 int cur_arg_idx = 0; 592 int next_arg_idx = 0; 593 int ret = FAIL; 594 #ifdef FEAT_TERMINAL 595 hashtab_T terminal_bufs; 596 597 hash_init(&terminal_bufs); 598 #endif 599 600 if (ssop_flags & SSOP_BUFFERS) 601 only_save_windows = FALSE; // Save ALL buffers 602 603 // Begin by setting the this_session variable, and then other 604 // sessionable variables. 605 #ifdef FEAT_EVAL 606 if (put_line(fd, "let v:this_session=expand(\"<sfile>:p\")") == FAIL) 607 goto fail; 608 if (ssop_flags & SSOP_GLOBALS) 609 if (store_session_globals(fd) == FAIL) 610 goto fail; 611 #endif 612 613 // Close all windows and tabs but one. 614 if (put_line(fd, "silent only") == FAIL) 615 goto fail; 616 if ((ssop_flags & SSOP_TABPAGES) 617 && put_line(fd, "silent tabonly") == FAIL) 618 goto fail; 619 620 // Now a :cd command to the session directory or the current directory 621 if (ssop_flags & SSOP_SESDIR) 622 { 623 if (put_line(fd, "exe \"cd \" . escape(expand(\"<sfile>:p:h\"), ' ')") 624 == FAIL) 625 goto fail; 626 } 627 else if (ssop_flags & SSOP_CURDIR) 628 { 629 sname = home_replace_save(NULL, globaldir != NULL ? globaldir : dirnow); 630 if (sname == NULL 631 || fputs("cd ", fd) < 0 632 || ses_put_fname(fd, sname, &ssop_flags) == FAIL 633 || put_eol(fd) == FAIL) 634 { 635 vim_free(sname); 636 goto fail; 637 } 638 vim_free(sname); 639 } 640 641 // If there is an empty, unnamed buffer we will wipe it out later. 642 // Remember the buffer number. 643 if (put_line(fd, "if expand('%') == '' && !&modified && line('$') <= 1 && getline(1) == ''") == FAIL) 644 goto fail; 645 if (put_line(fd, " let s:wipebuf = bufnr('%')") == FAIL) 646 goto fail; 647 if (put_line(fd, "endif") == FAIL) 648 goto fail; 649 650 // Now save the current files, current buffer first. 651 if (put_line(fd, "set shortmess=aoO") == FAIL) 652 goto fail; 653 654 // the global argument list 655 if (ses_arglist(fd, "argglobal", &global_alist.al_ga, 656 !(ssop_flags & SSOP_CURDIR), &ssop_flags) == FAIL) 657 goto fail; 658 659 if (ssop_flags & SSOP_RESIZE) 660 { 661 // Note: after the restore we still check it worked! 662 if (fprintf(fd, "set lines=%ld columns=%ld" , Rows, Columns) < 0 663 || put_eol(fd) == FAIL) 664 goto fail; 665 } 666 667 #ifdef FEAT_GUI 668 if (gui.in_use && (ssop_flags & SSOP_WINPOS)) 669 { 670 int x, y; 671 672 if (gui_mch_get_winpos(&x, &y) == OK) 673 { 674 // Note: after the restore we still check it worked! 675 if (fprintf(fd, "winpos %d %d", x, y) < 0 || put_eol(fd) == FAIL) 676 goto fail; 677 } 678 } 679 #endif 680 681 // When there are two or more tabpages and 'showtabline' is 1 the tabline 682 // will be displayed when creating the next tab. That resizes the windows 683 // in the first tab, which may cause problems. Set 'showtabline' to 2 684 // temporarily to avoid that. 685 if (p_stal == 1 && first_tabpage->tp_next != NULL) 686 { 687 if (put_line(fd, "set stal=2") == FAIL) 688 goto fail; 689 restore_stal = TRUE; 690 } 691 692 // May repeat putting Windows for each tab, when "tabpages" is in 693 // 'sessionoptions'. 694 // Don't use goto_tabpage(), it may change directory and trigger 695 // autocommands. 696 tab_firstwin = firstwin; // first window in tab page "tabnr" 697 tab_topframe = topframe; 698 if ((ssop_flags & SSOP_TABPAGES)) 699 { 700 tabpage_T *tp; 701 702 // Similar to ses_win_rec() below, populate the tab pages first so 703 // later local options won't be copied to the new tabs. 704 FOR_ALL_TABPAGES(tp) 705 if (tp->tp_next != NULL && put_line(fd, "tabnew") == FAIL) 706 goto fail; 707 if (first_tabpage->tp_next != NULL && put_line(fd, "tabrewind") == FAIL) 708 goto fail; 709 } 710 for (tabnr = 1; ; ++tabnr) 711 { 712 tabpage_T *tp = NULL; 713 int need_tabnext = FALSE; 714 int cnr = 1; 715 716 if ((ssop_flags & SSOP_TABPAGES)) 717 { 718 tp = find_tabpage(tabnr); 719 720 if (tp == NULL) 721 break; // done all tab pages 722 if (tp == curtab) 723 { 724 tab_firstwin = firstwin; 725 tab_topframe = topframe; 726 } 727 else 728 { 729 tab_firstwin = tp->tp_firstwin; 730 tab_topframe = tp->tp_topframe; 731 } 732 if (tabnr > 1) 733 need_tabnext = TRUE; 734 } 735 736 // Before creating the window layout, try loading one file. If this 737 // is aborted we don't end up with a number of useless windows. 738 // This may have side effects! (e.g., compressed or network file). 739 for (wp = tab_firstwin; wp != NULL; wp = wp->w_next) 740 { 741 if (ses_do_win(wp) 742 && wp->w_buffer->b_ffname != NULL 743 && !bt_help(wp->w_buffer) 744 #ifdef FEAT_QUICKFIX 745 && !bt_nofilename(wp->w_buffer) 746 #endif 747 ) 748 { 749 if (need_tabnext && put_line(fd, "tabnext") == FAIL) 750 goto fail; 751 need_tabnext = FALSE; 752 753 if (fputs("edit ", fd) < 0 754 || ses_fname(fd, wp->w_buffer, &ssop_flags, TRUE) 755 == FAIL) 756 goto fail; 757 if (!wp->w_arg_idx_invalid) 758 edited_win = wp; 759 break; 760 } 761 } 762 763 // If no file got edited create an empty tab page. 764 if (need_tabnext && put_line(fd, "tabnext") == FAIL) 765 goto fail; 766 767 // Save current window layout. 768 if (put_line(fd, "set splitbelow splitright") == FAIL) 769 goto fail; 770 if (ses_win_rec(fd, tab_topframe) == FAIL) 771 goto fail; 772 if (!p_sb && put_line(fd, "set nosplitbelow") == FAIL) 773 goto fail; 774 if (!p_spr && put_line(fd, "set nosplitright") == FAIL) 775 goto fail; 776 777 // Check if window sizes can be restored (no windows omitted). 778 // Remember the window number of the current window after restoring. 779 nr = 0; 780 for (wp = tab_firstwin; wp != NULL; wp = W_NEXT(wp)) 781 { 782 if (ses_do_win(wp)) 783 ++nr; 784 else 785 restore_size = FALSE; 786 if (curwin == wp) 787 cnr = nr; 788 } 789 790 // Go to the first window. 791 if (put_line(fd, "wincmd t") == FAIL) 792 goto fail; 793 794 // If more than one window, see if sizes can be restored. 795 // First set 'winheight' and 'winwidth' to 1 to avoid the windows being 796 // resized when moving between windows. 797 // Do this before restoring the view, so that the topline and the 798 // cursor can be set. This is done again below. 799 // winminheight and winminwidth need to be set to avoid an error if the 800 // user has set winheight or winwidth. 801 if (put_line(fd, "set winminheight=0") == FAIL 802 || put_line(fd, "set winheight=1") == FAIL 803 || put_line(fd, "set winminwidth=0") == FAIL 804 || put_line(fd, "set winwidth=1") == FAIL) 805 goto fail; 806 if (nr > 1 && ses_winsizes(fd, restore_size, tab_firstwin) == FAIL) 807 goto fail; 808 809 // Restore the tab-local working directory if specified 810 // Do this before the windows, so that the window-local directory can 811 // override the tab-local directory. 812 if (tp != NULL && tp->tp_localdir != NULL && ssop_flags & SSOP_CURDIR) 813 { 814 if (fputs("tcd ", fd) < 0 815 || ses_put_fname(fd, tp->tp_localdir, &ssop_flags) == FAIL 816 || put_eol(fd) == FAIL) 817 goto fail; 818 did_lcd = TRUE; 819 } 820 821 // Restore the view of the window (options, file, cursor, etc.). 822 for (wp = tab_firstwin; wp != NULL; wp = wp->w_next) 823 { 824 if (!ses_do_win(wp)) 825 continue; 826 if (put_view(fd, wp, wp != edited_win, &ssop_flags, cur_arg_idx, 827 #ifdef FEAT_TERMINAL 828 &terminal_bufs 829 #else 830 NULL 831 #endif 832 ) == FAIL) 833 goto fail; 834 if (nr > 1 && put_line(fd, "wincmd w") == FAIL) 835 goto fail; 836 next_arg_idx = wp->w_arg_idx; 837 } 838 839 // The argument index in the first tab page is zero, need to set it in 840 // each window. For further tab pages it's the window where we do 841 // "tabedit". 842 cur_arg_idx = next_arg_idx; 843 844 // Restore cursor to the current window if it's not the first one. 845 if (cnr > 1 && (fprintf(fd, "%dwincmd w", cnr) < 0 846 || put_eol(fd) == FAIL)) 847 goto fail; 848 849 // Restore window sizes again after jumping around in windows, because 850 // the current window has a minimum size while others may not. 851 if (nr > 1 && ses_winsizes(fd, restore_size, tab_firstwin) == FAIL) 852 goto fail; 853 854 // Don't continue in another tab page when doing only the current one 855 // or when at the last tab page. 856 if (!(ssop_flags & SSOP_TABPAGES)) 857 break; 858 } 859 860 if (ssop_flags & SSOP_TABPAGES) 861 { 862 if (fprintf(fd, "tabnext %d", tabpage_index(curtab)) < 0 863 || put_eol(fd) == FAIL) 864 goto fail; 865 } 866 if (restore_stal && put_line(fd, "set stal=1") == FAIL) 867 goto fail; 868 869 // Now put the remaining buffers into the buffer list. 870 // This is near the end, so that when 'hidden' is set we don't create extra 871 // buffers. If the buffer was already created with another command the 872 // ":badd" will have no effect. 873 FOR_ALL_BUFFERS(buf) 874 { 875 if (!(only_save_windows && buf->b_nwindows == 0) 876 && !(buf->b_help && !(ssop_flags & SSOP_HELP)) 877 #ifdef FEAT_TERMINAL 878 // Skip terminal buffers: finished ones are not useful, others 879 // will be resurrected and result in a new buffer. 880 && !bt_terminal(buf) 881 #endif 882 && buf->b_fname != NULL 883 && buf->b_p_bl) 884 { 885 if (fprintf(fd, "badd +%ld ", buf->b_wininfo == NULL ? 1L 886 : buf->b_wininfo->wi_fpos.lnum) < 0 887 || ses_fname(fd, buf, &ssop_flags, TRUE) == FAIL) 888 goto fail; 889 } 890 } 891 892 // Wipe out an empty unnamed buffer we started in. 893 if (put_line(fd, "if exists('s:wipebuf') && len(win_findbuf(s:wipebuf)) == 0") 894 == FAIL) 895 goto fail; 896 if (put_line(fd, " silent exe 'bwipe ' . s:wipebuf") == FAIL) 897 goto fail; 898 if (put_line(fd, "endif") == FAIL) 899 goto fail; 900 if (put_line(fd, "unlet! s:wipebuf") == FAIL) 901 goto fail; 902 903 // Re-apply 'winheight', 'winwidth' and 'shortmess'. 904 if (fprintf(fd, "set winheight=%ld winwidth=%ld shortmess=%s", 905 p_wh, p_wiw, p_shm) < 0 || put_eol(fd) == FAIL) 906 goto fail; 907 // Re-apply 'winminheight' and 'winminwidth'. 908 if (fprintf(fd, "set winminheight=%ld winminwidth=%ld", 909 p_wmh, p_wmw) < 0 || put_eol(fd) == FAIL) 910 goto fail; 911 912 // Lastly, execute the x.vim file if it exists. 913 if (put_line(fd, "let s:sx = expand(\"<sfile>:p:r\").\"x.vim\"") == FAIL 914 || put_line(fd, "if filereadable(s:sx)") == FAIL 915 || put_line(fd, " exe \"source \" . fnameescape(s:sx)") == FAIL 916 || put_line(fd, "endif") == FAIL) 917 goto fail; 918 919 ret = OK; 920 fail: 921 #ifdef FEAT_TERMINAL 922 hash_clear_all(&terminal_bufs, 0); 923 #endif 924 return ret; 925 } 926 927 /* 928 * Get the name of the view file for the current buffer. 929 */ 930 static char_u * 931 get_view_file(int c) 932 { 933 int len = 0; 934 char_u *p, *s; 935 char_u *retval; 936 char_u *sname; 937 938 if (curbuf->b_ffname == NULL) 939 { 940 emsg(_(e_noname)); 941 return NULL; 942 } 943 sname = home_replace_save(NULL, curbuf->b_ffname); 944 if (sname == NULL) 945 return NULL; 946 947 // We want a file name without separators, because we're not going to make 948 // a directory. 949 // "normal" path separator -> "=+" 950 // "=" -> "==" 951 // ":" path separator -> "=-" 952 for (p = sname; *p; ++p) 953 if (*p == '=' || vim_ispathsep(*p)) 954 ++len; 955 retval = alloc(STRLEN(sname) + len + STRLEN(p_vdir) + 9); 956 if (retval != NULL) 957 { 958 STRCPY(retval, p_vdir); 959 add_pathsep(retval); 960 s = retval + STRLEN(retval); 961 for (p = sname; *p; ++p) 962 { 963 if (*p == '=') 964 { 965 *s++ = '='; 966 *s++ = '='; 967 } 968 else if (vim_ispathsep(*p)) 969 { 970 *s++ = '='; 971 #if defined(BACKSLASH_IN_FILENAME) || defined(AMIGA) || defined(VMS) 972 if (*p == ':') 973 *s++ = '-'; 974 else 975 #endif 976 *s++ = '+'; 977 } 978 else 979 *s++ = *p; 980 } 981 *s++ = '='; 982 *s++ = c; 983 STRCPY(s, ".vim"); 984 } 985 986 vim_free(sname); 987 return retval; 988 } 989 990 /* 991 * ":loadview [nr]" 992 */ 993 void 994 ex_loadview(exarg_T *eap) 995 { 996 char_u *fname; 997 998 fname = get_view_file(*eap->arg); 999 if (fname != NULL) 1000 { 1001 do_source(fname, FALSE, DOSO_NONE, NULL); 1002 vim_free(fname); 1003 } 1004 } 1005 1006 # if defined(FEAT_GUI_GNOME) \ 1007 || (defined(GUI_MAY_SPAWN) && defined(EXPERIMENTAL_GUI_CMD)) \ 1008 || defined(PROTO) 1009 /* 1010 * Generate a script that can be used to restore the current editing session. 1011 * Save the value of v:this_session before running :mksession in order to make 1012 * automagic session save fully transparent. Return TRUE on success. 1013 */ 1014 int 1015 write_session_file(char_u *filename) 1016 { 1017 char_u *escaped_filename; 1018 char *mksession_cmdline; 1019 unsigned int save_ssop_flags; 1020 int failed; 1021 1022 // Build an ex command line to create a script that restores the current 1023 // session if executed. Escape the filename to avoid nasty surprises. 1024 escaped_filename = vim_strsave_escaped(filename, escape_chars); 1025 if (escaped_filename == NULL) 1026 return FALSE; 1027 mksession_cmdline = alloc(10 + (int)STRLEN(escaped_filename) + 1); 1028 if (mksession_cmdline == NULL) 1029 { 1030 vim_free(escaped_filename); 1031 return FALSE; 1032 } 1033 strcpy(mksession_cmdline, "mksession "); 1034 STRCAT(mksession_cmdline, escaped_filename); 1035 vim_free(escaped_filename); 1036 1037 // Use a reasonable hardcoded set of 'sessionoptions' flags to avoid 1038 // unpredictable effects when the session is saved automatically. Also, 1039 // we definitely need SSOP_GLOBALS to be able to restore v:this_session. 1040 // Don't use SSOP_BUFFERS to prevent the buffer list from becoming 1041 // enormously large if the GNOME session feature is used regularly. 1042 save_ssop_flags = ssop_flags; 1043 ssop_flags = (SSOP_BLANK|SSOP_CURDIR|SSOP_FOLDS|SSOP_GLOBALS 1044 |SSOP_HELP|SSOP_OPTIONS|SSOP_WINSIZE|SSOP_TABPAGES); 1045 1046 do_cmdline_cmd((char_u *)"let Save_VV_this_session = v:this_session"); 1047 failed = (do_cmdline_cmd((char_u *)mksession_cmdline) == FAIL); 1048 do_cmdline_cmd((char_u *)"let v:this_session = Save_VV_this_session"); 1049 do_unlet((char_u *)"Save_VV_this_session", TRUE); 1050 1051 ssop_flags = save_ssop_flags; 1052 vim_free(mksession_cmdline); 1053 1054 // Reopen the file and append a command to restore v:this_session, 1055 // as if this save never happened. This is to avoid conflicts with 1056 // the user's own sessions. FIXME: It's probably less hackish to add 1057 // a "stealth" flag to 'sessionoptions' -- gotta ask Bram. 1058 if (!failed) 1059 { 1060 FILE *fd; 1061 1062 fd = open_exfile(filename, TRUE, APPENDBIN); 1063 1064 failed = (fd == NULL 1065 || put_line(fd, "let v:this_session = Save_VV_this_session") 1066 == FAIL 1067 || put_line(fd, "unlet Save_VV_this_session") == FAIL); 1068 1069 if (fd != NULL && fclose(fd) != 0) 1070 failed = TRUE; 1071 1072 if (failed) 1073 mch_remove(filename); 1074 } 1075 1076 return !failed; 1077 } 1078 # endif 1079 1080 #endif // FEAT_SESSION 1081 1082 #if defined(FEAT_SESSION) && defined(USE_CRNL) 1083 # define MKSESSION_NL 1084 static int mksession_nl = FALSE; // use NL only in put_eol() 1085 #endif 1086 1087 /* 1088 * ":mkexrc", ":mkvimrc", ":mkview" and ":mksession". 1089 */ 1090 void 1091 ex_mkrc(exarg_T *eap) 1092 { 1093 FILE *fd; 1094 int failed = FALSE; 1095 char_u *fname; 1096 #ifdef FEAT_BROWSE 1097 char_u *browseFile = NULL; 1098 #endif 1099 #ifdef FEAT_SESSION 1100 int view_session = FALSE; 1101 int using_vdir = FALSE; // using 'viewdir'? 1102 char_u *viewFile = NULL; 1103 unsigned *flagp; 1104 #endif 1105 1106 if (eap->cmdidx == CMD_mksession || eap->cmdidx == CMD_mkview) 1107 { 1108 #ifdef FEAT_SESSION 1109 view_session = TRUE; 1110 #else 1111 ex_ni(eap); 1112 return; 1113 #endif 1114 } 1115 1116 #ifdef FEAT_SESSION 1117 // Use the short file name until ":lcd" is used. We also don't use the 1118 // short file name when 'acd' is set, that is checked later. 1119 did_lcd = FALSE; 1120 1121 // ":mkview" or ":mkview 9": generate file name with 'viewdir' 1122 if (eap->cmdidx == CMD_mkview 1123 && (*eap->arg == NUL 1124 || (vim_isdigit(*eap->arg) && eap->arg[1] == NUL))) 1125 { 1126 eap->forceit = TRUE; 1127 fname = get_view_file(*eap->arg); 1128 if (fname == NULL) 1129 return; 1130 viewFile = fname; 1131 using_vdir = TRUE; 1132 } 1133 else 1134 #endif 1135 if (*eap->arg != NUL) 1136 fname = eap->arg; 1137 else if (eap->cmdidx == CMD_mkvimrc) 1138 fname = (char_u *)VIMRC_FILE; 1139 #ifdef FEAT_SESSION 1140 else if (eap->cmdidx == CMD_mksession) 1141 fname = (char_u *)SESSION_FILE; 1142 #endif 1143 else 1144 fname = (char_u *)EXRC_FILE; 1145 1146 #ifdef FEAT_BROWSE 1147 if (cmdmod.cmod_flags & CMOD_BROWSE) 1148 { 1149 browseFile = do_browse(BROWSE_SAVE, 1150 # ifdef FEAT_SESSION 1151 eap->cmdidx == CMD_mkview ? (char_u *)_("Save View") : 1152 eap->cmdidx == CMD_mksession ? (char_u *)_("Save Session") : 1153 # endif 1154 (char_u *)_("Save Setup"), 1155 fname, (char_u *)"vim", NULL, 1156 (char_u *)_(BROWSE_FILTER_MACROS), NULL); 1157 if (browseFile == NULL) 1158 goto theend; 1159 fname = browseFile; 1160 eap->forceit = TRUE; // since dialog already asked 1161 } 1162 #endif 1163 1164 #if defined(FEAT_SESSION) && defined(vim_mkdir) 1165 // When using 'viewdir' may have to create the directory. 1166 if (using_vdir && !mch_isdir(p_vdir)) 1167 vim_mkdir_emsg(p_vdir, 0755); 1168 #endif 1169 1170 fd = open_exfile(fname, eap->forceit, WRITEBIN); 1171 if (fd != NULL) 1172 { 1173 #ifdef FEAT_SESSION 1174 if (eap->cmdidx == CMD_mkview) 1175 flagp = &vop_flags; 1176 else 1177 flagp = &ssop_flags; 1178 #endif 1179 1180 #ifdef MKSESSION_NL 1181 // "unix" in 'sessionoptions': use NL line separator 1182 if (view_session && (*flagp & SSOP_UNIX)) 1183 mksession_nl = TRUE; 1184 #endif 1185 1186 // Write the version command for :mkvimrc 1187 if (eap->cmdidx == CMD_mkvimrc) 1188 (void)put_line(fd, "version 6.0"); 1189 1190 #ifdef FEAT_SESSION 1191 if (eap->cmdidx == CMD_mksession) 1192 { 1193 if (put_line(fd, "let SessionLoad = 1") == FAIL) 1194 failed = TRUE; 1195 } 1196 1197 if (eap->cmdidx != CMD_mkview) 1198 #endif 1199 { 1200 // Write setting 'compatible' first, because it has side effects. 1201 // For that same reason only do it when needed. 1202 if (p_cp) 1203 (void)put_line(fd, "if !&cp | set cp | endif"); 1204 else 1205 (void)put_line(fd, "if &cp | set nocp | endif"); 1206 } 1207 1208 #ifdef FEAT_SESSION 1209 if (!view_session 1210 || (eap->cmdidx == CMD_mksession 1211 && (*flagp & SSOP_OPTIONS))) 1212 #endif 1213 failed |= (makemap(fd, NULL) == FAIL 1214 || makeset(fd, OPT_GLOBAL, FALSE) == FAIL); 1215 1216 #ifdef FEAT_SESSION 1217 if (!failed && view_session) 1218 { 1219 if (put_line(fd, "let s:so_save = &so | let s:siso_save = &siso | set so=0 siso=0") == FAIL) 1220 failed = TRUE; 1221 if (eap->cmdidx == CMD_mksession) 1222 { 1223 char_u *dirnow; // current directory 1224 1225 dirnow = alloc(MAXPATHL); 1226 if (dirnow == NULL) 1227 failed = TRUE; 1228 else 1229 { 1230 // Change to session file's dir. 1231 if (mch_dirname(dirnow, MAXPATHL) == FAIL 1232 || mch_chdir((char *)dirnow) != 0) 1233 *dirnow = NUL; 1234 if (*dirnow != NUL && (ssop_flags & SSOP_SESDIR)) 1235 { 1236 if (vim_chdirfile(fname, NULL) == OK) 1237 shorten_fnames(TRUE); 1238 } 1239 else if (*dirnow != NUL 1240 && (ssop_flags & SSOP_CURDIR) && globaldir != NULL) 1241 { 1242 if (mch_chdir((char *)globaldir) == 0) 1243 shorten_fnames(TRUE); 1244 } 1245 1246 failed |= (makeopens(fd, dirnow) == FAIL); 1247 1248 // restore original dir 1249 if (*dirnow != NUL && ((ssop_flags & SSOP_SESDIR) 1250 || ((ssop_flags & SSOP_CURDIR) && globaldir != NULL))) 1251 { 1252 if (mch_chdir((char *)dirnow) != 0) 1253 emsg(_(e_prev_dir)); 1254 shorten_fnames(TRUE); 1255 } 1256 vim_free(dirnow); 1257 } 1258 } 1259 else 1260 { 1261 failed |= (put_view(fd, curwin, !using_vdir, flagp, -1, NULL) 1262 == FAIL); 1263 } 1264 if (put_line(fd, "let &so = s:so_save | let &siso = s:siso_save") 1265 == FAIL) 1266 failed = TRUE; 1267 #ifdef FEAT_SEARCH_EXTRA 1268 if (no_hlsearch && put_line(fd, "nohlsearch") == FAIL) 1269 failed = TRUE; 1270 #endif 1271 if (put_line(fd, "doautoall SessionLoadPost") == FAIL) 1272 failed = TRUE; 1273 if (eap->cmdidx == CMD_mksession) 1274 { 1275 if (put_line(fd, "unlet SessionLoad") == FAIL) 1276 failed = TRUE; 1277 } 1278 } 1279 #endif 1280 if (put_line(fd, "\" vim: set ft=vim :") == FAIL) 1281 failed = TRUE; 1282 1283 failed |= fclose(fd); 1284 1285 if (failed) 1286 emsg(_(e_write)); 1287 #if defined(FEAT_SESSION) 1288 else if (eap->cmdidx == CMD_mksession) 1289 { 1290 // successful session write - set this_session var 1291 char_u *tbuf; 1292 1293 tbuf = alloc(MAXPATHL); 1294 if (tbuf != NULL) 1295 { 1296 if (vim_FullName(fname, tbuf, MAXPATHL, FALSE) == OK) 1297 set_vim_var_string(VV_THIS_SESSION, tbuf, -1); 1298 vim_free(tbuf); 1299 } 1300 } 1301 #endif 1302 #ifdef MKSESSION_NL 1303 mksession_nl = FALSE; 1304 #endif 1305 } 1306 1307 #ifdef FEAT_BROWSE 1308 theend: 1309 vim_free(browseFile); 1310 #endif 1311 #ifdef FEAT_SESSION 1312 vim_free(viewFile); 1313 #endif 1314 } 1315 1316 #if (defined(FEAT_VIMINFO) || defined(FEAT_SESSION)) || defined(PROTO) 1317 var_flavour_T 1318 var_flavour(char_u *varname) 1319 { 1320 char_u *p = varname; 1321 1322 if (ASCII_ISUPPER(*p)) 1323 { 1324 while (*(++p)) 1325 if (ASCII_ISLOWER(*p)) 1326 return VAR_FLAVOUR_SESSION; 1327 return VAR_FLAVOUR_VIMINFO; 1328 } 1329 else 1330 return VAR_FLAVOUR_DEFAULT; 1331 } 1332 #endif 1333 1334 /* 1335 * Write end-of-line character(s) for ":mkexrc", ":mkvimrc" and ":mksession". 1336 * Return FAIL for a write error. 1337 */ 1338 int 1339 put_eol(FILE *fd) 1340 { 1341 if ( 1342 #ifdef USE_CRNL 1343 ( 1344 # ifdef MKSESSION_NL 1345 !mksession_nl && 1346 # endif 1347 (putc('\r', fd) < 0)) || 1348 #endif 1349 (putc('\n', fd) < 0)) 1350 return FAIL; 1351 return OK; 1352 } 1353 1354 /* 1355 * Write a line to "fd". 1356 * Return FAIL for a write error. 1357 */ 1358 int 1359 put_line(FILE *fd, char *s) 1360 { 1361 if (fputs(s, fd) < 0 || put_eol(fd) == FAIL) 1362 return FAIL; 1363 return OK; 1364 } 1365