// Functions for creating a session file, i.e. implementing:
//   :mkexrc
//   :mkvimrc
//   :mkview
//   :mksession

#include <inttypes.h>
#include <stdbool.h>
#include <stdio.h>
#include <string.h>

#include "klib/kvec.h"
#include "nvim/arglist.h"
#include "nvim/arglist_defs.h"
#include "nvim/ascii_defs.h"
#include "nvim/autocmd.h"
#include "nvim/autocmd_defs.h"
#include "nvim/buffer.h"
#include "nvim/buffer_defs.h"
#include "nvim/errors.h"
#include "nvim/eval.h"
#include "nvim/eval/typval.h"
#include "nvim/eval/typval_defs.h"
#include "nvim/eval/vars.h"
#include "nvim/ex_cmds_defs.h"
#include "nvim/ex_docmd.h"
#include "nvim/ex_getln.h"
#include "nvim/ex_session.h"
#include "nvim/file_search.h"
#include "nvim/fileio.h"
#include "nvim/fold.h"
#include "nvim/garray_defs.h"
#include "nvim/gettext_defs.h"
#include "nvim/globals.h"
#include "nvim/macros_defs.h"
#include "nvim/mapping.h"
#include "nvim/mbyte.h"
#include "nvim/memory.h"
#include "nvim/message.h"
#include "nvim/option.h"
#include "nvim/option_vars.h"
#include "nvim/os/fs.h"
#include "nvim/os/os.h"
#include "nvim/os/os_defs.h"
#include "nvim/path.h"
#include "nvim/pos_defs.h"
#include "nvim/runtime.h"
#include "nvim/strings.h"
#include "nvim/types_defs.h"
#include "nvim/vim_defs.h"
#include "nvim/window.h"

#include "ex_session.c.generated.h"

/// Whether ":lcd" or ":tcd" was produced for a session.
static int did_lcd;

#define PUTLINE_FAIL(s) \
  do { if (FAIL == put_line(fd, (s))) { return FAIL; } } while (0)

static int put_view_curpos(FILE *fd, const win_T *wp, char *spaces)
{
  int r;

  if (wp->w_curswant == MAXCOL) {
    r = fprintf(fd, "%snormal! $\n", spaces);
  } else {
    r = fprintf(fd, "%snormal! 0%d|\n", spaces, wp->w_virtcol + 1);
  }
  return r >= 0;
}

static int ses_winsizes(FILE *fd, bool restore_size, win_T *tab_firstwin)
{
  if (restore_size && (ssop_flags & kOptSsopFlagWinsize)) {
    int n = 0;
    for (win_T *wp = tab_firstwin; wp != NULL; wp = wp->w_next) {
      if (!ses_do_win(wp)) {
        continue;
      }
      n++;

      // restore height when not full height
      if (wp->w_height + wp->w_hsep_height + wp->w_status_height < topframe->fr_height
          && (fprintf(fd,
                      "exe '%dresize ' . ((&lines * %" PRId64
                      " + %" PRId64 ") / %" PRId64 ")\n",
                      n, (int64_t)wp->w_height,
                      (int64_t)Rows / 2, (int64_t)Rows) < 0)) {
        return FAIL;
      }

      // restore width when not full width
      if (wp->w_width < Columns
          && (fprintf(fd,
                      "exe 'vert %dresize ' . ((&columns * %" PRId64
                      " + %" PRId64 ") / %" PRId64 ")\n",
                      n, (int64_t)wp->w_width, (int64_t)Columns / 2,
                      (int64_t)Columns) < 0)) {
        return FAIL;
      }
    }
  } else {
    // Just equalize window sizes.
    PUTLINE_FAIL("wincmd =");
  }
  return OK;
}

/// Write commands to "fd" to recursively create windows for frame "fr",
/// horizontally and vertically split.
/// After the commands the last window in the frame is the current window.
///
/// @return  FAIL when writing the commands to "fd" fails.
static int ses_win_rec(FILE *fd, frame_T *fr)
{
  int count = 0;

  if (fr->fr_layout == FR_LEAF) {
    return OK;
  }

  // Find first frame that's not skipped and then create a window for
  // each following one (first frame is already there).
  frame_T *frc = ses_skipframe(fr->fr_child);
  if (frc != NULL) {
    while ((frc = ses_skipframe(frc->fr_next)) != NULL) {
      // Make window as big as possible so that we have lots of room
      // to split.
      if (fprintf(fd, "%s%s",
                  "wincmd _ | wincmd |\n",
                  (fr->fr_layout == FR_COL ? "split\n" : "vsplit\n")) < 0) {
        return FAIL;
      }
      count++;
    }
  }

  // Go back to the first window.
  if (count > 0 && (fprintf(fd, fr->fr_layout == FR_COL
                            ? "%dwincmd k\n" : "%dwincmd h\n", count) < 0)) {
    return FAIL;
  }

  // Recursively create frames/windows in each window of this column or row.
  frc = ses_skipframe(fr->fr_child);
  while (frc != NULL) {
    ses_win_rec(fd, frc);
    frc = ses_skipframe(frc->fr_next);
    // Go to next window.
    if (frc != NULL && put_line(fd, "wincmd w") == FAIL) {
      return FAIL;
    }
  }

  return OK;
}

/// Skip frames that don't contain windows we want to save in the Session.
///
/// @return  NULL when there none.
static frame_T *ses_skipframe(frame_T *fr)
{
  frame_T *frc;

  FOR_ALL_FRAMES(frc, fr) {
    if (ses_do_frame(frc)) {
      break;
    }
  }
  return frc;
}

/// @return  true if frame "fr" has a window somewhere that we want to save in
///          the Session.
static bool ses_do_frame(const frame_T *fr)
  FUNC_ATTR_NONNULL_ARG(1)
{
  const frame_T *frc;

  if (fr->fr_layout == FR_LEAF) {
    return ses_do_win(fr->fr_win);
  }
  FOR_ALL_FRAMES(frc, fr->fr_child) {
    if (ses_do_frame(frc)) {
      return true;
    }
  }
  return false;
}

/// @return  non-zero if window "wp" is to be stored in the Session.
static int ses_do_win(win_T *wp)
{
  // Skip floating windows to avoid issues when restoring the Session. #18432
  if (wp->w_floating) {
    return false;
  }
  if (wp->w_buffer->b_fname == NULL
      // When 'buftype' is "nofile" can't restore the window contents.
      || (!wp->w_buffer->terminal && bt_nofilename(wp->w_buffer))) {
    return ssop_flags & kOptSsopFlagBlank;
  }
  if (bt_help(wp->w_buffer)) {
    return ssop_flags & kOptSsopFlagHelp;
  }
  if (bt_terminal(wp->w_buffer)) {
    return ssop_flags & kOptSsopFlagTerminal;
  }
  return true;
}

/// Writes an :argument list to the session file.
///
/// @param fd
/// @param cmd
/// @param gap
/// @param fullname  true: use full path name
/// @param flagp
///
/// @returns FAIL if writing fails.
static int ses_arglist(FILE *fd, char *cmd, garray_T *gap, bool fullname, unsigned *flagp)
{
  char *buf = NULL;

  if (fprintf(fd, "%s\n%s\n", cmd, "%argdel") < 0) {
    return FAIL;
  }
  for (int i = 0; i < gap->ga_len; i++) {
    // NULL file names are skipped (only happens when out of memory).
    char *s = alist_name(&((aentry_T *)gap->ga_data)[i]);
    if (s != NULL) {
      if (fullname) {
        buf = xmalloc(MAXPATHL);
        vim_FullName(s, buf, MAXPATHL, false);
        s = buf;
      }
      char *fname_esc = ses_escape_fname(s, flagp);
      if (fprintf(fd, "$argadd %s\n", fname_esc) < 0) {
        xfree(fname_esc);
        xfree(buf);
        return FAIL;
      }
      xfree(fname_esc);
      xfree(buf);
    }
  }
  return OK;
}

/// @return  the buffer name for `buf`.
static char *ses_get_fname(buf_T *buf, const unsigned *flagp)
{
  // Use the short file name if the current directory is known at the time
  // the session file will be sourced.
  // Don't do this for ":mkview", we don't know the current directory.
  // Don't do this after ":lcd", we don't keep track of what the current
  // directory is.
  if (buf->b_sfname != NULL
      && flagp == &ssop_flags
      && (ssop_flags & (kOptSsopFlagCurdir | kOptSsopFlagSesdir))
      && !p_acd
      && !did_lcd) {
    return buf->b_sfname;
  }
  return buf->b_ffname;
}

/// Write a buffer name to the session file.
/// Also ends the line, if "add_eol" is true.
///
/// @return  FAIL if writing fails.
static int ses_fname(FILE *fd, buf_T *buf, unsigned *flagp, bool add_eol)
{
  char *name = ses_get_fname(buf, flagp);
  if (ses_put_fname(fd, name, flagp) == FAIL
      || (add_eol && fprintf(fd, "\n") < 0)) {
    return FAIL;
  }
  return OK;
}

/// Escapes a filename for session writing.
/// Takes care of "slash" flag in 'sessionoptions' and escapes special
/// characters.
///
/// @return  allocated string or NULL.
static char *ses_escape_fname(char *name, unsigned *flagp)
{
  char *p;
  char *sname = home_replace_save(NULL, name);

  // Always kOptSsopFlagSlash: change all backslashes to forward slashes.
  for (p = sname; *p != NUL; MB_PTR_ADV(p)) {
    if (*p == '\\') {
      *p = '/';
    }
  }

  // Escape special characters.
  p = vim_strsave_fnameescape(sname, VSE_NONE);
  xfree(sname);
  return p;
}

/// Write a file name to the session file.
/// Takes care of the "slash" option in 'sessionoptions' and escapes special
/// characters.
///
/// @return  FAIL if writing fails.
static int ses_put_fname(FILE *fd, char *name, unsigned *flagp)
{
  char *p = ses_escape_fname(name, flagp);
  bool retval = fputs(p, fd) < 0 ? FAIL : OK;
  xfree(p);
  return retval;
}

/// Write commands to "fd" to restore the view of a window.
/// Caller must make sure 'scrolloff' is zero.
///
/// @param add_edit  add ":edit" command to view
/// @param flagp  vop_flags or ssop_flags
/// @param current_arg_idx  current argument index of the window, use -1 if unknown
static int put_view(FILE *fd, win_T *wp, tabpage_T *tp, bool add_edit, unsigned *flagp,
                    int current_arg_idx)
{
  int f;
  bool did_next = false;

  // Always restore cursor position for ":mksession".  For ":mkview" only
  // when 'viewoptions' contains "cursor".
  bool do_cursor = (flagp == &ssop_flags || *flagp & kOptSsopFlagCursor);

  // Local argument list.
  if (wp->w_alist == &global_alist) {
    PUTLINE_FAIL("argglobal");
  } else {
    if (ses_arglist(fd, "arglocal", &wp->w_alist->al_ga,
                    flagp == &vop_flags
                    || !(*flagp & kOptSsopFlagCurdir)
                    || tp->tp_localdir != NULL
                    || wp->w_localdir != NULL, flagp) == FAIL) {
      return FAIL;
    }
  }

  // Only when part of a session: restore the argument index.  Some
  // arguments may have been deleted, check if the index is valid.
  if (wp->w_arg_idx != current_arg_idx && wp->w_arg_idx < WARGCOUNT(wp)
      && flagp == &ssop_flags) {
    if (fprintf(fd, "%" PRId64 "argu\n", (int64_t)wp->w_arg_idx + 1) < 0) {
      return FAIL;
    }
    did_next = true;
  }

  // Edit the file.  Skip this when ":next" already did it.
  if (add_edit && (!did_next || wp->w_arg_idx_invalid)) {
    char *fname_esc = ses_escape_fname(ses_get_fname(wp->w_buffer, flagp), flagp);
    if (bt_help(wp->w_buffer)) {
      char *curtag = "";

      // A help buffer needs some options to be set.
      // First, create a new empty buffer with "buftype=help".
      // Then ":help" will re-use both the buffer and the window and set
      // the options, even when "options" is not in 'sessionoptions'.
      if (0 < wp->w_tagstackidx && wp->w_tagstackidx <= wp->w_tagstacklen) {
        curtag = wp->w_tagstack[wp->w_tagstackidx - 1].tagname;
      }

      if (put_line(fd, "enew | setl bt=help") == FAIL
          || fprintf(fd, "help %s", curtag) < 0 || put_eol(fd) == FAIL) {
        xfree(fname_esc);
        return FAIL;
      }
    } else if (wp->w_buffer->b_ffname != NULL
               && (!bt_nofilename(wp->w_buffer) || wp->w_buffer->terminal)) {
      // Load the file.

      // Editing a file in this buffer: use ":edit file".
      // This may have side effects! (e.g., compressed or network file).
      //
      // Note, if a buffer for that file already exists, use :badd to
      // edit that buffer, to not lose folding information (:edit resets
      // folds in other buffers)
      if (fprintf(fd,
                  "if bufexists(fnamemodify(\"%s\", \":p\")) | buffer %s | else | edit %s | endif\n"
                  // Fixup :terminal buffer name. #7836
                  "if &buftype ==# 'terminal'\n"
                  "  silent file %s\n"
                  "endif\n",
                  fname_esc,
                  fname_esc,
                  fname_esc,
                  fname_esc) < 0) {
        xfree(fname_esc);
        return FAIL;
      }
    } else {
      // No file in this buffer, just make it empty.
      PUTLINE_FAIL("enew");
      if (wp->w_buffer->b_ffname != NULL) {
        // The buffer does have a name, but it's not a file name.
        if (fprintf(fd, "file %s\n", fname_esc) < 0) {
          xfree(fname_esc);
          return FAIL;
        }
      }
      do_cursor = false;
    }
    xfree(fname_esc);
  }

  if (wp->w_alt_fnum) {
    buf_T *const alt = buflist_findnr(wp->w_alt_fnum);

    // Set the alternate file if the buffer is listed.
    if ((flagp == &ssop_flags) && alt != NULL && alt->b_fname != NULL
        && *alt->b_fname != NUL
        && alt->b_p_bl
        // do not set balt if buffer is terminal and "terminal" is not set in options
        && !(bt_terminal(alt) && !(ssop_flags & kOptSsopFlagTerminal))
        && (fputs("balt ", fd) < 0
            || ses_fname(fd, alt, flagp, true) == FAIL)) {
      return FAIL;
    }
  }

  // Local mappings and abbreviations.
  if ((*flagp & (kOptSsopFlagOptions | kOptSsopFlagLocaloptions))
      && makemap(fd, wp->w_buffer) == FAIL) {
    return FAIL;
  }

  // Local options.  Need to go to the window temporarily.
  // Store only local values when using ":mkview" and when ":mksession" is
  // used and 'sessionoptions' doesn't include "nvim/options".
  // Some folding options are always stored when "folds" is included,
  // otherwise the folds would not be restored correctly.
  win_T *save_curwin = curwin;
  curwin = wp;
  curbuf = curwin->w_buffer;
  if (*flagp & (kOptSsopFlagOptions | kOptSsopFlagLocaloptions)) {
    f = makeset(fd, OPT_LOCAL,
                flagp == &vop_flags || !(*flagp & kOptSsopFlagOptions));
  } else if (*flagp & kOptSsopFlagFolds) {
    f = makefoldset(fd);
  } else {
    f = OK;
  }
  curwin = save_curwin;
  curbuf = curwin->w_buffer;
  if (f == FAIL) {
    return FAIL;
  }

  // Save Folds when 'buftype' is empty and for help files.
  if ((*flagp & kOptSsopFlagFolds)
      && wp->w_buffer->b_ffname != NULL
      && (bt_normal(wp->w_buffer)
          || bt_help(wp->w_buffer))) {
    if (put_folds(fd, wp) == FAIL) {
      return FAIL;
    }
  }

  // Set the cursor after creating folds, since that moves the cursor.
  if (do_cursor) {
    // Restore the cursor line in the file and relatively in the
    // window.  Don't use "G", it changes the jumplist.
    if (wp->w_view_height <= 0) {
      if (fprintf(fd, "let s:l = %" PRIdLINENR "\n", wp->w_cursor.lnum) < 0) {
        return FAIL;
      }
    } else if (fprintf(fd,
                       "let s:l = %" PRIdLINENR " - ((%" PRIdLINENR
                       " * winheight(0) + %d) / %d)\n",
                       wp->w_cursor.lnum,
                       wp->w_cursor.lnum - wp->w_topline,
                       (wp->w_view_height / 2),
                       wp->w_view_height) < 0) {
      return FAIL;
    }
    if (fprintf(fd,
                "if s:l < 1 | let s:l = 1 | endif\n"
                "keepjumps exe s:l\n"
                "normal! zt\n"
                "keepjumps %" PRIdLINENR "\n",
                wp->w_cursor.lnum) < 0) {
      return FAIL;
    }
    // Restore the cursor column and left offset when not wrapping.
    if (wp->w_cursor.col == 0) {
      PUTLINE_FAIL("normal! 0");
    } else {
      if (!wp->w_p_wrap && wp->w_leftcol > 0 && wp->w_width > 0) {
        if (fprintf(fd,
                    "let s:c = %" PRId64 " - ((%" PRId64
                    " * winwidth(0) + %" PRId64 ") / %" PRId64 ")\n"
                    "if s:c > 0\n"
                    "  exe 'normal! ' . s:c . '|zs' . %" PRId64 " . '|'\n"
                    "else\n",
                    (int64_t)wp->w_virtcol + 1,
                    (int64_t)(wp->w_virtcol - wp->w_leftcol),
                    (int64_t)(wp->w_width / 2),
                    (int64_t)wp->w_width,
                    (int64_t)wp->w_virtcol + 1) < 0
            || put_view_curpos(fd, wp, "  ") == FAIL
            || put_line(fd, "endif") == FAIL) {
          return FAIL;
        }
      } else if (put_view_curpos(fd, wp, "") == FAIL) {
        return FAIL;
      }
    }
  }

  // Local directory, if the current flag is not view options or the "curdir"
  // option is included.
  if (wp->w_localdir != NULL
      && (flagp != &vop_flags || (*flagp & kOptSsopFlagCurdir))) {
    if (fputs("lcd ", fd) < 0
        || ses_put_fname(fd, wp->w_localdir, flagp) == FAIL
        || fprintf(fd, "\n") < 0) {
      return FAIL;
    }
    did_lcd = true;
  }

  return OK;
}

static int store_session_globals(FILE *fd)
{
  TV_DICT_ITER(get_globvar_dict(), this_var, {
    if ((this_var->di_tv.v_type == VAR_NUMBER
         || this_var->di_tv.v_type == VAR_STRING)
        && var_flavour(this_var->di_key) == VAR_FLAVOUR_SESSION) {
      // Escape special characters with a backslash.  Turn a LF and
      // CR into \n and \r.
      char *const p = vim_strsave_escaped(tv_get_string(&this_var->di_tv), "\\\"\n\r");
      for (char *t = p; *t != NUL; t++) {
        if (*t == '\n') {
          *t = 'n';
        } else if (*t == '\r') {
          *t = 'r';
        }
      }
      if ((fprintf(fd, "let %s = %c%s%c",
                   this_var->di_key,
                   ((this_var->di_tv.v_type == VAR_STRING) ? '"' : ' '),
                   p,
                   ((this_var->di_tv.v_type == VAR_STRING) ? '"' : ' ')) < 0)
          || put_eol(fd) == FAIL) {
        xfree(p);
        return FAIL;
      }
      xfree(p);
    } else if (this_var->di_tv.v_type == VAR_FLOAT
               && var_flavour(this_var->di_key) == VAR_FLAVOUR_SESSION) {
      float_T f = this_var->di_tv.vval.v_float;
      int sign = ' ';

      if (f < 0) {
        f = -f;
        sign = '-';
      }
      if ((fprintf(fd, "let %s = %c%f", this_var->di_key, sign, f) < 0)
          || put_eol(fd) == FAIL) {
        return FAIL;
      }
    }
  });
  return OK;
}

/// Writes commands for restoring the current buffers, for :mksession.
///
/// Legacy 'sessionoptions'/'viewoptions' flags kOptSsopFlagUnix, kOptSsopFlagSlash are
/// always enabled.
///
/// @param dirnow  Current directory name
/// @param fd  File descriptor to write to
///
/// @return FAIL on error, OK otherwise.
static int makeopens(FILE *fd, char *dirnow)
{
  bool only_save_windows = true;
  bool restore_size = true;
  win_T *edited_win = NULL;
  win_T *tab_firstwin;
  frame_T *tab_topframe;
  int cur_arg_idx = 0;
  int next_arg_idx = 0;

  if (ssop_flags & kOptSsopFlagBuffers) {
    only_save_windows = false;  // Save ALL buffers
  }

  // Begin by setting v:this_session, and then other sessionable variables.
  PUTLINE_FAIL("let v:this_session=expand(\"<sfile>:p\")");

  PUTLINE_FAIL("doautoall SessionLoadPre");

  if (ssop_flags & kOptSsopFlagGlobals) {
    if (store_session_globals(fd) == FAIL) {
      return FAIL;
    }
  }

  // Close all windows and tabs but one.
  PUTLINE_FAIL("silent only");
  if ((ssop_flags & kOptSsopFlagTabpages)
      && put_line(fd, "silent tabonly") == FAIL) {
    return FAIL;
  }

  // Now a :cd command to the session directory or the current directory
  if (ssop_flags & kOptSsopFlagSesdir) {
    PUTLINE_FAIL("exe \"cd \" . escape(expand(\"<sfile>:p:h\"), ' ')");
  } else if (ssop_flags & kOptSsopFlagCurdir) {
    char *sname = home_replace_save(NULL, globaldir != NULL ? globaldir : dirnow);
    char *fname_esc = ses_escape_fname(sname, &ssop_flags);
    if (fprintf(fd, "cd %s\n", fname_esc) < 0) {
      xfree(fname_esc);
      xfree(sname);
      return FAIL;
    }
    xfree(fname_esc);
    xfree(sname);
  }

  if (fprintf(fd,
              "%s",
              // If there is an empty, unnamed buffer we will wipe it out later.
              // Remember the buffer number.
              "if expand('%') == '' && !&modified && line('$') <= 1"
              " && getline(1) == ''\n"
              "  let s:wipebuf = bufnr('%')\n"
              "endif\n") < 0) {
    return FAIL;
  }

  // Save 'shortmess' if not storing options.
  if ((ssop_flags & kOptSsopFlagOptions) == 0) {
    PUTLINE_FAIL("let s:shortmess_save = &shortmess");
  }

  // Set 'shortmess' for the following.
  PUTLINE_FAIL("set shortmess+=aoO");

  // Now save the current files, current buffer first.
  // Put all buffers into the buffer list.
  // Do it very early to preserve buffer order after loading session (which
  // can be disrupted by prior `edit` or `tabedit` calls).
  FOR_ALL_BUFFERS(buf) {
    if (!(only_save_windows && buf->b_nwindows == 0)
        && !(buf->b_help && !(ssop_flags & kOptSsopFlagHelp))
        && !(bt_terminal(buf) && !(ssop_flags & kOptSsopFlagTerminal))
        && buf->b_fname != NULL
        && buf->b_p_bl) {
      if (fprintf(fd, "badd +%" PRId64 " ",
                  kv_size(buf->b_wininfo) == 0
                  ? 1 : (int64_t)kv_A(buf->b_wininfo, 0)->wi_mark.mark.lnum) < 0
          || ses_fname(fd, buf, &ssop_flags, true) == FAIL) {
        return FAIL;
      }
    }
  }

  // the global argument list
  if (ses_arglist(fd, "argglobal", &global_alist.al_ga,
                  !(ssop_flags & kOptSsopFlagCurdir), &ssop_flags) == FAIL) {
    return FAIL;
  }

  if (ssop_flags & kOptSsopFlagResize) {
    // Note: after the restore we still check it worked!
    if (fprintf(fd, "set lines=%" PRId64 " columns=%" PRId64 "\n",
                (int64_t)Rows, (int64_t)Columns) < 0) {
      return FAIL;
    }
  }

  bool restore_stal = false;
  // When there are two or more tabpages and 'showtabline' is 1 the tabline
  // will be displayed when creating the next tab.  That resizes the windows
  // in the first tab, which may cause problems.  Set 'showtabline' to 2
  // temporarily to avoid that.
  if (p_stal == 1 && first_tabpage->tp_next != NULL) {
    PUTLINE_FAIL("set stal=2");
    restore_stal = true;
  }

  if ((ssop_flags & kOptSsopFlagTabpages)) {
    // "tabpages" is in 'sessionoptions': Similar to ses_win_rec() below,
    // populate the tab pages first so later local options won't be copied
    // to the new tabs.
    FOR_ALL_TABS(tp) {
      // Use `bufhidden=wipe` to remove empty "placeholder" buffers once
      // they are not needed. This prevents creating extra buffers (see
      // cause of Vim patch 8.1.0829)
      if (tp->tp_next != NULL && put_line(fd, "tabnew +setlocal\\ bufhidden=wipe") == FAIL) {
        return FAIL;
      }
    }

    if (first_tabpage->tp_next != NULL && put_line(fd, "tabrewind") == FAIL) {
      return FAIL;
    }
  }

  // Assume "tabpages" is in 'sessionoptions'.  If not then we only do
  // "curtab" and bail out of the loop.
  bool restore_height_width = false;
  FOR_ALL_TABS(tp) {
    bool need_tabnext = false;
    int cnr = 1;

    // May repeat putting Windows for each tab, when "tabpages" is in
    // 'sessionoptions'.
    // Don't use goto_tabpage(), it may change directory and trigger
    // autocommands.
    if ((ssop_flags & kOptSsopFlagTabpages)) {
      if (tp == curtab) {
        tab_firstwin = firstwin;
        tab_topframe = topframe;
      } else {
        tab_firstwin = tp->tp_firstwin;
        tab_topframe = tp->tp_topframe;
      }
      if (tp != first_tabpage) {
        need_tabnext = true;
      }
    } else {
      tp = curtab;
      tab_firstwin = firstwin;
      tab_topframe = topframe;
    }

    // Before creating the window layout, try loading one file.  If this
    // is aborted we don't end up with a number of useless windows.
    // This may have side effects! (e.g., compressed or network file).
    for (win_T *wp = tab_firstwin; wp != NULL; wp = wp->w_next) {
      if (ses_do_win(wp)
          && wp->w_buffer->b_ffname != NULL
          && !bt_help(wp->w_buffer)
          && !bt_nofilename(wp->w_buffer)) {
        if (need_tabnext && put_line(fd, "tabnext") == FAIL) {
          return FAIL;
        }
        need_tabnext = false;

        if (fputs("edit ", fd) < 0
            || ses_fname(fd, wp->w_buffer, &ssop_flags, true) == FAIL) {
          return FAIL;
        }
        if (!wp->w_arg_idx_invalid) {
          edited_win = wp;
        }
        break;
      }
    }

    // If no file got edited create an empty tab page.
    if (need_tabnext && put_line(fd, "tabnext") == FAIL) {
      return FAIL;
    }

    if (tab_topframe->fr_layout != FR_LEAF) {
      // Save current window layout.
      PUTLINE_FAIL("let s:save_splitbelow = &splitbelow");
      PUTLINE_FAIL("let s:save_splitright = &splitright");
      PUTLINE_FAIL("set splitbelow splitright");
      if (ses_win_rec(fd, tab_topframe) == FAIL) {
        return FAIL;
      }
      PUTLINE_FAIL("let &splitbelow = s:save_splitbelow");
      PUTLINE_FAIL("let &splitright = s:save_splitright");
    }

    // Check if window sizes can be restored (no windows omitted).
    // Remember the window number of the current window after restoring.
    int nr = 0;
    for (win_T *wp = tab_firstwin; wp != NULL; wp = wp->w_next) {
      if (ses_do_win(wp)) {
        nr++;
      } else if (!wp->w_floating) {
        restore_size = false;
      }
      if (curwin == wp) {
        cnr = nr;
      }
    }

    if (tab_firstwin != NULL && tab_firstwin->w_next != NULL) {
      // Go to the first window.
      PUTLINE_FAIL("wincmd t");

      // If more than one window, see if sizes can be restored.
      // First set 'winheight' and 'winwidth' to 1 to avoid the windows
      // being resized when moving between windows.
      // Do this before restoring the view, so that the topline and the
      // cursor can be set.  This is done again below.
      // winminheight and winminwidth need to be set to avoid an error if
      // the user has set winheight or winwidth.
      PUTLINE_FAIL("let s:save_winminheight = &winminheight");
      PUTLINE_FAIL("let s:save_winminwidth = &winminwidth");
      if (fprintf(fd,
                  "set winminheight=0\n"
                  "set winheight=1\n"
                  "set winminwidth=0\n"
                  "set winwidth=1\n") < 0) {
        return FAIL;
      }
      restore_height_width = true;
    }
    if (nr > 1 && ses_winsizes(fd, restore_size, tab_firstwin) == FAIL) {
      return FAIL;
    }

    // Restore the tab-local working directory if specified
    // Do this before the windows, so that the window-local directory can
    // override the tab-local directory.
    if ((ssop_flags & kOptSsopFlagCurdir) && tp->tp_localdir != NULL) {
      if (fputs("tcd ", fd) < 0
          || ses_put_fname(fd, tp->tp_localdir, &ssop_flags) == FAIL
          || put_eol(fd) == FAIL) {
        return FAIL;
      }
      did_lcd = true;
    }

    // Restore the view of the window (options, file, cursor, etc.).
    for (win_T *wp = tab_firstwin; wp != NULL; wp = wp->w_next) {
      if (!ses_do_win(wp)) {
        continue;
      }
      if (put_view(fd, wp, tp, wp != edited_win, &ssop_flags, cur_arg_idx)
          == FAIL) {
        return FAIL;
      }
      if (nr > 1 && put_line(fd, "wincmd w") == FAIL) {
        return FAIL;
      }
      next_arg_idx = wp->w_arg_idx;
    }

    // The argument index in the first tab page is zero, need to set it in
    // each window.  For further tab pages it's the window where we do
    // "tabedit".
    cur_arg_idx = next_arg_idx;

    // Restore cursor to the current window if it's not the first one.
    if (cnr > 1 && (fprintf(fd, "%dwincmd w\n", cnr) < 0)) {
      return FAIL;
    }

    // Restore window sizes again after jumping around in windows, because
    // the current window has a minimum size while others may not.
    if (nr > 1 && ses_winsizes(fd, restore_size, tab_firstwin) == FAIL) {
      return FAIL;
    }

    // Don't continue in another tab page when doing only the current one
    // or when at the last tab page.
    if (!(ssop_flags & kOptSsopFlagTabpages)) {
      break;
    }
  }

  if (ssop_flags & kOptSsopFlagTabpages) {
    if (fprintf(fd, "tabnext %d\n", tabpage_index(curtab)) < 0) {
      return FAIL;
    }
  }
  if (restore_stal && put_line(fd, "set stal=1") == FAIL) {
    return FAIL;
  }

  // Wipe out an empty unnamed buffer we started in.
  if (fprintf(fd, "%s",
              "if exists('s:wipebuf') "
              "&& len(win_findbuf(s:wipebuf)) == 0 "
              "&& getbufvar(s:wipebuf, '&buftype') isnot# 'terminal'\n"
              "  silent exe 'bwipe ' . s:wipebuf\n"
              "endif\n"
              "unlet! s:wipebuf\n") < 0) {
    return FAIL;
  }

  // Re-apply 'winheight' and 'winwidth'.
  if (fprintf(fd, "set winheight=%" PRId64 " winwidth=%" PRId64 "\n",
              (int64_t)p_wh, (int64_t)p_wiw) < 0) {
    return FAIL;
  }

  // Restore 'shortmess'.
  if (ssop_flags & kOptSsopFlagOptions) {
    if (fprintf(fd, "set shortmess=%s\n", p_shm) < 0) {
      return FAIL;
    }
  } else {
    PUTLINE_FAIL("let &shortmess = s:shortmess_save");
  }

  if (restore_height_width) {
    // Restore 'winminheight' and 'winminwidth'.
    PUTLINE_FAIL("let &winminheight = s:save_winminheight");
    PUTLINE_FAIL("let &winminwidth = s:save_winminwidth");
  }

  // Lastly, execute the x.vim file if it exists.
  if (fprintf(fd, "%s",
              "let s:sx = expand(\"<sfile>:p:r\").\"x.vim\"\n"
              "if filereadable(s:sx)\n"
              "  exe \"source \" . fnameescape(s:sx)\n"
              "endif\n") < 0) {
    return FAIL;
  }

  return OK;
}

/// ":loadview [nr]"
void ex_loadview(exarg_T *eap)
{
  char *fname = get_view_file(*eap->arg);
  if (fname == NULL) {
    return;
  }

  if (do_source(fname, false, DOSO_NONE, NULL) == FAIL) {
    semsg(_(e_notopen), fname);
  }
  xfree(fname);
}

/// ":mkexrc", ":mkvimrc", ":mkview", ":mksession".
///
/// Legacy 'sessionoptions'/'viewoptions' flags are always enabled:
///   - kOptSsopFlagUnix: line-endings are LF
///   - kOptSsopFlagSlash: filenames are written with "/" slash
void ex_mkrc(exarg_T *eap)
{
  bool view_session = false;  // :mkview, :mksession
  int using_vdir = false;  // using 'viewdir'?
  char *viewFile = NULL;

  if (eap->cmdidx == CMD_mksession || eap->cmdidx == CMD_mkview) {
    view_session = true;
  }

  // Use the short file name until ":lcd" is used.  We also don't use the
  // short file name when 'acd' is set, that is checked later.
  did_lcd = false;

  char *fname;
  // ":mkview" or ":mkview 9": generate file name with 'viewdir'
  if (eap->cmdidx == CMD_mkview
      && (*eap->arg == NUL
          || (ascii_isdigit(*eap->arg) && eap->arg[1] == NUL))) {
    eap->forceit = true;
    fname = get_view_file(*eap->arg);
    if (fname == NULL) {
      return;
    }
    viewFile = fname;
    using_vdir = true;
  } else if (*eap->arg != NUL) {
    fname = eap->arg;
  } else if (eap->cmdidx == CMD_mkvimrc) {
    fname = VIMRC_FILE;
  } else if (eap->cmdidx == CMD_mksession) {
    fname = SESSION_FILE;
  } else {
    fname = EXRC_FILE;
  }

  // When using 'viewdir' may have to create the directory.
  if (using_vdir && !os_isdir(p_vdir)) {
    vim_mkdir_emsg(p_vdir, 0755);
  }

  FILE *fd = open_exfile(fname, eap->forceit, WRITEBIN);
  if (fd != NULL) {
    bool failed = false;
    unsigned *flagp;
    if (eap->cmdidx == CMD_mkview) {
      flagp = &vop_flags;
    } else {
      flagp = &ssop_flags;
    }

    // Write the version command for :mkvimrc
    if (eap->cmdidx == CMD_mkvimrc) {
      put_line(fd, "version 6.0");
    }

    if (eap->cmdidx == CMD_mksession) {
      if (put_line(fd, "let SessionLoad = 1") == FAIL) {
        failed = true;
      }
    }

    if (!view_session || (eap->cmdidx == CMD_mksession
                          && (*flagp & kOptSsopFlagOptions))) {
      int flags = OPT_GLOBAL;

      if (eap->cmdidx == CMD_mksession && (*flagp & kOptSsopFlagSkiprtp)) {
        flags |= OPT_SKIPRTP;
      }
      failed |= (makemap(fd, NULL) == FAIL
                 || makeset(fd, flags, false) == FAIL);
    }

    if (!failed && view_session) {
      if (put_line(fd,
                   "let s:so_save = &g:so | let s:siso_save = &g:siso"
                   " | setg so=0 siso=0 | setl so=-1 siso=-1") == FAIL) {
        failed = true;
      }
      if (eap->cmdidx == CMD_mksession) {
        char *dirnow;  // current directory

        dirnow = xmalloc(MAXPATHL);

        // Change to session file's dir.
        if (os_dirname(dirnow, MAXPATHL) == FAIL
            || os_chdir(dirnow) != 0) {
          *dirnow = NUL;
        }
        if (*dirnow != NUL && (ssop_flags & kOptSsopFlagSesdir)) {
          if (vim_chdirfile(fname, kCdCauseOther) == OK) {
            shorten_fnames(true);
          }
        } else if (*dirnow != NUL
                   && (ssop_flags & kOptSsopFlagCurdir) && globaldir != NULL) {
          if (os_chdir(globaldir) == 0) {
            shorten_fnames(true);
          }
        }

        failed |= (makeopens(fd, dirnow) == FAIL);

        // restore original dir
        if (*dirnow != NUL && ((ssop_flags & kOptSsopFlagSesdir)
                               || ((ssop_flags & kOptSsopFlagCurdir) && globaldir !=
                                   NULL))) {
          if (os_chdir(dirnow) != 0) {
            emsg(_(e_prev_dir));
          }
          shorten_fnames(true);
        }
        xfree(dirnow);
      } else {
        failed |= (put_view(fd, curwin, curtab, !using_vdir, flagp, -1) == FAIL);
      }
      if (fprintf(fd,
                  "%s",
                  "let &g:so = s:so_save | let &g:siso = s:siso_save\n")
          < 0) {
        failed = true;
      }
      if (p_hls && fprintf(fd, "%s", "set hlsearch\n") < 0) {
        failed = true;
      }
      if (no_hlsearch && fprintf(fd, "%s", "nohlsearch\n") < 0) {
        failed = true;
      }
      if (fprintf(fd, "%s", "doautoall SessionLoadPost\n") < 0) {
        failed = true;
      }
      if (eap->cmdidx == CMD_mksession) {
        if (fprintf(fd, "unlet SessionLoad\n") < 0) {
          failed = true;
        }
      }
    }
    if (put_line(fd, "\" vim: set ft=vim :") == FAIL) {
      failed = true;
    }

    failed |= fclose(fd);

    if (failed) {
      emsg(_(e_write));
    } else if (eap->cmdidx == CMD_mksession) {
      // successful session write - set v:this_session
      char *const tbuf = xmalloc(MAXPATHL);
      if (vim_FullName(fname, tbuf, MAXPATHL, false) == OK) {
        set_vim_var_string(VV_THIS_SESSION, tbuf, -1);
      }
      xfree(tbuf);
    }
  }

  xfree(viewFile);

  apply_autocmds(EVENT_SESSIONWRITEPOST, NULL, NULL, false, curbuf);
}

/// @return  the name of the view file for the current buffer.
static char *get_view_file(char c)
{
  if (curbuf->b_ffname == NULL) {
    emsg(_(e_noname));
    return NULL;
  }
  char *sname = home_replace_save(NULL, curbuf->b_ffname);

  // We want a file name without separators, because we're not going to make
  // a directory.
  //    "normal" path separator   -> "=+"
  //    "="                       -> "=="
  //    ":" path separator        -> "=-"
  size_t len = 0;
  for (char *p = sname; *p; p++) {
    if (*p == '=' || vim_ispathsep(*p)) {
      len++;
    }
  }
  char *retval = xmalloc(strlen(sname) + len + strlen(p_vdir) + 9);
  STRCPY(retval, p_vdir);
  add_pathsep(retval);
  char *s = retval + strlen(retval);
  for (char *p = sname; *p; p++) {
    if (*p == '=') {
      *s++ = '=';
      *s++ = '=';
    } else if (vim_ispathsep(*p)) {
      *s++ = '=';
#if defined(BACKSLASH_IN_FILENAME)
      *s++ = (*p == ':') ? '-' : '+';
#else
      *s++ = '+';
#endif
    } else {
      *s++ = *p;
    }
  }
  *s++ = '=';
  *s++ = c;
  xmemcpyz(s, S_LEN(".vim"));

  xfree(sname);
  return retval;
}

/// TODO(justinmk): remove this, not needed after 5ba3cecb68cd.
int put_eol(FILE *fd)
{
  if (putc('\n', fd) < 0) {
    return FAIL;
  }
  return OK;
}

/// TODO(justinmk): remove this, not needed after 5ba3cecb68cd.
int put_line(FILE *fd, char *s)
{
  if (fprintf(fd, "%s\n", s) < 0) {
    return FAIL;
  }
  return OK;
}
