/* vi:set ts=8 sts=4 sw=4 noet:
 *
 * VIM - Vi IMproved	by Bram Moolenaar
 *
 * Do ":help uganda"  in Vim to read copying and usage conditions.
 * Do ":help credits" in Vim to see a list of people who contributed.
 * See README.txt for an overview of the Vim source code.
 */

/*
 * ex_cmds2.c: some more functions for command line commands
 */

#include "version.h"
#include "vim.h"

static void cmd_source(char_u *fname, exarg_T *eap);

#ifdef FEAT_EVAL
/* Growarray to store info about already sourced scripts.
 * For Unix also store the dev/ino, so that we don't have to stat() each
 * script when going through the list. */
typedef struct scriptitem_S
{
  char_u *sn_name;
#ifdef UNIX
  int sn_dev_valid;
  dev_t sn_dev;
  ino_t sn_ino;
#endif
#ifdef FEAT_PROFILE
  int sn_prof_on;         /* TRUE when script is/was profiled */
  int sn_pr_force;        /* forceit: profile functions in this script */
  proftime_T sn_pr_child; /* time set when going into first child */
  int sn_pr_nest;         /* nesting for sn_pr_child */
  /* profiling the script as a whole */
  int sn_pr_count;           /* nr of times sourced */
  proftime_T sn_pr_total;    /* time spent in script + children */
  proftime_T sn_pr_self;     /* time spent in script itself */
  proftime_T sn_pr_start;    /* time at script start */
  proftime_T sn_pr_children; /* time in children after script start */
  /* profiling the script per line */
  garray_T sn_prl_ga;         /* things stored for every line */
  proftime_T sn_prl_start;    /* start time for current line */
  proftime_T sn_prl_children; /* time spent in children for this line */
  proftime_T sn_prl_wait;     /* wait start time for current line */
  int sn_prl_idx;             /* index of line being timed; -1 if none */
  int sn_prl_execed;          /* line being timed was executed */
#endif
} scriptitem_T;

static garray_T script_items = {0, 0, sizeof(scriptitem_T), 4, NULL};
#define SCRIPT_ITEM(id) (((scriptitem_T *)script_items.ga_data)[(id)-1])

#ifdef FEAT_PROFILE
/* Struct used in sn_prl_ga for every line of a script. */
typedef struct sn_prl_S
{
  int snp_count;           /* nr of times line was executed */
  proftime_T sn_prl_total; /* time spent in a line + children */
  proftime_T sn_prl_self;  /* time spent in a line itself */
} sn_prl_T;

#define PRL_ITEM(si, idx) (((sn_prl_T *)(si)->sn_prl_ga.ga_data)[(idx)])
#endif
#endif

#if defined(FEAT_EVAL) || defined(PROTO)
#if defined(FEAT_PROFILE) || defined(FEAT_RELTIME) || defined(PROTO)
/*
 * Store the current time in "tm".
 */
void profile_start(proftime_T *tm)
{
#ifdef MSWIN
  QueryPerformanceCounter(tm);
#else
  gettimeofday(tm, NULL);
#endif
}

/*
 * Compute the elapsed time from "tm" till now and store in "tm".
 */
void profile_end(proftime_T *tm)
{
  proftime_T now;

#ifdef MSWIN
  QueryPerformanceCounter(&now);
  tm->QuadPart = now.QuadPart - tm->QuadPart;
#else
  gettimeofday(&now, NULL);
  tm->tv_usec = now.tv_usec - tm->tv_usec;
  tm->tv_sec = now.tv_sec - tm->tv_sec;
  if (tm->tv_usec < 0)
  {
    tm->tv_usec += 1000000;
    --tm->tv_sec;
  }
#endif
}

/*
 * Subtract the time "tm2" from "tm".
 */
void profile_sub(proftime_T *tm, proftime_T *tm2)
{
#ifdef MSWIN
  tm->QuadPart -= tm2->QuadPart;
#else
  tm->tv_usec -= tm2->tv_usec;
  tm->tv_sec -= tm2->tv_sec;
  if (tm->tv_usec < 0)
  {
    tm->tv_usec += 1000000;
    --tm->tv_sec;
  }
#endif
}

/*
 * Return a string that represents the time in "tm".
 * Uses a static buffer!
 */
char *
profile_msg(proftime_T *tm)
{
  static char buf[50];

#ifdef MSWIN
  LARGE_INTEGER fr;

  QueryPerformanceFrequency(&fr);
  sprintf(buf, "%10.6lf", (double)tm->QuadPart / (double)fr.QuadPart);
#else
  sprintf(buf, "%3ld.%06ld", (long)tm->tv_sec, (long)tm->tv_usec);
#endif
  return buf;
}

#if defined(FEAT_FLOAT) || defined(PROTO)
/*
 * Return a float that represents the time in "tm".
 */
float_T
profile_float(proftime_T *tm)
{
#ifdef MSWIN
  LARGE_INTEGER fr;

  QueryPerformanceFrequency(&fr);
  return (float_T)tm->QuadPart / (float_T)fr.QuadPart;
#else
  return (float_T)tm->tv_sec + (float_T)tm->tv_usec / 1000000.0;
#endif
}
#endif

/*
 * Put the time "msec" past now in "tm".
 */
void profile_setlimit(long msec, proftime_T *tm)
{
  if (msec <= 0) /* no limit */
    profile_zero(tm);
  else
  {
#ifdef MSWIN
    LARGE_INTEGER fr;

    QueryPerformanceCounter(tm);
    QueryPerformanceFrequency(&fr);
    tm->QuadPart += (LONGLONG)((double)msec / 1000.0 * (double)fr.QuadPart);
#else
    long usec;

    gettimeofday(tm, NULL);
    usec = (long)tm->tv_usec + (long)msec * 1000;
    tm->tv_usec = usec % 1000000L;
    tm->tv_sec += usec / 1000000L;
#endif
  }
}

/*
 * Return TRUE if the current time is past "tm".
 */
int profile_passed_limit(proftime_T *tm)
{
  proftime_T now;

#ifdef MSWIN
  if (tm->QuadPart == 0) /* timer was not set */
    return FALSE;
  QueryPerformanceCounter(&now);
  return (now.QuadPart > tm->QuadPart);
#else
  if (tm->tv_sec == 0) /* timer was not set */
    return FALSE;
  gettimeofday(&now, NULL);
  return (now.tv_sec > tm->tv_sec || (now.tv_sec == tm->tv_sec && now.tv_usec > tm->tv_usec));
#endif
}

/*
 * Set the time in "tm" to zero.
 */
void profile_zero(proftime_T *tm)
{
#ifdef MSWIN
  tm->QuadPart = 0;
#else
  tm->tv_usec = 0;
  tm->tv_sec = 0;
#endif
}

#endif /* FEAT_PROFILE || FEAT_RELTIME */

#if defined(FEAT_TIMERS) || defined(PROTO)
static timer_T *first_timer = NULL;
static long last_timer_id = 0;

/*
 * Return time left until "due".  Negative if past "due".
 */
long proftime_time_left(proftime_T *due, proftime_T *now)
{
#ifdef MSWIN
  LARGE_INTEGER fr;

  if (now->QuadPart > due->QuadPart)
    return 0;
  QueryPerformanceFrequency(&fr);
  return (long)(((double)(due->QuadPart - now->QuadPart) / (double)fr.QuadPart) * 1000);
#else
  if (now->tv_sec > due->tv_sec)
    return 0;
  return (due->tv_sec - now->tv_sec) * 1000 + (due->tv_usec - now->tv_usec) / 1000;
#endif
}

/*
 * Insert a timer in the list of timers.
 */
static void
insert_timer(timer_T *timer)
{
  timer->tr_next = first_timer;
  timer->tr_prev = NULL;
  if (first_timer != NULL)
    first_timer->tr_prev = timer;
  first_timer = timer;
  did_add_timer = TRUE;
}

/*
 * Take a timer out of the list of timers.
 */
static void
remove_timer(timer_T *timer)
{
  if (timer->tr_prev == NULL)
    first_timer = timer->tr_next;
  else
    timer->tr_prev->tr_next = timer->tr_next;
  if (timer->tr_next != NULL)
    timer->tr_next->tr_prev = timer->tr_prev;
}

static void
free_timer(timer_T *timer)
{
  free_callback(&timer->tr_callback);
  vim_free(timer);
}

/*
 * Create a timer and return it.  NULL if out of memory.
 * Caller should set the callback.
 */
timer_T *
create_timer(long msec, int repeat)
{
  timer_T *timer = ALLOC_CLEAR_ONE(timer_T);
  long prev_id = last_timer_id;

  if (timer == NULL)
    return NULL;
  if (++last_timer_id <= prev_id)
    /* Overflow!  Might cause duplicates... */
    last_timer_id = 0;
  timer->tr_id = last_timer_id;
  insert_timer(timer);
  if (repeat != 0)
    timer->tr_repeat = repeat - 1;
  timer->tr_interval = msec;

  profile_setlimit(msec, &timer->tr_due);
  return timer;
}

/*
 * Invoke the callback of "timer".
 */
static void
timer_callback(timer_T *timer)
{
  typval_T rettv;
  int dummy;
  typval_T argv[2];

  argv[0].v_type = VAR_NUMBER;
  argv[0].vval.v_number = (varnumber_T)timer->tr_id;
  argv[1].v_type = VAR_UNKNOWN;

  call_callback(&timer->tr_callback, -1,
                &rettv, 1, argv, NULL, 0L, 0L, &dummy, TRUE, NULL);
  clear_tv(&rettv);
}

/*
 * Call timers that are due.
 * Return the time in msec until the next timer is due.
 * Returns -1 if there are no pending timers.
 */
long check_due_timer(void)
{
  timer_T *timer;
  timer_T *timer_next;
  long this_due;
  long next_due = -1;
  proftime_T now;
  int did_one = FALSE;
  int need_update_screen = FALSE;
  long current_id = last_timer_id;

  /* Don't run any timers while exiting or dealing with an error. */
  if (exiting || aborting())
    return next_due;

  profile_start(&now);
  for (timer = first_timer; timer != NULL && !got_int; timer = timer_next)
  {
    timer_next = timer->tr_next;

    if (timer->tr_id == -1 || timer->tr_firing || timer->tr_paused)
      continue;
    this_due = proftime_time_left(&timer->tr_due, &now);
    if (this_due <= 1)
    {
      /* Save and restore a lot of flags, because the timer fires while
	     * waiting for a character, which might be halfway a command. */
      int save_timer_busy = timer_busy;
      int save_vgetc_busy = vgetc_busy;
      int save_did_emsg = did_emsg;
      int save_called_emsg = called_emsg;
      int save_must_redraw = must_redraw;
      int save_trylevel = trylevel;
      int save_did_throw = did_throw;
      int save_ex_pressedreturn = get_pressedreturn();
      except_T *save_current_exception = current_exception;
      vimvars_save_T vvsave;

      /* Create a scope for running the timer callback, ignoring most of
	     * the current scope, such as being inside a try/catch. */
      timer_busy = timer_busy > 0 || vgetc_busy > 0;
      vgetc_busy = 0;
      called_emsg = FALSE;
      did_emsg = FALSE;
      did_uncaught_emsg = FALSE;
      must_redraw = 0;
      trylevel = 0;
      did_throw = FALSE;
      current_exception = NULL;
      save_vimvars(&vvsave);
      timer->tr_firing = TRUE;
      timer_callback(timer);
      timer->tr_firing = FALSE;

      timer_next = timer->tr_next;
      did_one = TRUE;
      timer_busy = save_timer_busy;
      vgetc_busy = save_vgetc_busy;
      if (did_uncaught_emsg)
        ++timer->tr_emsg_count;
      did_emsg = save_did_emsg;
      called_emsg = save_called_emsg;
      trylevel = save_trylevel;
      did_throw = save_did_throw;
      current_exception = save_current_exception;
      restore_vimvars(&vvsave);
      if (must_redraw != 0)
        need_update_screen = TRUE;
      must_redraw = must_redraw > save_must_redraw
                        ? must_redraw
                        : save_must_redraw;
      set_pressedreturn(save_ex_pressedreturn);

      /* Only fire the timer again if it repeats and stop_timer() wasn't
	     * called while inside the callback (tr_id == -1). */
      if (timer->tr_repeat != 0 && timer->tr_id != -1 && timer->tr_emsg_count < 3)
      {
        profile_setlimit(timer->tr_interval, &timer->tr_due);
        this_due = proftime_time_left(&timer->tr_due, &now);
        if (this_due < 1)
          this_due = 1;
        if (timer->tr_repeat > 0)
          --timer->tr_repeat;
      }
      else
      {
        this_due = -1;
        remove_timer(timer);
        free_timer(timer);
      }
    }
    if (this_due > 0 && (next_due == -1 || next_due > this_due))
      next_due = this_due;
  }

  if (did_one)
    redraw_after_callback(need_update_screen);

#ifdef FEAT_TERMINAL
  /* Some terminal windows may need their buffer updated. */
  next_due = term_check_timers(next_due, &now);
#endif

  return current_id != last_timer_id ? 1 : next_due;
}

/*
 * Find a timer by ID.  Returns NULL if not found;
 */
timer_T *
find_timer(long id)
{
  timer_T *timer;

  if (id >= 0)
  {
    for (timer = first_timer; timer != NULL; timer = timer->tr_next)
      if (timer->tr_id == id)
        return timer;
  }
  return NULL;
}

/*
 * Stop a timer and delete it.
 */
void stop_timer(timer_T *timer)
{
  if (timer->tr_firing)
    /* Free the timer after the callback returns. */
    timer->tr_id = -1;
  else
  {
    remove_timer(timer);
    free_timer(timer);
  }
}

void stop_all_timers(void)
{
  timer_T *timer;
  timer_T *timer_next;

  for (timer = first_timer; timer != NULL; timer = timer_next)
  {
    timer_next = timer->tr_next;
    stop_timer(timer);
  }
}

void add_timer_info(typval_T *rettv, timer_T *timer)
{
  list_T *list = rettv->vval.v_list;
  dict_T *dict = dict_alloc();
  dictitem_T *di;
  long remaining;
  proftime_T now;

  if (dict == NULL)
    return;
  list_append_dict(list, dict);

  dict_add_number(dict, "id", timer->tr_id);
  dict_add_number(dict, "time", (long)timer->tr_interval);

  profile_start(&now);
  remaining = proftime_time_left(&timer->tr_due, &now);
  dict_add_number(dict, "remaining", (long)remaining);

  dict_add_number(dict, "repeat",
                  (long)(timer->tr_repeat < 0 ? -1 : timer->tr_repeat + 1));
  dict_add_number(dict, "paused", (long)(timer->tr_paused));

  di = dictitem_alloc((char_u *)"callback");
  if (di != NULL)
  {
    if (dict_add(dict, di) == FAIL)
      vim_free(di);
    else
      put_callback(&timer->tr_callback, &di->di_tv);
  }
}

void add_timer_info_all(typval_T *rettv)
{
  timer_T *timer;

  for (timer = first_timer; timer != NULL; timer = timer->tr_next)
    if (timer->tr_id != -1)
      add_timer_info(rettv, timer);
}

/*
 * Mark references in partials of timers.
 */
int set_ref_in_timer(int copyID)
{
  int abort = FALSE;
  timer_T *timer;
  typval_T tv;

  for (timer = first_timer; timer != NULL; timer = timer->tr_next)
  {
    if (timer->tr_callback.cb_partial != NULL)
    {
      tv.v_type = VAR_PARTIAL;
      tv.vval.v_partial = timer->tr_callback.cb_partial;
    }
    else
    {
      tv.v_type = VAR_FUNC;
      tv.vval.v_string = timer->tr_callback.cb_name;
    }
    abort = abort || set_ref_in_item(&tv, copyID, NULL, NULL);
  }
  return abort;
}

#if defined(EXITFREE) || defined(PROTO)
void timer_free_all()
{
  timer_T *timer;

  while (first_timer != NULL)
  {
    timer = first_timer;
    remove_timer(timer);
    free_timer(timer);
  }
}
#endif
#endif

#if defined(FEAT_PROFILE) || defined(PROTO)
/*
 * Functions for profiling.
 */
static void script_dump_profile(FILE *fd);
static proftime_T prof_wait_time;

/*
 * Add the time "tm2" to "tm".
 */
void profile_add(proftime_T *tm, proftime_T *tm2)
{
#ifdef MSWIN
  tm->QuadPart += tm2->QuadPart;
#else
  tm->tv_usec += tm2->tv_usec;
  tm->tv_sec += tm2->tv_sec;
  if (tm->tv_usec >= 1000000)
  {
    tm->tv_usec -= 1000000;
    ++tm->tv_sec;
  }
#endif
}

/*
 * Add the "self" time from the total time and the children's time.
 */
void profile_self(proftime_T *self, proftime_T *total, proftime_T *children)
{
  /* Check that the result won't be negative.  Can happen with recursive
     * calls. */
#ifdef MSWIN
  if (total->QuadPart <= children->QuadPart)
    return;
#else
  if (total->tv_sec < children->tv_sec || (total->tv_sec == children->tv_sec && total->tv_usec <= children->tv_usec))
    return;
#endif
  profile_add(self, total);
  profile_sub(self, children);
}

/*
 * Get the current waittime.
 */
void profile_get_wait(proftime_T *tm)
{
  *tm = prof_wait_time;
}

/*
 * Subtract the passed waittime since "tm" from "tma".
 */
void profile_sub_wait(proftime_T *tm, proftime_T *tma)
{
  proftime_T tm3 = prof_wait_time;

  profile_sub(&tm3, tm);
  profile_sub(tma, &tm3);
}

/*
 * Return TRUE if "tm1" and "tm2" are equal.
 */
int profile_equal(proftime_T *tm1, proftime_T *tm2)
{
#ifdef MSWIN
  return (tm1->QuadPart == tm2->QuadPart);
#else
  return (tm1->tv_usec == tm2->tv_usec && tm1->tv_sec == tm2->tv_sec);
#endif
}

/*
 * Return <0, 0 or >0 if "tm1" < "tm2", "tm1" == "tm2" or "tm1" > "tm2"
 */
int profile_cmp(const proftime_T *tm1, const proftime_T *tm2)
{
#ifdef MSWIN
  return (int)(tm2->QuadPart - tm1->QuadPart);
#else
  if (tm1->tv_sec == tm2->tv_sec)
    return tm2->tv_usec - tm1->tv_usec;
  return tm2->tv_sec - tm1->tv_sec;
#endif
}

static char_u *profile_fname = NULL;
static proftime_T pause_time;

/*
 * ":profile cmd args"
 */
void ex_profile(exarg_T *eap)
{
  char_u *e;
  int len;

  e = skiptowhite(eap->arg);
  len = (int)(e - eap->arg);
  e = skipwhite(e);

  if (len == 5 && STRNCMP(eap->arg, "start", 5) == 0 && *e != NUL)
  {
    vim_free(profile_fname);
    profile_fname = expand_env_save_opt(e, TRUE);
    do_profiling = PROF_YES;
    profile_zero(&prof_wait_time);
    set_vim_var_nr(VV_PROFILING, 1L);
  }
  else if (do_profiling == PROF_NONE)
    emsg(_("E750: First use \":profile start {fname}\""));
  else if (STRCMP(eap->arg, "pause") == 0)
  {
    if (do_profiling == PROF_YES)
      profile_start(&pause_time);
    do_profiling = PROF_PAUSED;
  }
  else if (STRCMP(eap->arg, "continue") == 0)
  {
    if (do_profiling == PROF_PAUSED)
    {
      profile_end(&pause_time);
      profile_add(&prof_wait_time, &pause_time);
    }
    do_profiling = PROF_YES;
  }
  else
  {
    /* The rest is similar to ":breakadd". */
    ex_breakadd(eap);
  }
}

/* Command line expansion for :profile. */
static enum {
  PEXP_SUBCMD, /* expand :profile sub-commands */
  PEXP_FUNC    /* expand :profile func {funcname} */
} pexpand_what;

static char *pexpand_cmds[] = {
    "start",
#define PROFCMD_START 0
    "pause",
#define PROFCMD_PAUSE 1
    "continue",
#define PROFCMD_CONTINUE 2
    "func",
#define PROFCMD_FUNC 3
    "file",
#define PROFCMD_FILE 4
    NULL
#define PROFCMD_LAST 5
};

/*
 * Function given to ExpandGeneric() to obtain the profile command
 * specific expansion.
 */
char_u *
get_profile_name(expand_T *xp UNUSED, int idx)
{
  switch (pexpand_what)
  {
  case PEXP_SUBCMD:
    return (char_u *)pexpand_cmds[idx];
  /* case PEXP_FUNC: TODO */
  default:
    return NULL;
  }
}

/*
 * Handle command line completion for :profile command.
 */
void set_context_in_profile_cmd(expand_T *xp, char_u *arg)
{
  char_u *end_subcmd;

  /* Default: expand subcommands. */
  xp->xp_context = EXPAND_PROFILE;
  pexpand_what = PEXP_SUBCMD;
  xp->xp_pattern = arg;

  end_subcmd = skiptowhite(arg);
  if (*end_subcmd == NUL)
    return;

  if (end_subcmd - arg == 5 && STRNCMP(arg, "start", 5) == 0)
  {
    xp->xp_context = EXPAND_FILES;
    xp->xp_pattern = skipwhite(end_subcmd);
    return;
  }

  /* TODO: expand function names after "func" */
  xp->xp_context = EXPAND_NOTHING;
}

/*
 * Dump the profiling info.
 */
void profile_dump(void)
{
  FILE *fd;

  if (profile_fname != NULL)
  {
    fd = mch_fopen((char *)profile_fname, "w");
    if (fd == NULL)
      semsg(_(e_notopen), profile_fname);
    else
    {
      script_dump_profile(fd);
      func_dump_profile(fd);
      fclose(fd);
    }
  }
}

/*
 * Start profiling script "fp".
 */
static void
script_do_profile(scriptitem_T *si)
{
  si->sn_pr_count = 0;
  profile_zero(&si->sn_pr_total);
  profile_zero(&si->sn_pr_self);

  ga_init2(&si->sn_prl_ga, sizeof(sn_prl_T), 100);
  si->sn_prl_idx = -1;
  si->sn_prof_on = TRUE;
  si->sn_pr_nest = 0;
}

/*
 * Save time when starting to invoke another script or function.
 */
void script_prof_save(
    proftime_T *tm) /* place to store wait time */
{
  scriptitem_T *si;

  if (current_sctx.sc_sid > 0 && current_sctx.sc_sid <= script_items.ga_len)
  {
    si = &SCRIPT_ITEM(current_sctx.sc_sid);
    if (si->sn_prof_on && si->sn_pr_nest++ == 0)
      profile_start(&si->sn_pr_child);
  }
  profile_get_wait(tm);
}

/*
 * Count time spent in children after invoking another script or function.
 */
void script_prof_restore(proftime_T *tm)
{
  scriptitem_T *si;

  if (current_sctx.sc_sid > 0 && current_sctx.sc_sid <= script_items.ga_len)
  {
    si = &SCRIPT_ITEM(current_sctx.sc_sid);
    if (si->sn_prof_on && --si->sn_pr_nest == 0)
    {
      profile_end(&si->sn_pr_child);
      profile_sub_wait(tm, &si->sn_pr_child); /* don't count wait time */
      profile_add(&si->sn_pr_children, &si->sn_pr_child);
      profile_add(&si->sn_prl_children, &si->sn_pr_child);
    }
  }
}

static proftime_T inchar_time;

/*
 * Called when starting to wait for the user to type a character.
 */
void prof_inchar_enter(void)
{
  profile_start(&inchar_time);
}

/*
 * Called when finished waiting for the user to type a character.
 */
void prof_inchar_exit(void)
{
  profile_end(&inchar_time);
  profile_add(&prof_wait_time, &inchar_time);
}

/*
 * Dump the profiling results for all scripts in file "fd".
 */
static void
script_dump_profile(FILE *fd)
{
  int id;
  scriptitem_T *si;
  int i;
  FILE *sfd;
  sn_prl_T *pp;

  for (id = 1; id <= script_items.ga_len; ++id)
  {
    si = &SCRIPT_ITEM(id);
    if (si->sn_prof_on)
    {
      fprintf(fd, "SCRIPT  %s\n", si->sn_name);
      if (si->sn_pr_count == 1)
        fprintf(fd, "Sourced 1 time\n");
      else
        fprintf(fd, "Sourced %d times\n", si->sn_pr_count);
      fprintf(fd, "Total time: %s\n", profile_msg(&si->sn_pr_total));
      fprintf(fd, " Self time: %s\n", profile_msg(&si->sn_pr_self));
      fprintf(fd, "\n");
      fprintf(fd, "count  total (s)   self (s)\n");

      sfd = mch_fopen((char *)si->sn_name, "r");
      if (sfd == NULL)
        fprintf(fd, "Cannot open file!\n");
      else
      {
        /* Keep going till the end of file, so that trailing
		 * continuation lines are listed. */
        for (i = 0;; ++i)
        {
          if (vim_fgets(IObuff, IOSIZE, sfd))
            break;
          /* When a line has been truncated, append NL, taking care
		     * of multi-byte characters . */
          if (IObuff[IOSIZE - 2] != NUL && IObuff[IOSIZE - 2] != NL)
          {
            int n = IOSIZE - 2;

            if (enc_utf8)
            {
              /* Move to the first byte of this char.
			     * utf_head_off() doesn't work, because it checks
			     * for a truncated character. */
              while (n > 0 && (IObuff[n] & 0xc0) == 0x80)
                --n;
            }
            else if (has_mbyte)
              n -= mb_head_off(IObuff, IObuff + n);
            IObuff[n] = NL;
            IObuff[n + 1] = NUL;
          }
          if (i < si->sn_prl_ga.ga_len && (pp = &PRL_ITEM(si, i))->snp_count > 0)
          {
            fprintf(fd, "%5d ", pp->snp_count);
            if (profile_equal(&pp->sn_prl_total, &pp->sn_prl_self))
              fprintf(fd, "           ");
            else
              fprintf(fd, "%s ", profile_msg(&pp->sn_prl_total));
            fprintf(fd, "%s ", profile_msg(&pp->sn_prl_self));
          }
          else
            fprintf(fd, "                            ");
          fprintf(fd, "%s", IObuff);
        }
        fclose(sfd);
      }
      fprintf(fd, "\n");
    }
  }
}

/*
 * Return TRUE when a function defined in the current script should be
 * profiled.
 */
int prof_def_func(void)
{
  if (current_sctx.sc_sid > 0)
    return SCRIPT_ITEM(current_sctx.sc_sid).sn_pr_force;
  return FALSE;
}

#endif
#endif

/*
 * If 'autowrite' option set, try to write the file.
 * Careful: autocommands may make "buf" invalid!
 *
 * return FAIL for failure, OK otherwise
 */
int autowrite(buf_T *buf, int forceit)
{
  int r;
  bufref_T bufref;

  if (!(p_aw || p_awa) || !p_write
#ifdef FEAT_QUICKFIX
      /* never autowrite a "nofile" or "nowrite" buffer */
      || bt_dontwrite(buf)
#endif
      || (!forceit && buf->b_p_ro) || buf->b_ffname == NULL)
    return FAIL;
  set_bufref(&bufref, buf);
  r = buf_write_all(buf, forceit);

  /* Writing may succeed but the buffer still changed, e.g., when there is a
     * conversion error.  We do want to return FAIL then. */
  if (bufref_valid(&bufref) && bufIsChanged(buf))
    r = FAIL;
  return r;
}

/*
 * Flush all buffers, except the ones that are readonly or are never written.
 */
void autowrite_all(void)
{
  buf_T *buf;

  if (!(p_aw || p_awa) || !p_write)
    return;
  FOR_ALL_BUFFERS(buf)
  if (bufIsChanged(buf) && !buf->b_p_ro && !bt_dontwrite(buf))
  {
    bufref_T bufref;

    set_bufref(&bufref, buf);

    (void)buf_write_all(buf, FALSE);

    /* an autocommand may have deleted the buffer */
    if (!bufref_valid(&bufref))
      buf = firstbuf;
  }
}

/*
 * Return TRUE if buffer was changed and cannot be abandoned.
 * For flags use the CCGD_ values.
 */
int check_changed(buf_T *buf, int flags)
{
  int forceit = (flags & CCGD_FORCEIT);
  bufref_T bufref;

  set_bufref(&bufref, buf);

  if (!forceit && bufIsChanged(buf) && ((flags & CCGD_MULTWIN) || buf->b_nwindows <= 1) && (!(flags & CCGD_AW) || autowrite(buf, forceit) == FAIL))
  {
    if (flags & CCGD_EXCMD)
      no_write_message();
    else
      no_write_message_nobang(curbuf);
    return TRUE;
  }
  return FALSE;
}

/*
 * Return TRUE if the buffer "buf" can be abandoned, either by making it
 * hidden, autowriting it or unloading it.
 */
int can_abandon(buf_T *buf, int forceit)
{
  return (buf_hide(buf) || !bufIsChanged(buf) || buf->b_nwindows > 1 || autowrite(buf, forceit) == OK || forceit);
}

/*
 * Add a buffer number to "bufnrs", unless it's already there.
 */
static void
add_bufnum(int *bufnrs, int *bufnump, int nr)
{
  int i;

  for (i = 0; i < *bufnump; ++i)
    if (bufnrs[i] == nr)
      return;
  bufnrs[*bufnump] = nr;
  *bufnump = *bufnump + 1;
}

/*
 * Return TRUE if any buffer was changed and cannot be abandoned.
 * That changed buffer becomes the current buffer.
 * When "unload" is TRUE the current buffer is unloaded instead of making it
 * hidden.  This is used for ":q!".
 */
int check_changed_any(
    int hidden, /* Only check hidden buffers */
    int unload)
{
  int ret = FALSE;
  buf_T *buf;
  int save;
  int i;
  int bufnum = 0;
  int bufcount = 0;
  int *bufnrs;
  tabpage_T *tp;
  win_T *wp;

  /* Make a list of all buffers, with the most important ones first. */
  FOR_ALL_BUFFERS(buf)
  ++bufcount;

  if (bufcount == 0)
    return FALSE;

  bufnrs = ALLOC_MULT(int, bufcount);
  if (bufnrs == NULL)
    return FALSE;

  /* curbuf */
  bufnrs[bufnum++] = curbuf->b_fnum;

  /* buffers in current tab */
  FOR_ALL_WINDOWS(wp)
  if (wp->w_buffer != curbuf)
    add_bufnum(bufnrs, &bufnum, wp->w_buffer->b_fnum);

  /* buffers in other tabs */
  FOR_ALL_TABPAGES(tp)
  if (tp != curtab)
    for (wp = tp->tp_firstwin; wp != NULL; wp = wp->w_next)
      add_bufnum(bufnrs, &bufnum, wp->w_buffer->b_fnum);

  /* any other buffer */
  FOR_ALL_BUFFERS(buf)
  add_bufnum(bufnrs, &bufnum, buf->b_fnum);

  for (i = 0; i < bufnum; ++i)
  {
    buf = buflist_findnr(bufnrs[i]);
    if (buf == NULL)
      continue;
    if ((!hidden || buf->b_nwindows == 0) && bufIsChanged(buf))
    {
      bufref_T bufref;

      set_bufref(&bufref, buf);
#ifdef FEAT_TERMINAL
      if (term_job_running(buf->b_term))
      {
        if (term_try_stop_job(buf) == FAIL)
          break;
      }
      else
#endif
          /* Try auto-writing the buffer.  If this fails but the buffer no
	     * longer exists it's not changed, that's OK. */
          if (check_changed(buf, (p_awa ? CCGD_AW : 0) | CCGD_MULTWIN | CCGD_ALLBUF) && bufref_valid(&bufref))
        break; /* didn't save - still changes */
    }
  }

  if (i >= bufnum)
    goto theend;

  /* Get here if "buf" cannot be abandoned. */
  ret = TRUE;
  exiting = FALSE;
  {
    /* There must be a wait_return for this message, do_buffer()
	 * may cause a redraw.  But wait_return() is a no-op when vgetc()
	 * is busy (Quit used from window menu), then make sure we don't
	 * cause a scroll up. */
    if (vgetc_busy > 0)
    {
      msg_row = cmdline_row;
      msg_col = 0;
      msg_didout = FALSE;
    }
    if (
#ifdef FEAT_TERMINAL
        term_job_running(buf->b_term)
            ? semsg(_("E947: Job still running in buffer \"%s\""),
                    buf->b_fname)
            :
#endif
            semsg(_("E162: No write since last change for buffer \"%s\""),
                  buf_spname(buf) != NULL ? buf_spname(buf) : buf->b_fname))
    {
      save = no_wait_return;
      no_wait_return = FALSE;
      wait_return(FALSE);
      no_wait_return = save;
    }
  }

  /* Try to find a window that contains the buffer. */
  if (buf != curbuf)
    FOR_ALL_TAB_WINDOWS(tp, wp)
  if (wp->w_buffer == buf)
  {
    bufref_T bufref;

    set_bufref(&bufref, buf);

    goto_tabpage_win(tp, wp);

    // Paranoia: did autocmd wipe out the buffer with changes?
    if (!bufref_valid(&bufref))
      goto theend;
    goto buf_found;
  }
buf_found:

  /* Open the changed buffer in the current window. */
  if (buf != curbuf)
    set_curbuf(buf, unload ? DOBUF_UNLOAD : DOBUF_GOTO);

theend:
  vim_free(bufnrs);
  return ret;
}

/*
 * return FAIL if there is no file name, OK if there is one
 * give error message for FAIL
 */
int check_fname(void)
{
  if (curbuf->b_ffname == NULL)
  {
    emsg(_(e_noname));
    return FAIL;
  }
  return OK;
}

/*
 * flush the contents of a buffer, unless it has no file name
 *
 * return FAIL for failure, OK otherwise
 */
int buf_write_all(buf_T *buf, int forceit)
{
  int retval;
  buf_T *old_curbuf = curbuf;

  retval = (buf_write(buf, buf->b_ffname, buf->b_fname,
                      (linenr_T)1, buf->b_ml.ml_line_count, NULL,
                      FALSE, forceit, TRUE, FALSE));
  if (curbuf != old_curbuf)
  {
    msg_source(HL_ATTR(HLF_W));
    msg(_("Warning: Entered other buffer unexpectedly (check autocommands)"));
  }
  return retval;
}

/*
 * Code to handle the argument list.
 */

static int do_arglist(char_u *str, int what, int after, int will_edit);
static void alist_check_arg_idx(void);
static void alist_add_list(int count, char_u **files, int after, int will_edit);
#define AL_SET 1
#define AL_ADD 2
#define AL_DEL 3

/*
 * Isolate one argument, taking backticks.
 * Changes the argument in-place, puts a NUL after it.  Backticks remain.
 * Return a pointer to the start of the next argument.
 */
static char_u *
do_one_arg(char_u *str)
{
  char_u *p;
  int inbacktick;

  inbacktick = FALSE;
  for (p = str; *str; ++str)
  {
    /* When the backslash is used for escaping the special meaning of a
	 * character we need to keep it until wildcard expansion. */
    if (rem_backslash(str))
    {
      *p++ = *str++;
      *p++ = *str;
    }
    else
    {
      /* An item ends at a space not in backticks */
      if (!inbacktick && vim_isspace(*str))
        break;
      if (*str == '`')
        inbacktick ^= TRUE;
      *p++ = *str;
    }
  }
  str = skipwhite(str);
  *p = NUL;

  return str;
}

/*
 * Separate the arguments in "str" and return a list of pointers in the
 * growarray "gap".
 */
static int
get_arglist(garray_T *gap, char_u *str, int escaped)
{
  ga_init2(gap, (int)sizeof(char_u *), 20);
  while (*str != NUL)
  {
    if (ga_grow(gap, 1) == FAIL)
    {
      ga_clear(gap);
      return FAIL;
    }
    ((char_u **)gap->ga_data)[gap->ga_len++] = str;

    /* If str is escaped, don't handle backslashes or spaces */
    if (!escaped)
      return OK;

    /* Isolate one argument, change it in-place, put a NUL after it. */
    str = do_one_arg(str);
  }
  return OK;
}

#if defined(FEAT_QUICKFIX) || defined(PROTO)
/*
 * Parse a list of arguments (file names), expand them and return in
 * "fnames[fcountp]".  When "wig" is TRUE, removes files matching 'wildignore'.
 * Return FAIL or OK.
 */
int get_arglist_exp(
    char_u *str,
    int *fcountp,
    char_u ***fnamesp,
    int wig)
{
  garray_T ga;
  int i;

  if (get_arglist(&ga, str, TRUE) == FAIL)
    return FAIL;
  if (wig == TRUE)
    i = expand_wildcards(ga.ga_len, (char_u **)ga.ga_data,
                         fcountp, fnamesp, EW_FILE | EW_NOTFOUND);
  else
    i = gen_expand_wildcards(ga.ga_len, (char_u **)ga.ga_data,
                             fcountp, fnamesp, EW_FILE | EW_NOTFOUND);

  ga_clear(&ga);
  return i;
}
#endif

/*
 * Redefine the argument list.
 */
void set_arglist(char_u *str)
{
  do_arglist(str, AL_SET, 0, FALSE);
}

/*
 * "what" == AL_SET: Redefine the argument list to 'str'.
 * "what" == AL_ADD: add files in 'str' to the argument list after "after".
 * "what" == AL_DEL: remove files in 'str' from the argument list.
 *
 * Return FAIL for failure, OK otherwise.
 */
static int
do_arglist(
    char_u *str,
    int what,
    int after UNUSED, // 0 means before first one
    int will_edit)    // will edit added argument
{
  garray_T new_ga;
  int exp_count;
  char_u **exp_files;
  int i;
  char_u *p;
  int match;
  int arg_escaped = TRUE;

  /*
     * Set default argument for ":argadd" command.
     */
  if (what == AL_ADD && *str == NUL)
  {
    if (curbuf->b_ffname == NULL)
      return FAIL;
    str = curbuf->b_fname;
    arg_escaped = FALSE;
  }

  /*
     * Collect all file name arguments in "new_ga".
     */
  if (get_arglist(&new_ga, str, arg_escaped) == FAIL)
    return FAIL;

  if (what == AL_DEL)
  {
    regmatch_T regmatch;
    int didone;

    /*
	 * Delete the items: use each item as a regexp and find a match in the
	 * argument list.
	 */
    regmatch.rm_ic = p_fic; /* ignore case when 'fileignorecase' is set */
    for (i = 0; i < new_ga.ga_len && !got_int; ++i)
    {
      p = ((char_u **)new_ga.ga_data)[i];
      p = file_pat_to_reg_pat(p, NULL, NULL, FALSE);
      if (p == NULL)
        break;
      regmatch.regprog = vim_regcomp(p, p_magic ? RE_MAGIC : 0);
      if (regmatch.regprog == NULL)
      {
        vim_free(p);
        break;
      }

      didone = FALSE;
      for (match = 0; match < ARGCOUNT; ++match)
        if (vim_regexec(&regmatch, alist_name(&ARGLIST[match]),
                        (colnr_T)0))
        {
          didone = TRUE;
          vim_free(ARGLIST[match].ae_fname);
          mch_memmove(ARGLIST + match, ARGLIST + match + 1,
                      (ARGCOUNT - match - 1) * sizeof(aentry_T));
          --ALIST(curwin)->al_ga.ga_len;
          if (curwin->w_arg_idx > match)
            --curwin->w_arg_idx;
          --match;
        }

      vim_regfree(regmatch.regprog);
      vim_free(p);
      if (!didone)
        semsg(_(e_nomatch2), ((char_u **)new_ga.ga_data)[i]);
    }
    ga_clear(&new_ga);
  }
  else
  {
    i = expand_wildcards(new_ga.ga_len, (char_u **)new_ga.ga_data,
                         &exp_count, &exp_files, EW_DIR | EW_FILE | EW_ADDSLASH | EW_NOTFOUND);
    ga_clear(&new_ga);
    if (i == FAIL || exp_count == 0)
    {
      emsg(_(e_nomatch));
      return FAIL;
    }

    if (what == AL_ADD)
    {
      alist_add_list(exp_count, exp_files, after, will_edit);
      vim_free(exp_files);
    }
    else /* what == AL_SET */
      alist_set(ALIST(curwin), exp_count, exp_files, will_edit, NULL, 0);
  }

  alist_check_arg_idx();

  return OK;
}

/*
 * Check the validity of the arg_idx for each other window.
 */
static void
alist_check_arg_idx(void)
{
  win_T *win;
  tabpage_T *tp;

  FOR_ALL_TAB_WINDOWS(tp, win)
  if (win->w_alist == curwin->w_alist)
    check_arg_idx(win);
}

/*
 * Return TRUE if window "win" is editing the file at the current argument
 * index.
 */
static int
editing_arg_idx(win_T *win)
{
  return !(win->w_arg_idx >= WARGCOUNT(win) || (win->w_buffer->b_fnum != WARGLIST(win)[win->w_arg_idx].ae_fnum && (win->w_buffer->b_ffname == NULL || !(fullpathcmp(
                                                                                                                                                            alist_name(&WARGLIST(win)[win->w_arg_idx]),
                                                                                                                                                            win->w_buffer->b_ffname, TRUE, TRUE) &
                                                                                                                                                        FPC_SAME))));
}

/*
 * Check if window "win" is editing the w_arg_idx file in its argument list.
 */
void check_arg_idx(win_T *win)
{
  if (WARGCOUNT(win) > 1 && !editing_arg_idx(win))
  {
    /* We are not editing the current entry in the argument list.
	 * Set "arg_had_last" if we are editing the last one. */
    win->w_arg_idx_invalid = TRUE;
    if (win->w_arg_idx != WARGCOUNT(win) - 1 && arg_had_last == FALSE && ALIST(win) == &global_alist && GARGCOUNT > 0 && win->w_arg_idx < GARGCOUNT && (win->w_buffer->b_fnum == GARGLIST[GARGCOUNT - 1].ae_fnum || (win->w_buffer->b_ffname != NULL && (fullpathcmp(alist_name(&GARGLIST[GARGCOUNT - 1]), win->w_buffer->b_ffname, TRUE, TRUE) & FPC_SAME))))
      arg_had_last = TRUE;
  }
  else
  {
    /* We are editing the current entry in the argument list.
	 * Set "arg_had_last" if it's also the last one */
    win->w_arg_idx_invalid = FALSE;
    if (win->w_arg_idx == WARGCOUNT(win) - 1 && win->w_alist == &global_alist)
      arg_had_last = TRUE;
  }
}

/*
 * ":args", ":argslocal" and ":argsglobal".
 */
void ex_args(exarg_T *eap)
{
  int i;

  if (eap->cmdidx != CMD_args)
  {
    alist_unlink(ALIST(curwin));
    if (eap->cmdidx == CMD_argglobal)
      ALIST(curwin) = &global_alist;
    else /* eap->cmdidx == CMD_arglocal */
      alist_new();
  }

  if (*eap->arg != NUL)
  {
    /*
	 * ":args file ..": define new argument list, handle like ":next"
	 * Also for ":argslocal file .." and ":argsglobal file ..".
	 */
    ex_next(eap);
  }
  else if (eap->cmdidx == CMD_args)
  {
    /*
	 * ":args": list arguments.
	 */
    if (ARGCOUNT > 0)
    {
      char_u **items = ALLOC_MULT(char_u *, ARGCOUNT);

      if (items != NULL)
      {
        /* Overwrite the command, for a short list there is no
		 * scrolling required and no wait_return(). */
        gotocmdline(TRUE);

        for (i = 0; i < ARGCOUNT; ++i)
          items[i] = alist_name(&ARGLIST[i]);
        list_in_columns(items, ARGCOUNT, curwin->w_arg_idx);
        vim_free(items);
      }
    }
  }
  else if (eap->cmdidx == CMD_arglocal)
  {
    garray_T *gap = &curwin->w_alist->al_ga;

    /*
	 * ":argslocal": make a local copy of the global argument list.
	 */
    if (ga_grow(gap, GARGCOUNT) == OK)
      for (i = 0; i < GARGCOUNT; ++i)
        if (GARGLIST[i].ae_fname != NULL)
        {
          AARGLIST(curwin->w_alist)
          [gap->ga_len].ae_fname =
              vim_strsave(GARGLIST[i].ae_fname);
          AARGLIST(curwin->w_alist)
          [gap->ga_len].ae_fnum =
              GARGLIST[i].ae_fnum;
          ++gap->ga_len;
        }
  }
}

/*
 * ":previous", ":sprevious", ":Next" and ":sNext".
 */
void ex_previous(exarg_T *eap)
{
  /* If past the last one already, go to the last one. */
  if (curwin->w_arg_idx - (int)eap->line2 >= ARGCOUNT)
    do_argfile(eap, ARGCOUNT - 1);
  else
    do_argfile(eap, curwin->w_arg_idx - (int)eap->line2);
}

/*
 * ":rewind", ":first", ":sfirst" and ":srewind".
 */
void ex_rewind(exarg_T *eap)
{
  do_argfile(eap, 0);
}

/*
 * ":last" and ":slast".
 */
void ex_last(exarg_T *eap)
{
  do_argfile(eap, ARGCOUNT - 1);
}

/*
 * ":argument" and ":sargument".
 */
void ex_argument(exarg_T *eap)
{
  int i;

  if (eap->addr_count > 0)
    i = eap->line2 - 1;
  else
    i = curwin->w_arg_idx;
  do_argfile(eap, i);
}

/*
 * Edit file "argn" of the argument lists.
 */
void do_argfile(exarg_T *eap, int argn)
{
  int other;
  char_u *p;
  int old_arg_idx = curwin->w_arg_idx;

  if (NOT_IN_POPUP_WINDOW)
    return;
  if (argn < 0 || argn >= ARGCOUNT)
  {
    if (ARGCOUNT <= 1)
      emsg(_("E163: There is only one file to edit"));
    else if (argn < 0)
      emsg(_("E164: Cannot go before first file"));
    else
      emsg(_("E165: Cannot go beyond last file"));
  }
  else
  {
    setpcmark();

    /* split window or create new tab page first */
    if (*eap->cmd == 's' || cmdmod.tab != 0)
    {
      if (win_split(0, 0) == FAIL)
        return;
      RESET_BINDING(curwin);
    }
    else
    {
      /*
	     * if 'hidden' set, only check for changed file when re-editing
	     * the same buffer
	     */
      other = TRUE;
      if (buf_hide(curbuf))
      {
        p = fix_fname(alist_name(&ARGLIST[argn]));
        other = otherfile(p);
        vim_free(p);
      }
      if ((!buf_hide(curbuf) || !other) && check_changed(curbuf, CCGD_AW | (other ? 0 : CCGD_MULTWIN) | (eap->forceit ? CCGD_FORCEIT : 0) | CCGD_EXCMD))
        return;
    }

    curwin->w_arg_idx = argn;
    if (argn == ARGCOUNT - 1 && curwin->w_alist == &global_alist)
      arg_had_last = TRUE;

    /* Edit the file; always use the last known line number.
	 * When it fails (e.g. Abort for already edited file) restore the
	 * argument index. */
    if (do_ecmd(0, alist_name(&ARGLIST[curwin->w_arg_idx]), NULL,
                eap, ECMD_LAST,
                (buf_hide(curwin->w_buffer) ? ECMD_HIDE : 0) + (eap->forceit ? ECMD_FORCEIT : 0), curwin) == FAIL)
      curwin->w_arg_idx = old_arg_idx;
    /* like Vi: set the mark where the cursor is in the file. */
    else if (eap->cmdidx != CMD_argdo)
      setmark('\'');
  }
}

/*
 * ":next", and commands that behave like it.
 */
void ex_next(exarg_T *eap)
{
  int i;

  /*
     * check for changed buffer now, if this fails the argument list is not
     * redefined.
     */
  if (buf_hide(curbuf) || eap->cmdidx == CMD_snext || !check_changed(curbuf, CCGD_AW | (eap->forceit ? CCGD_FORCEIT : 0) | CCGD_EXCMD))
  {
    if (*eap->arg != NUL) /* redefine file list */
    {
      if (do_arglist(eap->arg, AL_SET, 0, TRUE) == FAIL)
        return;
      i = 0;
    }
    else
      i = curwin->w_arg_idx + (int)eap->line2;
    do_argfile(eap, i);
  }
}

/*
 * ":argedit"
 */
void ex_argedit(exarg_T *eap)
{
  int i = eap->addr_count ? (int)eap->line2 : curwin->w_arg_idx + 1;
  // Whether curbuf will be reused, curbuf->b_ffname will be set.
  int curbuf_is_reusable = curbuf_reusable();

  if (do_arglist(eap->arg, AL_ADD, i, TRUE) == FAIL)
    return;

  if (curwin->w_arg_idx == 0 && (curbuf->b_ml.ml_flags & ML_EMPTY) && (curbuf->b_ffname == NULL || curbuf_is_reusable))
    i = 0;
  /* Edit the argument. */
  if (i < ARGCOUNT)
    do_argfile(eap, i);
}

/*
 * ":argadd"
 */
void ex_argadd(exarg_T *eap)
{
  do_arglist(eap->arg, AL_ADD,
             eap->addr_count > 0 ? (int)eap->line2 : curwin->w_arg_idx + 1,
             FALSE);
}

/*
 * ":argdelete"
 */
void ex_argdelete(exarg_T *eap)
{
  int i;
  int n;

  if (eap->addr_count > 0)
  {
    /* ":1,4argdel": Delete all arguments in the range. */
    if (eap->line2 > ARGCOUNT)
      eap->line2 = ARGCOUNT;
    n = eap->line2 - eap->line1 + 1;
    if (*eap->arg != NUL)
      /* Can't have both a range and an argument. */
      emsg(_(e_invarg));
    else if (n <= 0)
    {
      /* Don't give an error for ":%argdel" if the list is empty. */
      if (eap->line1 != 1 || eap->line2 != 0)
        emsg(_(e_invrange));
    }
    else
    {
      for (i = eap->line1; i <= eap->line2; ++i)
        vim_free(ARGLIST[i - 1].ae_fname);
      mch_memmove(ARGLIST + eap->line1 - 1, ARGLIST + eap->line2,
                  (size_t)((ARGCOUNT - eap->line2) * sizeof(aentry_T)));
      ALIST(curwin)->al_ga.ga_len -= n;
      if (curwin->w_arg_idx >= eap->line2)
        curwin->w_arg_idx -= n;
      else if (curwin->w_arg_idx > eap->line1)
        curwin->w_arg_idx = eap->line1;
      if (ARGCOUNT == 0)
        curwin->w_arg_idx = 0;
      else if (curwin->w_arg_idx >= ARGCOUNT)
        curwin->w_arg_idx = ARGCOUNT - 1;
    }
  }
  else if (*eap->arg == NUL)
    emsg(_(e_argreq));
  else
    do_arglist(eap->arg, AL_DEL, 0, FALSE);
}

/*
 * ":argdo", ":windo", ":bufdo", ":tabdo", ":cdo", ":ldo", ":cfdo" and ":lfdo"
 */
void ex_listdo(exarg_T *eap)
{
  int i;
  win_T *wp;
  tabpage_T *tp;
  buf_T *buf = curbuf;
  int next_fnum = 0;
  char_u *p_shm_save;
#ifdef FEAT_QUICKFIX
  int qf_size = 0;
  int qf_idx;
#endif

#ifndef FEAT_QUICKFIX
  if (eap->cmdidx == CMD_cdo || eap->cmdidx == CMD_ldo ||
      eap->cmdidx == CMD_cfdo || eap->cmdidx == CMD_lfdo)
  {
    ex_ni(eap);
    return;
  }
#endif

  if (eap->cmdidx == CMD_windo || eap->cmdidx == CMD_tabdo || buf_hide(curbuf) || !check_changed(curbuf, CCGD_AW | (eap->forceit ? CCGD_FORCEIT : 0) | CCGD_EXCMD))
  {
    i = 0;
    /* start at the eap->line1 argument/window/buffer */
    wp = firstwin;
    tp = first_tabpage;
    switch (eap->cmdidx)
    {
    case CMD_windo:
      for (; wp != NULL && i + 1 < eap->line1; wp = wp->w_next)
        i++;
      break;
    case CMD_tabdo:
      for (; tp != NULL && i + 1 < eap->line1; tp = tp->tp_next)
        i++;
      break;
    case CMD_argdo:
      i = eap->line1 - 1;
      break;
    default:
      break;
    }
    /* set pcmark now */
    if (eap->cmdidx == CMD_bufdo)
    {
      /* Advance to the first listed buffer after "eap->line1". */
      for (buf = firstbuf; buf != NULL && (buf->b_fnum < eap->line1 || !buf->b_p_bl); buf = buf->b_next)
        if (buf->b_fnum > eap->line2)
        {
          buf = NULL;
          break;
        }
      if (buf != NULL)
        goto_buffer(eap, DOBUF_FIRST, FORWARD, buf->b_fnum);
    }
#ifdef FEAT_QUICKFIX
    else if (eap->cmdidx == CMD_cdo || eap->cmdidx == CMD_ldo || eap->cmdidx == CMD_cfdo || eap->cmdidx == CMD_lfdo)
    {
      qf_size = qf_get_valid_size(eap);
      if (qf_size <= 0 || eap->line1 > qf_size)
        buf = NULL;
      else
      {
        ex_cc(eap);

        buf = curbuf;
        i = eap->line1 - 1;
        if (eap->addr_count <= 0)
          /* default is all the quickfix/location list entries */
          eap->line2 = qf_size;
      }
    }
#endif
    else
      setpcmark();
    listcmd_busy = TRUE; /* avoids setting pcmark below */

    while (!got_int && buf != NULL)
    {
      if (eap->cmdidx == CMD_argdo)
      {
        /* go to argument "i" */
        if (i == ARGCOUNT)
          break;
        /* Don't call do_argfile() when already there, it will try
		 * reloading the file. */
        if (curwin->w_arg_idx != i || !editing_arg_idx(curwin))
        {
          /* Clear 'shm' to avoid that the file message overwrites
		     * any output from the command. */
          p_shm_save = vim_strsave(p_shm);
          set_option_value((char_u *)"shm", 0L, (char_u *)"", 0);
          do_argfile(eap, i);
          set_option_value((char_u *)"shm", 0L, p_shm_save, 0);
          vim_free(p_shm_save);
        }
        if (curwin->w_arg_idx != i)
          break;
      }
      else if (eap->cmdidx == CMD_windo)
      {
        /* go to window "wp" */
        if (!win_valid(wp))
          break;
        win_goto(wp);
        if (curwin != wp)
          break; /* something must be wrong */
        wp = curwin->w_next;
      }
      else if (eap->cmdidx == CMD_tabdo)
      {
        /* go to window "tp" */
        if (!valid_tabpage(tp))
          break;
        goto_tabpage_tp(tp, TRUE, TRUE);
        tp = tp->tp_next;
      }
      else if (eap->cmdidx == CMD_bufdo)
      {
        /* Remember the number of the next listed buffer, in case
		 * ":bwipe" is used or autocommands do something strange. */
        next_fnum = -1;
        for (buf = curbuf->b_next; buf != NULL; buf = buf->b_next)
          if (buf->b_p_bl)
          {
            next_fnum = buf->b_fnum;
            break;
          }
      }

      ++i;

      /* execute the command */
      do_cmdline(eap->arg, eap->getline, eap->cookie,
                 DOCMD_VERBOSE + DOCMD_NOWAIT);

      if (eap->cmdidx == CMD_bufdo)
      {
        /* Done? */
        if (next_fnum < 0 || next_fnum > eap->line2)
          break;
        /* Check if the buffer still exists. */
        FOR_ALL_BUFFERS(buf)
        if (buf->b_fnum == next_fnum)
          break;
        if (buf == NULL)
          break;

        /* Go to the next buffer.  Clear 'shm' to avoid that the file
		 * message overwrites any output from the command. */
        p_shm_save = vim_strsave(p_shm);
        set_option_value((char_u *)"shm", 0L, (char_u *)"", 0);
        goto_buffer(eap, DOBUF_FIRST, FORWARD, next_fnum);
        set_option_value((char_u *)"shm", 0L, p_shm_save, 0);
        vim_free(p_shm_save);

        /* If autocommands took us elsewhere, quit here. */
        if (curbuf->b_fnum != next_fnum)
          break;
      }

#ifdef FEAT_QUICKFIX
      if (eap->cmdidx == CMD_cdo || eap->cmdidx == CMD_ldo || eap->cmdidx == CMD_cfdo || eap->cmdidx == CMD_lfdo)
      {
        if (i >= qf_size || i >= eap->line2)
          break;

        qf_idx = qf_get_cur_idx(eap);

        ex_cnext(eap);

        /* If jumping to the next quickfix entry fails, quit here */
        if (qf_get_cur_idx(eap) == qf_idx)
          break;
      }
#endif

      if (eap->cmdidx == CMD_windo)
      {
        validate_cursor(); /* cursor may have moved */

        /* required when 'scrollbind' has been set */
        if (curwin->w_p_scb)
          do_check_scrollbind(TRUE);
      }

      if (eap->cmdidx == CMD_windo || eap->cmdidx == CMD_tabdo)
        if (i + 1 > eap->line2)
          break;
      if (eap->cmdidx == CMD_argdo && i >= eap->line2)
        break;
    }
    listcmd_busy = FALSE;
  }
}

/*
 * Add files[count] to the arglist of the current window after arg "after".
 * The file names in files[count] must have been allocated and are taken over.
 * Files[] itself is not taken over.
 */
static void
alist_add_list(
    int count,
    char_u **files,
    int after,     // where to add: 0 = before first one
    int will_edit) // will edit adding argument
{
  int i;
  int old_argcount = ARGCOUNT;

  if (ga_grow(&ALIST(curwin)->al_ga, count) == OK)
  {
    if (after < 0)
      after = 0;
    if (after > ARGCOUNT)
      after = ARGCOUNT;
    if (after < ARGCOUNT)
      mch_memmove(&(ARGLIST[after + count]), &(ARGLIST[after]),
                  (ARGCOUNT - after) * sizeof(aentry_T));
    for (i = 0; i < count; ++i)
    {
      int flags = BLN_LISTED | (will_edit ? BLN_CURBUF : 0);

      ARGLIST[after + i].ae_fname = files[i];
      ARGLIST[after + i].ae_fnum = buflist_add(files[i], flags);
    }
    ALIST(curwin)->al_ga.ga_len += count;
    if (old_argcount > 0 && curwin->w_arg_idx >= after)
      curwin->w_arg_idx += count;
    return;
  }

  for (i = 0; i < count; ++i)
    vim_free(files[i]);
}

#if defined(FEAT_CMDL_COMPL) || defined(PROTO)
/*
 * Function given to ExpandGeneric() to obtain the possible arguments of the
 * argedit and argdelete commands.
 */
char_u *
get_arglist_name(expand_T *xp UNUSED, int idx)
{
  if (idx >= ARGCOUNT)
    return NULL;

  return alist_name(&ARGLIST[idx]);
}
#endif

#ifdef FEAT_EVAL
/*
 * ":compiler[!] {name}"
 */
void ex_compiler(exarg_T *eap)
{
  char_u *buf;
  char_u *old_cur_comp = NULL;
  char_u *p;

  if (*eap->arg == NUL)
  {
    /* List all compiler scripts. */
    do_cmdline_cmd((char_u *)"echo globpath(&rtp, 'compiler/*.vim')");
    /* ) keep the indenter happy... */
  }
  else
  {
    buf = alloc(STRLEN(eap->arg) + 14);
    if (buf != NULL)
    {
      if (eap->forceit)
      {
        /* ":compiler! {name}" sets global options */
        do_cmdline_cmd((char_u *)"command -nargs=* CompilerSet set <args>");
      }
      else
      {
        /* ":compiler! {name}" sets local options.
		 * To remain backwards compatible "current_compiler" is always
		 * used.  A user's compiler plugin may set it, the distributed
		 * plugin will then skip the settings.  Afterwards set
		 * "b:current_compiler" and restore "current_compiler".
		 * Explicitly prepend "g:" to make it work in a function. */
        old_cur_comp = get_var_value((char_u *)"g:current_compiler");
        if (old_cur_comp != NULL)
          old_cur_comp = vim_strsave(old_cur_comp);
        do_cmdline_cmd((char_u *)"command -nargs=* CompilerSet setlocal <args>");
      }
      do_unlet((char_u *)"g:current_compiler", TRUE);
      do_unlet((char_u *)"b:current_compiler", TRUE);

      sprintf((char *)buf, "compiler/%s.vim", eap->arg);
      if (source_runtime(buf, DIP_ALL) == FAIL)
        semsg(_("E666: compiler not supported: %s"), eap->arg);
      vim_free(buf);

      do_cmdline_cmd((char_u *)":delcommand CompilerSet");

      /* Set "b:current_compiler" from "current_compiler". */
      p = get_var_value((char_u *)"g:current_compiler");
      if (p != NULL)
        set_internal_string_var((char_u *)"b:current_compiler", p);

      /* Restore "current_compiler" for ":compiler {name}". */
      if (!eap->forceit)
      {
        if (old_cur_comp != NULL)
        {
          set_internal_string_var((char_u *)"g:current_compiler",
                                  old_cur_comp);
          vim_free(old_cur_comp);
        }
        else
          do_unlet((char_u *)"g:current_compiler", TRUE);
      }
    }
  }
}
#endif

/*
 * ":runtime [what] {name}"
 */
void ex_runtime(exarg_T *eap)
{
  char_u *arg = eap->arg;
  char_u *p = skiptowhite(arg);
  int len = (int)(p - arg);
  int flags = eap->forceit ? DIP_ALL : 0;

  if (STRNCMP(arg, "START", len) == 0)
  {
    flags += DIP_START + DIP_NORTP;
    arg = skipwhite(arg + len);
  }
  else if (STRNCMP(arg, "OPT", len) == 0)
  {
    flags += DIP_OPT + DIP_NORTP;
    arg = skipwhite(arg + len);
  }
  else if (STRNCMP(arg, "PACK", len) == 0)
  {
    flags += DIP_START + DIP_OPT + DIP_NORTP;
    arg = skipwhite(arg + len);
  }
  else if (STRNCMP(arg, "ALL", len) == 0)
  {
    flags += DIP_START + DIP_OPT;
    arg = skipwhite(arg + len);
  }

  source_runtime(arg, flags);
}

static void
source_callback(char_u *fname, void *cookie UNUSED)
{
  (void)do_source(fname, FALSE, DOSO_NONE);
}

/*
 * Find the file "name" in all directories in "path" and invoke
 * "callback(fname, cookie)".
 * "name" can contain wildcards.
 * When "flags" has DIP_ALL: source all files, otherwise only the first one.
 * When "flags" has DIP_DIR: find directories instead of files.
 * When "flags" has DIP_ERR: give an error message if there is no match.
 *
 * return FAIL when no file could be sourced, OK otherwise.
 */
int do_in_path(
    char_u *path,
    char_u *name,
    int flags,
    void (*callback)(char_u *fname, void *ck),
    void *cookie)
{
  char_u *rtp;
  char_u *np;
  char_u *buf;
  char_u *rtp_copy;
  char_u *tail;
  int num_files;
  char_u **files;
  int i;
  int did_one = FALSE;

  /* Make a copy of 'runtimepath'.  Invoking the callback may change the
     * value. */
  rtp_copy = vim_strsave(path);
  buf = alloc(MAXPATHL);
  if (buf != NULL && rtp_copy != NULL)
  {
    if (p_verbose > 1 && name != NULL)
    {
      verbose_enter();
      smsg(_("Searching for \"%s\" in \"%s\""),
           (char *)name, (char *)path);
      verbose_leave();
    }

    /* Loop over all entries in 'runtimepath'. */
    rtp = rtp_copy;
    while (*rtp != NUL && ((flags & DIP_ALL) || !did_one))
    {
      size_t buflen;

      /* Copy the path from 'runtimepath' to buf[]. */
      copy_option_part(&rtp, buf, MAXPATHL, ",");
      buflen = STRLEN(buf);

      /* Skip after or non-after directories. */
      if (flags & (DIP_NOAFTER | DIP_AFTER))
      {
        int is_after = buflen >= 5 && STRCMP(buf + buflen - 5, "after") == 0;

        if ((is_after && (flags & DIP_NOAFTER)) || (!is_after && (flags & DIP_AFTER)))
          continue;
      }

      if (name == NULL)
      {
        (*callback)(buf, (void *)&cookie);
        if (!did_one)
          did_one = (cookie == NULL);
      }
      else if (buflen + STRLEN(name) + 2 < MAXPATHL)
      {
        add_pathsep(buf);
        tail = buf + STRLEN(buf);

        /* Loop over all patterns in "name" */
        np = name;
        while (*np != NUL && ((flags & DIP_ALL) || !did_one))
        {
          /* Append the pattern from "name" to buf[]. */
          copy_option_part(&np, tail, (int)(MAXPATHL - (tail - buf)),
                           "\t ");

          if (p_verbose > 2)
          {
            verbose_enter();
            smsg(_("Searching for \"%s\""), buf);
            verbose_leave();
          }

          /* Expand wildcards, invoke the callback for each match. */
          if (gen_expand_wildcards(1, &buf, &num_files, &files,
                                   (flags & DIP_DIR) ? EW_DIR : EW_FILE) == OK)
          {
            for (i = 0; i < num_files; ++i)
            {
              (*callback)(files[i], cookie);
              did_one = TRUE;
              if (!(flags & DIP_ALL))
                break;
            }
            FreeWild(num_files, files);
          }
        }
      }
    }
  }
  vim_free(buf);
  vim_free(rtp_copy);
  if (!did_one && name != NULL)
  {
    char *basepath = path == p_rtp ? "runtimepath" : "packpath";

    if (flags & DIP_ERR)
      semsg(_(e_dirnotf), basepath, name);
    else if (p_verbose > 0)
    {
      verbose_enter();
      smsg(_("not found in '%s': \"%s\""), basepath, name);
      verbose_leave();
    }
  }

  return did_one ? OK : FAIL;
}

/*
 * Find "name" in "path".  When found, invoke the callback function for
 * it: callback(fname, "cookie")
 * When "flags" has DIP_ALL repeat for all matches, otherwise only the first
 * one is used.
 * Returns OK when at least one match found, FAIL otherwise.
 *
 * If "name" is NULL calls callback for each entry in "path". Cookie is
 * passed by reference in this case, setting it to NULL indicates that callback
 * has done its job.
 */
static int
do_in_path_and_pp(
    char_u *path,
    char_u *name,
    int flags,
    void (*callback)(char_u *fname, void *ck),
    void *cookie)
{
  int done = FAIL;
  char_u *s;
  int len;
  char *start_dir = "pack/*/start/*/%s";
  char *opt_dir = "pack/*/opt/*/%s";

  if ((flags & DIP_NORTP) == 0)
    done = do_in_path(path, name, flags, callback, cookie);

  if ((done == FAIL || (flags & DIP_ALL)) && (flags & DIP_START))
  {
    len = (int)(STRLEN(start_dir) + STRLEN(name));
    s = alloc(len);
    if (s == NULL)
      return FAIL;
    vim_snprintf((char *)s, len, start_dir, name);
    done = do_in_path(p_pp, s, flags, callback, cookie);
    vim_free(s);
  }

  if ((done == FAIL || (flags & DIP_ALL)) && (flags & DIP_OPT))
  {
    len = (int)(STRLEN(opt_dir) + STRLEN(name));
    s = alloc(len);
    if (s == NULL)
      return FAIL;
    vim_snprintf((char *)s, len, opt_dir, name);
    done = do_in_path(p_pp, s, flags, callback, cookie);
    vim_free(s);
  }

  return done;
}

/*
 * Just like do_in_path_and_pp(), using 'runtimepath' for "path".
 */
int do_in_runtimepath(
    char_u *name,
    int flags,
    void (*callback)(char_u *fname, void *ck),
    void *cookie)
{
  return do_in_path_and_pp(p_rtp, name, flags, callback, cookie);
}

/*
 * Source the file "name" from all directories in 'runtimepath'.
 * "name" can contain wildcards.
 * When "flags" has DIP_ALL: source all files, otherwise only the first one.
 *
 * return FAIL when no file could be sourced, OK otherwise.
 */
int source_runtime(char_u *name, int flags)
{
  return source_in_path(p_rtp, name, flags);
}

/*
 * Just like source_runtime(), but use "path" instead of 'runtimepath'.
 */
int source_in_path(char_u *path, char_u *name, int flags)
{
  return do_in_path_and_pp(path, name, flags, source_callback, NULL);
}

#if defined(FEAT_EVAL) || defined(PROTO)

/*
 * Expand wildcards in "pat" and invoke do_source() for each match.
 */
static void
source_all_matches(char_u *pat)
{
  int num_files;
  char_u **files;
  int i;

  if (gen_expand_wildcards(1, &pat, &num_files, &files, EW_FILE) == OK)
  {
    for (i = 0; i < num_files; ++i)
      (void)do_source(files[i], FALSE, DOSO_NONE);
    FreeWild(num_files, files);
  }
}

/*
 * Add the package directory to 'runtimepath'.
 */
static int
add_pack_dir_to_rtp(char_u *fname)
{
  char_u *p4, *p3, *p2, *p1, *p;
  char_u *entry;
  char_u *insp = NULL;
  int c;
  char_u *new_rtp;
  int keep;
  size_t oldlen;
  size_t addlen;
  size_t new_rtp_len;
  char_u *afterdir = NULL;
  size_t afterlen = 0;
  char_u *after_insp = NULL;
  char_u *ffname = NULL;
  size_t fname_len;
  char_u *buf = NULL;
  char_u *rtp_ffname;
  int match;
  int retval = FAIL;

  p4 = p3 = p2 = p1 = get_past_head(fname);
  for (p = p1; *p; MB_PTR_ADV(p))
    if (vim_ispathsep_nocolon(*p))
    {
      p4 = p3;
      p3 = p2;
      p2 = p1;
      p1 = p;
    }

  /* now we have:
     * rtp/pack/name/start/name
     *    p4   p3   p2    p1
     *
     * find the part up to "pack" in 'runtimepath' */
  c = *++p4; /* append pathsep in order to expand symlink */
  *p4 = NUL;
  ffname = fix_fname(fname);
  *p4 = c;
  if (ffname == NULL)
    return FAIL;

  // Find "ffname" in "p_rtp", ignoring '/' vs '\' differences.
  // Also stop at the first "after" directory.
  fname_len = STRLEN(ffname);
  buf = alloc(MAXPATHL);
  if (buf == NULL)
    goto theend;
  for (entry = p_rtp; *entry != NUL;)
  {
    char_u *cur_entry = entry;

    copy_option_part(&entry, buf, MAXPATHL, ",");
    if (insp == NULL)
    {
      add_pathsep(buf);
      rtp_ffname = fix_fname(buf);
      if (rtp_ffname == NULL)
        goto theend;
      match = vim_fnamencmp(rtp_ffname, ffname, fname_len) == 0;
      vim_free(rtp_ffname);
      if (match)
        // Insert "ffname" after this entry (and comma).
        insp = entry;
    }

    if ((p = (char_u *)strstr((char *)buf, "after")) != NULL && p > buf && vim_ispathsep(p[-1]) && (vim_ispathsep(p[5]) || p[5] == NUL || p[5] == ','))
    {
      if (insp == NULL)
        // Did not find "ffname" before the first "after" directory,
        // insert it before this entry.
        insp = cur_entry;
      after_insp = cur_entry;
      break;
    }
  }

  if (insp == NULL)
    // Both "fname" and "after" not found, append at the end.
    insp = p_rtp + STRLEN(p_rtp);

  // check if rtp/pack/name/start/name/after exists
  afterdir = concat_fnames(fname, (char_u *)"after", TRUE);
  if (afterdir != NULL && mch_isdir(afterdir))
    afterlen = STRLEN(afterdir) + 1; // add one for comma

  oldlen = STRLEN(p_rtp);
  addlen = STRLEN(fname) + 1;                      // add one for comma
  new_rtp = alloc(oldlen + addlen + afterlen + 1); // add one for NUL
  if (new_rtp == NULL)
    goto theend;

  // We now have 'rtp' parts: {keep}{keep_after}{rest}.
  // Create new_rtp, first: {keep},{fname}
  keep = (int)(insp - p_rtp);
  mch_memmove(new_rtp, p_rtp, keep);
  new_rtp_len = keep;
  if (*insp == NUL)
    new_rtp[new_rtp_len++] = ','; // add comma before
  mch_memmove(new_rtp + new_rtp_len, fname, addlen - 1);
  new_rtp_len += addlen - 1;
  if (*insp != NUL)
    new_rtp[new_rtp_len++] = ','; // add comma after

  if (afterlen > 0 && after_insp != NULL)
  {
    int keep_after = (int)(after_insp - p_rtp);

    // Add to new_rtp: {keep},{fname}{keep_after},{afterdir}
    mch_memmove(new_rtp + new_rtp_len, p_rtp + keep,
                keep_after - keep);
    new_rtp_len += keep_after - keep;
    mch_memmove(new_rtp + new_rtp_len, afterdir, afterlen - 1);
    new_rtp_len += afterlen - 1;
    new_rtp[new_rtp_len++] = ',';
    keep = keep_after;
  }

  if (p_rtp[keep] != NUL)
    // Append rest: {keep},{fname}{keep_after},{afterdir}{rest}
    mch_memmove(new_rtp + new_rtp_len, p_rtp + keep, oldlen - keep + 1);
  else
    new_rtp[new_rtp_len] = NUL;

  if (afterlen > 0 && after_insp == NULL)
  {
    // Append afterdir when "after" was not found:
    // {keep},{fname}{rest},{afterdir}
    STRCAT(new_rtp, ",");
    STRCAT(new_rtp, afterdir);
  }

  set_option_value((char_u *)"rtp", 0L, new_rtp, 0);
  vim_free(new_rtp);
  retval = OK;

theend:
  vim_free(buf);
  vim_free(ffname);
  vim_free(afterdir);
  return retval;
}

/*
 * Load scripts in "plugin" and "ftdetect" directories of the package.
 */
static int
load_pack_plugin(char_u *fname)
{
  static char *plugpat = "%s/plugin/**/*.vim";
  static char *ftpat = "%s/ftdetect/*.vim";
  int len;
  char_u *ffname = fix_fname(fname);
  char_u *pat = NULL;
  int retval = FAIL;

  if (ffname == NULL)
    return FAIL;
  len = (int)STRLEN(ffname) + (int)STRLEN(ftpat);
  pat = alloc(len);
  if (pat == NULL)
    goto theend;
  vim_snprintf((char *)pat, len, plugpat, ffname);
  source_all_matches(pat);

  {
    char_u *cmd = vim_strsave((char_u *)"g:did_load_filetypes");

    /* If runtime/filetype.vim wasn't loaded yet, the scripts will be
	 * found when it loads. */
    if (cmd != NULL && eval_to_number(cmd) > 0)
    {
      do_cmdline_cmd((char_u *)"augroup filetypedetect");
      vim_snprintf((char *)pat, len, ftpat, ffname);
      source_all_matches(pat);
      do_cmdline_cmd((char_u *)"augroup END");
    }
    vim_free(cmd);
  }
  vim_free(pat);
  retval = OK;

theend:
  vim_free(ffname);
  return retval;
}

/* used for "cookie" of add_pack_plugin() */
static int APP_ADD_DIR;
static int APP_LOAD;
static int APP_BOTH;

static void
add_pack_plugin(char_u *fname, void *cookie)
{
  if (cookie != &APP_LOAD)
  {
    char_u *buf = alloc(MAXPATHL);
    char_u *p;
    int found = FALSE;

    if (buf == NULL)
      return;
    p = p_rtp;
    while (*p != NUL)
    {
      copy_option_part(&p, buf, MAXPATHL, ",");
      if (pathcmp((char *)buf, (char *)fname, -1) == 0)
      {
        found = TRUE;
        break;
      }
    }
    vim_free(buf);
    if (!found)
      /* directory is not yet in 'runtimepath', add it */
      if (add_pack_dir_to_rtp(fname) == FAIL)
        return;
  }

  if (cookie != &APP_ADD_DIR)
    load_pack_plugin(fname);
}

/*
 * Add all packages in the "start" directory to 'runtimepath'.
 */
void add_pack_start_dirs(void)
{
  do_in_path(p_pp, (char_u *)"pack/*/start/*", DIP_ALL + DIP_DIR,
             add_pack_plugin, &APP_ADD_DIR);
}

/*
 * Load plugins from all packages in the "start" directory.
 */
void load_start_packages(void)
{
  did_source_packages = TRUE;
  do_in_path(p_pp, (char_u *)"pack/*/start/*", DIP_ALL + DIP_DIR,
             add_pack_plugin, &APP_LOAD);
}

/*
 * ":packloadall"
 * Find plugins in the package directories and source them.
 */
void ex_packloadall(exarg_T *eap)
{
  if (!did_source_packages || eap->forceit)
  {
    /* First do a round to add all directories to 'runtimepath', then load
	 * the plugins. This allows for plugins to use an autoload directory
	 * of another plugin. */
    add_pack_start_dirs();
    load_start_packages();
  }
}

/*
 * ":packadd[!] {name}"
 */
void ex_packadd(exarg_T *eap)
{
  static char *plugpat = "pack/*/%s/%s";
  int len;
  char *pat;
  int round;
  int res = OK;

  /* Round 1: use "start", round 2: use "opt". */
  for (round = 1; round <= 2; ++round)
  {
    /* Only look under "start" when loading packages wasn't done yet. */
    if (round == 1 && did_source_packages)
      continue;

    len = (int)STRLEN(plugpat) + (int)STRLEN(eap->arg) + 5;
    pat = alloc(len);
    if (pat == NULL)
      return;
    vim_snprintf(pat, len, plugpat, round == 1 ? "start" : "opt", eap->arg);
    /* The first round don't give a "not found" error, in the second round
	 * only when nothing was found in the first round. */
    res = do_in_path(p_pp, (char_u *)pat,
                     DIP_ALL + DIP_DIR + (round == 2 && res == FAIL ? DIP_ERR : 0),
                     add_pack_plugin, eap->forceit ? &APP_ADD_DIR : &APP_BOTH);
    vim_free(pat);
  }
}
#endif

#if defined(FEAT_EVAL) || defined(PROTO)
/*
 * ":options"
 */
void ex_options(
    exarg_T *eap UNUSED)
{
  vim_setenv((char_u *)"OPTWIN_CMD",
             (char_u *)(cmdmod.tab ? "tab"
                                   : (cmdmod.split & WSP_VERT) ? "vert" : ""));
  cmd_source((char_u *)SYS_OPTWIN_FILE, NULL);
}
#endif

#if defined(FEAT_PYTHON3) || defined(FEAT_PYTHON) || defined(PROTO)

#if (defined(FEAT_PYTHON) && defined(FEAT_PYTHON3)) || defined(PROTO)
/*
 * Detect Python 3 or 2, and initialize 'pyxversion'.
 */
void init_pyxversion(void)
{
  if (p_pyx == 0)
  {
    if (python3_enabled(FALSE))
      p_pyx = 3;
    else if (python_enabled(FALSE))
      p_pyx = 2;
  }
}
#endif

/*
 * Does a file contain one of the following strings at the beginning of any
 * line?
 * "#!(any string)python2"  => returns 2
 * "#!(any string)python3"  => returns 3
 * "# requires python 2.x"  => returns 2
 * "# requires python 3.x"  => returns 3
 * otherwise return 0.
 */
static int
requires_py_version(char_u *filename)
{
  FILE *file;
  int requires_py_version = 0;
  int i, lines;

  lines = (int)p_mls;
  if (lines < 0)
    lines = 5;

  file = mch_fopen((char *)filename, "r");
  if (file != NULL)
  {
    for (i = 0; i < lines; i++)
    {
      if (vim_fgets(IObuff, IOSIZE, file))
        break;
      if (i == 0 && IObuff[0] == '#' && IObuff[1] == '!')
      {
        /* Check shebang. */
        if (strstr((char *)IObuff + 2, "python2") != NULL)
        {
          requires_py_version = 2;
          break;
        }
        if (strstr((char *)IObuff + 2, "python3") != NULL)
        {
          requires_py_version = 3;
          break;
        }
      }
      IObuff[21] = '\0';
      if (STRCMP("# requires python 2.x", IObuff) == 0)
      {
        requires_py_version = 2;
        break;
      }
      if (STRCMP("# requires python 3.x", IObuff) == 0)
      {
        requires_py_version = 3;
        break;
      }
    }
    fclose(file);
  }
  return requires_py_version;
}

/*
 * Source a python file using the requested python version.
 */
static void
source_pyx_file(exarg_T *eap, char_u *fname)
{
  exarg_T ex;
  int v = requires_py_version(fname);

#if defined(FEAT_PYTHON) && defined(FEAT_PYTHON3)
  init_pyxversion();
#endif
  if (v == 0)
  {
#if defined(FEAT_PYTHON) && defined(FEAT_PYTHON3)
    /* user didn't choose a preference, 'pyx' is used */
    v = p_pyx;
#elif defined(FEAT_PYTHON)
    v = 2;
#elif defined(FEAT_PYTHON3)
    v = 3;
#endif
  }

  /*
     * now source, if required python version is not supported show
     * unobtrusive message.
     */
  if (eap == NULL)
    vim_memset(&ex, 0, sizeof(ex));
  else
    ex = *eap;
  ex.arg = fname;
  ex.cmd = (char_u *)(v == 2 ? "pyfile" : "pyfile3");

  if (v == 2)
  {
#ifdef FEAT_PYTHON
    ex_pyfile(&ex);
#else
    vim_snprintf((char *)IObuff, IOSIZE,
                 _("W20: Required python version 2.x not supported, ignoring file: %s"),
                 fname);
    msg((char *)IObuff);
#endif
    return;
  }
  else
  {
#ifdef FEAT_PYTHON3
    ex_py3file(&ex);
#else
    vim_snprintf((char *)IObuff, IOSIZE,
                 _("W21: Required python version 3.x not supported, ignoring file: %s"),
                 fname);
    msg((char *)IObuff);
#endif
    return;
  }
}

/*
 * ":pyxfile {fname}"
 */
void ex_pyxfile(exarg_T *eap)
{
  source_pyx_file(eap, eap->arg);
}

/*
 * ":pyx"
 */
void ex_pyx(exarg_T *eap)
{
#if defined(FEAT_PYTHON) && defined(FEAT_PYTHON3)
  init_pyxversion();
  if (p_pyx == 2)
    ex_python(eap);
  else
    ex_py3(eap);
#elif defined(FEAT_PYTHON)
  ex_python(eap);
#elif defined(FEAT_PYTHON3)
  ex_py3(eap);
#endif
}

/*
 * ":pyxdo"
 */
void ex_pyxdo(exarg_T *eap)
{
#if defined(FEAT_PYTHON) && defined(FEAT_PYTHON3)
  init_pyxversion();
  if (p_pyx == 2)
    ex_pydo(eap);
  else
    ex_py3do(eap);
#elif defined(FEAT_PYTHON)
  ex_pydo(eap);
#elif defined(FEAT_PYTHON3)
  ex_py3do(eap);
#endif
}

#endif

/*
 * ":source {fname}"
 */
void ex_source(exarg_T *eap)
{
#ifdef FEAT_BROWSE
  if (cmdmod.browse)
  {
    char_u *fname = NULL;

    fname = do_browse(0, (char_u *)_("Source Vim script"), eap->arg,
                      NULL, NULL,
                      (char_u *)_(BROWSE_FILTER_MACROS), NULL);
    if (fname != NULL)
    {
      cmd_source(fname, eap);
      vim_free(fname);
    }
  }
  else
#endif
    cmd_source(eap->arg, eap);
}

static void
cmd_source(char_u *fname, exarg_T *eap)
{
  if (*fname == NUL)
    emsg(_(e_argreq));

  else if (eap != NULL && eap->forceit)
    /* ":source!": read Normal mode commands
	 * Need to execute the commands directly.  This is required at least
	 * for:
	 * - ":g" command busy
	 * - after ":argdo", ":windo" or ":bufdo"
	 * - another command follows
	 * - inside a loop
	 */
    openscript(fname, global_busy || listcmd_busy || eap->nextcmd != NULL
#ifdef FEAT_EVAL
                          || eap->cstack->cs_idx >= 0
#endif
    );

  /* ":source" read ex commands */
  else if (do_source(fname, FALSE, DOSO_NONE) == FAIL)
    semsg(_(e_notopen), fname);
}

/*
 * ":source" and associated commands.
 */
/*
 * Structure used to store info for each sourced file.
 * It is shared between do_source() and getsourceline().
 * This is required, because it needs to be handed to do_cmdline() and
 * sourcing can be done recursively.
 */
struct source_cookie
{
  FILE *fp;         /* opened file for sourcing */
  char_u *nextline; /* if not NULL: line that was read ahead */
  int finished;     /* ":finish" used */
#ifdef USE_CRNL
  int fileformat; /* EOL_UNKNOWN, EOL_UNIX or EOL_DOS */
  int error;      /* TRUE if LF found after CR-LF */
#endif
#ifdef FEAT_EVAL
  linenr_T breakpoint; /* next line with breakpoint or zero */
  char_u *fname;       /* name of sourced file */
  int dbg_tick;        /* debug_tick when breakpoint was set */
  int level;           /* top nesting level of sourced file */
#endif
  vimconv_T conv; /* type of conversion */
};

#ifdef FEAT_EVAL
/*
 * Return the address holding the next breakpoint line for a source cookie.
 */
linenr_T *
source_breakpoint(void *cookie)
{
  return &((struct source_cookie *)cookie)->breakpoint;
}

/*
 * Return the address holding the debug tick for a source cookie.
 */
int *source_dbg_tick(void *cookie)
{
  return &((struct source_cookie *)cookie)->dbg_tick;
}

/*
 * Return the nesting level for a source cookie.
 */
int source_level(void *cookie)
{
  return ((struct source_cookie *)cookie)->level;
}
#endif

static char_u *get_one_sourceline(struct source_cookie *sp);

/*
 * do_source: Read the file "fname" and execute its lines as EX commands.
 *
 * This function may be called recursively!
 *
 * return FAIL if file could not be opened, OK otherwise
 */
int do_source(
    char_u *fname,
    int check_other, /* check for .vimrc and _vimrc */
    int is_vimrc)    /* DOSO_ value */
{
  struct source_cookie cookie;
  char_u *save_sourcing_name;
  linenr_T save_sourcing_lnum;
  char_u *p;
  char_u *fname_exp;
  char_u *firstline = NULL;
  int retval = FAIL;
#ifdef FEAT_EVAL
  sctx_T save_current_sctx;
  static scid_T last_current_SID = 0;
  static int last_current_SID_seq = 0;
  funccal_entry_T funccalp_entry;
  int save_debug_break_level = debug_break_level;
  scriptitem_T *si = NULL;
#ifdef UNIX
  stat_T st;
  int stat_ok;
#endif
#endif
#ifdef STARTUPTIME
  struct timeval tv_rel;
  struct timeval tv_start;
#endif
#ifdef FEAT_PROFILE
  proftime_T wait_start;
#endif
  int trigger_source_post = FALSE;

  p = expand_env_save(fname);
  if (p == NULL)
    return retval;
  fname_exp = fix_fname(p);
  vim_free(p);
  if (fname_exp == NULL)
    return retval;
  if (mch_isdir(fname_exp))
  {
    smsg(_("Cannot source a directory: \"%s\""), fname);
    goto theend;
  }

  /* Apply SourceCmd autocommands, they should get the file and source it. */
  if (has_autocmd(EVENT_SOURCECMD, fname_exp, NULL) && apply_autocmds(EVENT_SOURCECMD, fname_exp, fname_exp,
                                                                      FALSE, curbuf))
  {
#ifdef FEAT_EVAL
    retval = aborting() ? FAIL : OK;
#else
    retval = OK;
#endif
    if (retval == OK)
      // Apply SourcePost autocommands.
      apply_autocmds(EVENT_SOURCEPOST, fname_exp, fname_exp,
                     FALSE, curbuf);
    goto theend;
  }

  /* Apply SourcePre autocommands, they may get the file. */
  apply_autocmds(EVENT_SOURCEPRE, fname_exp, fname_exp, FALSE, curbuf);

#ifdef USE_FOPEN_NOINH
  cookie.fp = fopen_noinh_readbin((char *)fname_exp);
#else
  cookie.fp = mch_fopen((char *)fname_exp, READBIN);
#endif
  if (cookie.fp == NULL && check_other)
  {
    /*
	 * Try again, replacing file name ".vimrc" by "_vimrc" or vice versa,
	 * and ".exrc" by "_exrc" or vice versa.
	 */
    p = gettail(fname_exp);
    if ((*p == '.' || *p == '_') && (STRICMP(p + 1, "vimrc") == 0 || STRICMP(p + 1, "gvimrc") == 0 || STRICMP(p + 1, "exrc") == 0))
    {
      if (*p == '_')
        *p = '.';
      else
        *p = '_';
#ifdef USE_FOPEN_NOINH
      cookie.fp = fopen_noinh_readbin((char *)fname_exp);
#else
      cookie.fp = mch_fopen((char *)fname_exp, READBIN);
#endif
    }
  }

  if (cookie.fp == NULL)
  {
    if (p_verbose > 0)
    {
      verbose_enter();
      if (sourcing_name == NULL)
        smsg(_("could not source \"%s\""), fname);
      else
        smsg(_("line %ld: could not source \"%s\""),
             sourcing_lnum, fname);
      verbose_leave();
    }
    goto theend;
  }

  /*
     * The file exists.
     * - In verbose mode, give a message.
     * - For a vimrc file, may want to set 'compatible', call vimrc_found().
     */
  if (p_verbose > 1)
  {
    verbose_enter();
    if (sourcing_name == NULL)
      smsg(_("sourcing \"%s\""), fname);
    else
      smsg(_("line %ld: sourcing \"%s\""),
           sourcing_lnum, fname);
    verbose_leave();
  }
  if (is_vimrc == DOSO_VIMRC)
    vimrc_found(fname_exp, (char_u *)"MYVIMRC");
  else if (is_vimrc == DOSO_GVIMRC)
    vimrc_found(fname_exp, (char_u *)"MYGVIMRC");

#ifdef USE_CRNL
  /* If no automatic file format: Set default to CR-NL. */
  if (*p_ffs == NUL)
    cookie.fileformat = EOL_DOS;
  else
    cookie.fileformat = EOL_UNKNOWN;
  cookie.error = FALSE;
#endif

  cookie.nextline = NULL;
  cookie.finished = FALSE;

#ifdef FEAT_EVAL
  /*
     * Check if this script has a breakpoint.
     */
  cookie.breakpoint = dbg_find_breakpoint(TRUE, fname_exp, (linenr_T)0);
  cookie.fname = fname_exp;
  cookie.dbg_tick = debug_tick;

  cookie.level = ex_nesting_level;
#endif

  /*
     * Keep the sourcing name/lnum, for recursive calls.
     */
  save_sourcing_name = sourcing_name;
  sourcing_name = fname_exp;
  save_sourcing_lnum = sourcing_lnum;
  sourcing_lnum = 0;

#ifdef STARTUPTIME
  if (time_fd != NULL)
    time_push(&tv_rel, &tv_start);
#endif

#ifdef FEAT_EVAL
#ifdef FEAT_PROFILE
  if (do_profiling == PROF_YES)
    prof_child_enter(&wait_start); /* entering a child now */
#endif

  /* Don't use local function variables, if called from a function.
     * Also starts profiling timer for nested script. */
  save_funccal(&funccalp_entry);

  save_current_sctx = current_sctx;
  current_sctx.sc_lnum = 0;
  current_sctx.sc_version = 1;

  // Check if this script was sourced before to finds its SID.
  // If it's new, generate a new SID.
  // Always use a new sequence number.
  current_sctx.sc_seq = ++last_current_SID_seq;
#ifdef UNIX
  stat_ok = (mch_stat((char *)fname_exp, &st) >= 0);
#endif
  for (current_sctx.sc_sid = script_items.ga_len; current_sctx.sc_sid > 0;
       --current_sctx.sc_sid)
  {
    si = &SCRIPT_ITEM(current_sctx.sc_sid);
    if (si->sn_name != NULL && (
#ifdef UNIX
                                   /* Compare dev/ino when possible, it catches symbolic
		     * links.  Also compare file names, the inode may change
		     * when the file was edited. */
                                   ((stat_ok && si->sn_dev_valid) && (si->sn_dev == st.st_dev && si->sn_ino == st.st_ino)) ||
#endif
                                   fnamecmp(si->sn_name, fname_exp) == 0))
      break;
  }
  if (current_sctx.sc_sid == 0)
  {
    current_sctx.sc_sid = ++last_current_SID;
    if (ga_grow(&script_items,
                (int)(current_sctx.sc_sid - script_items.ga_len)) == FAIL)
      goto almosttheend;
    while (script_items.ga_len < current_sctx.sc_sid)
    {
      ++script_items.ga_len;
      SCRIPT_ITEM(script_items.ga_len).sn_name = NULL;
#ifdef FEAT_PROFILE
      SCRIPT_ITEM(script_items.ga_len).sn_prof_on = FALSE;
#endif
    }
    si = &SCRIPT_ITEM(current_sctx.sc_sid);
    si->sn_name = fname_exp;
    fname_exp = vim_strsave(si->sn_name); // used for autocmd
#ifdef UNIX
    if (stat_ok)
    {
      si->sn_dev_valid = TRUE;
      si->sn_dev = st.st_dev;
      si->sn_ino = st.st_ino;
    }
    else
      si->sn_dev_valid = FALSE;
#endif

    /* Allocate the local script variables to use for this script. */
    new_script_vars(current_sctx.sc_sid);
  }

#ifdef FEAT_PROFILE
  if (do_profiling == PROF_YES)
  {
    int forceit;

    /* Check if we do profiling for this script. */
    if (!si->sn_prof_on && has_profiling(TRUE, si->sn_name, &forceit))
    {
      script_do_profile(si);
      si->sn_pr_force = forceit;
    }
    if (si->sn_prof_on)
    {
      ++si->sn_pr_count;
      profile_start(&si->sn_pr_start);
      profile_zero(&si->sn_pr_children);
    }
  }
#endif
#endif

  cookie.conv.vc_type = CONV_NONE; /* no conversion */

  /* Read the first line so we can check for a UTF-8 BOM. */
  firstline = getsourceline(0, (void *)&cookie, 0);
  if (firstline != NULL && STRLEN(firstline) >= 3 && firstline[0] == 0xef && firstline[1] == 0xbb && firstline[2] == 0xbf)
  {
    /* Found BOM; setup conversion, skip over BOM and recode the line. */
    convert_setup(&cookie.conv, (char_u *)"utf-8", p_enc);
    p = string_convert(&cookie.conv, firstline + 3, NULL);
    if (p == NULL)
      p = vim_strsave(firstline + 3);
    if (p != NULL)
    {
      vim_free(firstline);
      firstline = p;
    }
  }

  /*
     * Call do_cmdline, which will call getsourceline() to get the lines.
     */
  do_cmdline(firstline, getsourceline, (void *)&cookie,
             DOCMD_VERBOSE | DOCMD_NOWAIT | DOCMD_REPEAT);
  retval = OK;

#ifdef FEAT_PROFILE
  if (do_profiling == PROF_YES)
  {
    /* Get "si" again, "script_items" may have been reallocated. */
    si = &SCRIPT_ITEM(current_sctx.sc_sid);
    if (si->sn_prof_on)
    {
      profile_end(&si->sn_pr_start);
      profile_sub_wait(&wait_start, &si->sn_pr_start);
      profile_add(&si->sn_pr_total, &si->sn_pr_start);
      profile_self(&si->sn_pr_self, &si->sn_pr_start,
                   &si->sn_pr_children);
    }
  }
#endif

  if (got_int)
    emsg(_(e_interr));
  sourcing_name = save_sourcing_name;
  sourcing_lnum = save_sourcing_lnum;
  if (p_verbose > 1)
  {
    verbose_enter();
    smsg(_("finished sourcing %s"), fname);
    if (sourcing_name != NULL)
      smsg(_("continuing in %s"), sourcing_name);
    verbose_leave();
  }
#ifdef STARTUPTIME
  if (time_fd != NULL)
  {
    vim_snprintf((char *)IObuff, IOSIZE, "sourcing %s", fname);
    time_msg((char *)IObuff, &tv_start);
    time_pop(&tv_rel);
  }
#endif

  if (!got_int)
    trigger_source_post = TRUE;

#ifdef FEAT_EVAL
  /*
     * After a "finish" in debug mode, need to break at first command of next
     * sourced file.
     */
  if (save_debug_break_level > ex_nesting_level && debug_break_level == ex_nesting_level)
    ++debug_break_level;
#endif

#ifdef FEAT_EVAL
almosttheend:
  current_sctx = save_current_sctx;
  restore_funccal();
#ifdef FEAT_PROFILE
  if (do_profiling == PROF_YES)
    prof_child_exit(&wait_start); /* leaving a child now */
#endif
#endif
  fclose(cookie.fp);
  vim_free(cookie.nextline);
  vim_free(firstline);
  convert_setup(&cookie.conv, NULL, NULL);

  if (trigger_source_post)
    apply_autocmds(EVENT_SOURCEPOST, fname_exp, fname_exp, FALSE, curbuf);

theend:
  vim_free(fname_exp);
  return retval;
}

#if defined(FEAT_EVAL) || defined(PROTO)

/*
 * ":scriptnames"
 */
void ex_scriptnames(exarg_T *eap)
{
  int i;

  if (eap->addr_count > 0)
  {
    // :script {scriptId}: edit the script
    if (eap->line2 < 1 || eap->line2 > script_items.ga_len)
      emsg(_(e_invarg));
    else
    {
      eap->arg = SCRIPT_ITEM(eap->line2).sn_name;
      do_exedit(eap, NULL);
    }
    return;
  }

  for (i = 1; i <= script_items.ga_len && !got_int; ++i)
    if (SCRIPT_ITEM(i).sn_name != NULL)
    {
      home_replace(NULL, SCRIPT_ITEM(i).sn_name,
                   NameBuff, MAXPATHL, TRUE);
      smsg("%3d: %s", i, NameBuff);
    }
}

#if defined(BACKSLASH_IN_FILENAME) || defined(PROTO)
/*
 * Fix slashes in the list of script names for 'shellslash'.
 */
void scriptnames_slash_adjust(void)
{
  int i;

  for (i = 1; i <= script_items.ga_len; ++i)
    if (SCRIPT_ITEM(i).sn_name != NULL)
      slash_adjust(SCRIPT_ITEM(i).sn_name);
}
#endif

/*
 * Get a pointer to a script name.  Used for ":verbose set".
 */
char_u *
get_scriptname(scid_T id)
{
  if (id == SID_MODELINE)
    return (char_u *)_("modeline");
  if (id == SID_CMDARG)
    return (char_u *)_("--cmd argument");
  if (id == SID_CARG)
    return (char_u *)_("-c argument");
  if (id == SID_ENV)
    return (char_u *)_("environment variable");
  if (id == SID_ERROR)
    return (char_u *)_("error handler");
  return SCRIPT_ITEM(id).sn_name;
}

#if defined(EXITFREE) || defined(PROTO)
void free_scriptnames(void)
{
  int i;

  for (i = script_items.ga_len; i > 0; --i)
    vim_free(SCRIPT_ITEM(i).sn_name);
  ga_clear(&script_items);
}
#endif

#endif

/*
 * Get one full line from a sourced file.
 * Called by do_cmdline() when it's called from do_source().
 *
 * Return a pointer to the line in allocated memory.
 * Return NULL for end-of-file or some error.
 */
char_u *
getsourceline(int c UNUSED, void *cookie, int indent UNUSED)
{
  struct source_cookie *sp = (struct source_cookie *)cookie;
  char_u *line;
  char_u *p;

#ifdef FEAT_EVAL
  /* If breakpoints have been added/deleted need to check for it. */
  if (sp->dbg_tick < debug_tick)
  {
    sp->breakpoint = dbg_find_breakpoint(TRUE, sp->fname, sourcing_lnum);
    sp->dbg_tick = debug_tick;
  }
#ifdef FEAT_PROFILE
  if (do_profiling == PROF_YES)
    script_line_end();
#endif
#endif
  /*
     * Get current line.  If there is a read-ahead line, use it, otherwise get
     * one now.
     */
  if (sp->finished)
    line = NULL;
  else if (sp->nextline == NULL)
    line = get_one_sourceline(sp);
  else
  {
    line = sp->nextline;
    sp->nextline = NULL;
    ++sourcing_lnum;
  }
#ifdef FEAT_PROFILE
  if (line != NULL && do_profiling == PROF_YES)
    script_line_start();
#endif

  /* Only concatenate lines starting with a \ when 'cpoptions' doesn't
     * contain the 'C' flag. */
  if (line != NULL && (vim_strchr(p_cpo, CPO_CONCAT) == NULL))
  {
    /* compensate for the one line read-ahead */
    --sourcing_lnum;

    // Get the next line and concatenate it when it starts with a
    // backslash. We always need to read the next line, keep it in
    // sp->nextline.
    /* Also check for a comment in between continuation lines: "\ */
    sp->nextline = get_one_sourceline(sp);
    if (sp->nextline != NULL && (*(p = skipwhite(sp->nextline)) == '\\' || (p[0] == '"' && p[1] == '\\' && p[2] == ' ')))
    {
      garray_T ga;

      ga_init2(&ga, (int)sizeof(char_u), 400);
      ga_concat(&ga, line);
      if (*p == '\\')
        ga_concat(&ga, p + 1);
      for (;;)
      {
        vim_free(sp->nextline);
        sp->nextline = get_one_sourceline(sp);
        if (sp->nextline == NULL)
          break;
        p = skipwhite(sp->nextline);
        if (*p == '\\')
        {
          // Adjust the growsize to the current length to speed up
          // concatenating many lines.
          if (ga.ga_len > 400)
          {
            if (ga.ga_len > 8000)
              ga.ga_growsize = 8000;
            else
              ga.ga_growsize = ga.ga_len;
          }
          ga_concat(&ga, p + 1);
        }
        else if (p[0] != '"' || p[1] != '\\' || p[2] != ' ')
          break;
      }
      ga_append(&ga, NUL);
      vim_free(line);
      line = ga.ga_data;
    }
  }

  if (line != NULL && sp->conv.vc_type != CONV_NONE)
  {
    char_u *s;

    /* Convert the encoding of the script line. */
    s = string_convert(&sp->conv, line, NULL);
    if (s != NULL)
    {
      vim_free(line);
      line = s;
    }
  }

#ifdef FEAT_EVAL
  /* Did we encounter a breakpoint? */
  if (sp->breakpoint != 0 && sp->breakpoint <= sourcing_lnum)
  {
    dbg_breakpoint(sp->fname, sourcing_lnum);
    /* Find next breakpoint. */
    sp->breakpoint = dbg_find_breakpoint(TRUE, sp->fname, sourcing_lnum);
    sp->dbg_tick = debug_tick;
  }
#endif

  return line;
}

static char_u *
get_one_sourceline(struct source_cookie *sp)
{
  garray_T ga;
  int len;
  int c;
  char_u *buf;
#ifdef USE_CRNL
  int has_cr; /* CR-LF found */
#endif
  int have_read = FALSE;

  /* use a growarray to store the sourced line */
  ga_init2(&ga, 1, 250);

  /*
     * Loop until there is a finished line (or end-of-file).
     */
  sourcing_lnum++;
  for (;;)
  {
    /* make room to read at least 120 (more) characters */
    if (ga_grow(&ga, 120) == FAIL)
      break;
    buf = (char_u *)ga.ga_data;

    if (fgets((char *)buf + ga.ga_len, ga.ga_maxlen - ga.ga_len,
              sp->fp) == NULL)
      break;
    len = ga.ga_len + (int)STRLEN(buf + ga.ga_len);
#ifdef USE_CRNL
    /* Ignore a trailing CTRL-Z, when in Dos mode.	Only recognize the
	 * CTRL-Z by its own, or after a NL. */
    if ((len == 1 || (len >= 2 && buf[len - 2] == '\n')) && sp->fileformat == EOL_DOS && buf[len - 1] == Ctrl_Z)
    {
      buf[len - 1] = NUL;
      break;
    }
#endif

    have_read = TRUE;
    ga.ga_len = len;

    /* If the line was longer than the buffer, read more. */
    if (ga.ga_maxlen - ga.ga_len == 1 && buf[len - 1] != '\n')
      continue;

    if (len >= 1 && buf[len - 1] == '\n') /* remove trailing NL */
    {
#ifdef USE_CRNL
      has_cr = (len >= 2 && buf[len - 2] == '\r');
      if (sp->fileformat == EOL_UNKNOWN)
      {
        if (has_cr)
          sp->fileformat = EOL_DOS;
        else
          sp->fileformat = EOL_UNIX;
      }

      if (sp->fileformat == EOL_DOS)
      {
        if (has_cr) /* replace trailing CR */
        {
          buf[len - 2] = '\n';
          --len;
          --ga.ga_len;
        }
        else /* lines like ":map xx yy^M" will have failed */
        {
          if (!sp->error)
          {
            msg_source(HL_ATTR(HLF_W));
            emsg(_("W15: Warning: Wrong line separator, ^M may be missing"));
          }
          sp->error = TRUE;
          sp->fileformat = EOL_UNIX;
        }
      }
#endif
      /* The '\n' is escaped if there is an odd number of ^V's just
	     * before it, first set "c" just before the 'V's and then check
	     * len&c parities (is faster than ((len-c)%2 == 0)) -- Acevedo */
      for (c = len - 2; c >= 0 && buf[c] == Ctrl_V; c--)
        ;
      if ((len & 1) != (c & 1)) /* escaped NL, read more */
      {
        sourcing_lnum++;
        continue;
      }

      buf[len - 1] = NUL; /* remove the NL */
    }

    /*
	 * Check for ^C here now and then, so recursive :so can be broken.
	 */
    line_breakcheck();
    break;
  }

  if (have_read)
    return (char_u *)ga.ga_data;

  vim_free(ga.ga_data);
  return NULL;
}

#if defined(FEAT_PROFILE) || defined(PROTO)
/*
 * Called when starting to read a script line.
 * "sourcing_lnum" must be correct!
 * When skipping lines it may not actually be executed, but we won't find out
 * until later and we need to store the time now.
 */
void script_line_start(void)
{
  scriptitem_T *si;
  sn_prl_T *pp;

  if (current_sctx.sc_sid <= 0 || current_sctx.sc_sid > script_items.ga_len)
    return;
  si = &SCRIPT_ITEM(current_sctx.sc_sid);
  if (si->sn_prof_on && sourcing_lnum >= 1)
  {
    /* Grow the array before starting the timer, so that the time spent
	 * here isn't counted. */
    (void)ga_grow(&si->sn_prl_ga,
                  (int)(sourcing_lnum - si->sn_prl_ga.ga_len));
    si->sn_prl_idx = sourcing_lnum - 1;
    while (si->sn_prl_ga.ga_len <= si->sn_prl_idx && si->sn_prl_ga.ga_len < si->sn_prl_ga.ga_maxlen)
    {
      /* Zero counters for a line that was not used before. */
      pp = &PRL_ITEM(si, si->sn_prl_ga.ga_len);
      pp->snp_count = 0;
      profile_zero(&pp->sn_prl_total);
      profile_zero(&pp->sn_prl_self);
      ++si->sn_prl_ga.ga_len;
    }
    si->sn_prl_execed = FALSE;
    profile_start(&si->sn_prl_start);
    profile_zero(&si->sn_prl_children);
    profile_get_wait(&si->sn_prl_wait);
  }
}

/*
 * Called when actually executing a function line.
 */
void script_line_exec(void)
{
  scriptitem_T *si;

  if (current_sctx.sc_sid <= 0 || current_sctx.sc_sid > script_items.ga_len)
    return;
  si = &SCRIPT_ITEM(current_sctx.sc_sid);
  if (si->sn_prof_on && si->sn_prl_idx >= 0)
    si->sn_prl_execed = TRUE;
}

/*
 * Called when done with a script line.
 */
void script_line_end(void)
{
  scriptitem_T *si;
  sn_prl_T *pp;

  if (current_sctx.sc_sid <= 0 || current_sctx.sc_sid > script_items.ga_len)
    return;
  si = &SCRIPT_ITEM(current_sctx.sc_sid);
  if (si->sn_prof_on && si->sn_prl_idx >= 0 && si->sn_prl_idx < si->sn_prl_ga.ga_len)
  {
    if (si->sn_prl_execed)
    {
      pp = &PRL_ITEM(si, si->sn_prl_idx);
      ++pp->snp_count;
      profile_end(&si->sn_prl_start);
      profile_sub_wait(&si->sn_prl_wait, &si->sn_prl_start);
      profile_add(&pp->sn_prl_total, &si->sn_prl_start);
      profile_self(&pp->sn_prl_self, &si->sn_prl_start,
                   &si->sn_prl_children);
    }
    si->sn_prl_idx = -1;
  }
}
#endif

/*
 * ":scriptencoding": Set encoding conversion for a sourced script.
 */
void ex_scriptencoding(exarg_T *eap)
{
  struct source_cookie *sp;
  char_u *name;

  if (!getline_equal(eap->getline, eap->cookie, getsourceline))
  {
    emsg(_("E167: :scriptencoding used outside of a sourced file"));
    return;
  }

  if (*eap->arg != NUL)
  {
    name = enc_canonize(eap->arg);
    if (name == NULL) /* out of memory */
      return;
  }
  else
    name = eap->arg;

  /* Setup for conversion from the specified encoding to 'encoding'. */
  sp = (struct source_cookie *)getline_cookie(eap->getline, eap->cookie);
  convert_setup(&sp->conv, name, p_enc);

  if (name != eap->arg)
    vim_free(name);
}

/*
 * ":scriptversion": Set Vim script version for a sourced script.
 */
void ex_scriptversion(exarg_T *eap UNUSED)
{
#ifdef FEAT_EVAL
  int nr;

  if (!getline_equal(eap->getline, eap->cookie, getsourceline))
  {
    emsg(_("E984: :scriptversion used outside of a sourced file"));
    return;
  }

  nr = getdigits(&eap->arg);
  if (nr == 0 || *eap->arg != NUL)
    emsg(_(e_invarg));
  else if (nr > 3)
    semsg(_("E999: scriptversion not supported: %d"), nr);
  else
    current_sctx.sc_version = nr;
#endif
}

#if defined(FEAT_EVAL) || defined(PROTO)
/*
 * ":finish": Mark a sourced file as finished.
 */
void ex_finish(exarg_T *eap)
{
  if (getline_equal(eap->getline, eap->cookie, getsourceline))
    do_finish(eap, FALSE);
  else
    emsg(_("E168: :finish used outside of a sourced file"));
}

/*
 * Mark a sourced file as finished.  Possibly makes the ":finish" pending.
 * Also called for a pending finish at the ":endtry" or after returning from
 * an extra do_cmdline().  "reanimate" is used in the latter case.
 */
void do_finish(exarg_T *eap, int reanimate)
{
  int idx;

  if (reanimate)
    ((struct source_cookie *)getline_cookie(eap->getline,
                                            eap->cookie))
        ->finished = FALSE;

  /*
     * Cleanup (and inactivate) conditionals, but stop when a try conditional
     * not in its finally clause (which then is to be executed next) is found.
     * In this case, make the ":finish" pending for execution at the ":endtry".
     * Otherwise, finish normally.
     */
  idx = cleanup_conditionals(eap->cstack, 0, TRUE);
  if (idx >= 0)
  {
    eap->cstack->cs_pending[idx] = CSTP_FINISH;
    report_make_pending(CSTP_FINISH, NULL);
  }
  else
    ((struct source_cookie *)getline_cookie(eap->getline,
                                            eap->cookie))
        ->finished = TRUE;
}

/*
 * Return TRUE when a sourced file had the ":finish" command: Don't give error
 * message for missing ":endif".
 * Return FALSE when not sourcing a file.
 */
int source_finished(
    char_u *(*fgetline)(int, void *, int),
    void *cookie)
{
  return (getline_equal(fgetline, cookie, getsourceline) && ((struct source_cookie *)getline_cookie(
                                                                 fgetline, cookie))
                                                                ->finished);
}
#endif

/*
 * ":checktime [buffer]"
 */
void ex_checktime(exarg_T *eap)
{
  buf_T *buf;
  int save_no_check_timestamps = no_check_timestamps;

  no_check_timestamps = 0;
  if (eap->addr_count == 0) /* default is all buffers */
    check_timestamps(FALSE);
  else
  {
    buf = buflist_findnr((int)eap->line2);
    if (buf != NULL) /* cannot happen? */
      (void)buf_check_timestamp(buf, FALSE);
  }
  no_check_timestamps = save_no_check_timestamps;
}

#if (defined(HAVE_LOCALE_H) || defined(X_LOCALE)) && (defined(FEAT_EVAL) || defined(FEAT_MULTI_LANG))
#define HAVE_GET_LOCALE_VAL
static char_u *
get_locale_val(int what)
{
  char_u *loc;

  /* Obtain the locale value from the libraries. */
  loc = (char_u *)setlocale(what, NULL);

#ifdef MSWIN
  if (loc != NULL)
  {
    char_u *p;

    /* setocale() returns something like "LC_COLLATE=<name>;LC_..." when
	 * one of the values (e.g., LC_CTYPE) differs. */
    p = vim_strchr(loc, '=');
    if (p != NULL)
    {
      loc = ++p;
      while (*p != NUL) /* remove trailing newline */
      {
        if (*p < ' ' || *p == ';')
        {
          *p = NUL;
          break;
        }
        ++p;
      }
    }
  }
#endif

  return loc;
}
#endif

#ifdef MSWIN
/*
 * On MS-Windows locale names are strings like "German_Germany.1252", but
 * gettext expects "de".  Try to translate one into another here for a few
 * supported languages.
 */
static char_u *
gettext_lang(char_u *name)
{
  int i;
  static char *(mtable[]) = {
      "afrikaans", "af",
      "czech", "cs",
      "dutch", "nl",
      "german", "de",
      "english_united kingdom", "en_GB",
      "spanish", "es",
      "french", "fr",
      "italian", "it",
      "japanese", "ja",
      "korean", "ko",
      "norwegian", "no",
      "polish", "pl",
      "russian", "ru",
      "slovak", "sk",
      "swedish", "sv",
      "ukrainian", "uk",
      "chinese_china", "zh_CN",
      "chinese_taiwan", "zh_TW",
      NULL};

  for (i = 0; mtable[i] != NULL; i += 2)
    if (STRNICMP(mtable[i], name, STRLEN(mtable[i])) == 0)
      return (char_u *)mtable[i + 1];
  return name;
}
#endif

#if defined(FEAT_MULTI_LANG) || defined(PROTO)
/*
 * Return TRUE when "lang" starts with a valid language name.
 * Rejects NULL, empty string, "C", "C.UTF-8" and others.
 */
static int
is_valid_mess_lang(char_u *lang)
{
  return lang != NULL && ASCII_ISALPHA(lang[0]) && ASCII_ISALPHA(lang[1]);
}

/*
 * Obtain the current messages language.  Used to set the default for
 * 'helplang'.  May return NULL or an empty string.
 */
char_u *
get_mess_lang(void)
{
  char_u *p;

#ifdef HAVE_GET_LOCALE_VAL
#if defined(LC_MESSAGES)
  p = get_locale_val(LC_MESSAGES);
#else
  /* This is necessary for Win32, where LC_MESSAGES is not defined and $LANG
     * may be set to the LCID number.  LC_COLLATE is the best guess, LC_TIME
     * and LC_MONETARY may be set differently for a Japanese working in the
     * US. */
  p = get_locale_val(LC_COLLATE);
#endif
#else
  p = mch_getenv((char_u *)"LC_ALL");
  if (!is_valid_mess_lang(p))
  {
    p = mch_getenv((char_u *)"LC_MESSAGES");
    if (!is_valid_mess_lang(p))
      p = mch_getenv((char_u *)"LANG");
  }
#endif
#ifdef MSWIN
  p = gettext_lang(p);
#endif
  return is_valid_mess_lang(p) ? p : NULL;
}
#endif

/* Complicated #if; matches with where get_mess_env() is used below. */
#if (defined(FEAT_EVAL) && !((defined(HAVE_LOCALE_H) || defined(X_LOCALE)) && defined(LC_MESSAGES))) || ((defined(HAVE_LOCALE_H) || defined(X_LOCALE)) && !defined(LC_MESSAGES))
/*
 * Get the language used for messages from the environment.
 */
static char_u *
get_mess_env(void)
{
  char_u *p;

  p = mch_getenv((char_u *)"LC_ALL");
  if (p == NULL || *p == NUL)
  {
    p = mch_getenv((char_u *)"LC_MESSAGES");
    if (p == NULL || *p == NUL)
    {
      p = mch_getenv((char_u *)"LANG");
      if (p != NULL && VIM_ISDIGIT(*p))
        p = NULL; /* ignore something like "1043" */
#ifdef HAVE_GET_LOCALE_VAL
      if (p == NULL || *p == NUL)
        p = get_locale_val(LC_CTYPE);
#endif
    }
  }
  return p;
}
#endif

#if defined(FEAT_EVAL) || defined(PROTO)

/*
 * Set the "v:lang" variable according to the current locale setting.
 * Also do "v:lc_time"and "v:ctype".
 */
void set_lang_var(void)
{
  char_u *loc;

#ifdef HAVE_GET_LOCALE_VAL
  loc = get_locale_val(LC_CTYPE);
#else
  /* setlocale() not supported: use the default value */
  loc = (char_u *)"C";
#endif
  set_vim_var_string(VV_CTYPE, loc, -1);

  /* When LC_MESSAGES isn't defined use the value from $LC_MESSAGES, fall
     * back to LC_CTYPE if it's empty. */
#if defined(HAVE_GET_LOCALE_VAL) && defined(LC_MESSAGES)
  loc = get_locale_val(LC_MESSAGES);
#else
  loc = get_mess_env();
#endif
  set_vim_var_string(VV_LANG, loc, -1);

#ifdef HAVE_GET_LOCALE_VAL
  loc = get_locale_val(LC_TIME);
#endif
  set_vim_var_string(VV_LC_TIME, loc, -1);
}
#endif

#if defined(HAVE_LOCALE_H) || defined(X_LOCALE)
/*
 * ":language":  Set the language (locale).
 */
void ex_language(exarg_T *eap)
{
  char *loc;
  char_u *p;
  char_u *name;
  int what = LC_ALL;
  char *whatstr = "";
#ifdef LC_MESSAGES
#define VIM_LC_MESSAGES LC_MESSAGES
#else
#define VIM_LC_MESSAGES 6789
#endif

  name = eap->arg;

  /* Check for "messages {name}", "ctype {name}" or "time {name}" argument.
     * Allow abbreviation, but require at least 3 characters to avoid
     * confusion with a two letter language name "me" or "ct". */
  p = skiptowhite(eap->arg);
  if ((*p == NUL || VIM_ISWHITE(*p)) && p - eap->arg >= 3)
  {
    if (STRNICMP(eap->arg, "messages", p - eap->arg) == 0)
    {
      what = VIM_LC_MESSAGES;
      name = skipwhite(p);
      whatstr = "messages ";
    }
    else if (STRNICMP(eap->arg, "ctype", p - eap->arg) == 0)
    {
      what = LC_CTYPE;
      name = skipwhite(p);
      whatstr = "ctype ";
    }
    else if (STRNICMP(eap->arg, "time", p - eap->arg) == 0)
    {
      what = LC_TIME;
      name = skipwhite(p);
      whatstr = "time ";
    }
  }

  if (*name == NUL)
  {
#ifndef LC_MESSAGES
    if (what == VIM_LC_MESSAGES)
      p = get_mess_env();
    else
#endif
      p = (char_u *)setlocale(what, NULL);
    if (p == NULL || *p == NUL)
      p = (char_u *)"Unknown";
    smsg(_("Current %slanguage: \"%s\""), whatstr, p);
  }
  else
  {
#ifndef LC_MESSAGES
    if (what == VIM_LC_MESSAGES)
      loc = "";
    else
#endif
    {
      loc = setlocale(what, (char *)name);
#if defined(FEAT_FLOAT) && defined(LC_NUMERIC)
      /* Make sure strtod() uses a decimal point, not a comma. */
      setlocale(LC_NUMERIC, "C");
#endif
    }
    if (loc == NULL)
      semsg(_("E197: Cannot set language to \"%s\""), name);
    else
    {
#ifdef HAVE_NL_MSG_CAT_CNTR
      /* Need to do this for GNU gettext, otherwise cached translations
	     * will be used again. */
      extern int _nl_msg_cat_cntr;

      ++_nl_msg_cat_cntr;
#endif
      /* Reset $LC_ALL, otherwise it would overrule everything. */
      vim_setenv((char_u *)"LC_ALL", (char_u *)"");

      if (what != LC_TIME)
      {
        /* Tell gettext() what to translate to.  It apparently doesn't
		 * use the currently effective locale.  Also do this when
		 * FEAT_GETTEXT isn't defined, so that shell commands use this
		 * value. */
        if (what == LC_ALL)
        {
          vim_setenv((char_u *)"LANG", name);

          /* Clear $LANGUAGE because GNU gettext uses it. */
          vim_setenv((char_u *)"LANGUAGE", (char_u *)"");
#ifdef MSWIN
          /* Apparently MS-Windows printf() may cause a crash when
		     * we give it 8-bit text while it's expecting text in the
		     * current locale.  This call avoids that. */
          setlocale(LC_CTYPE, "C");
#endif
        }
        if (what != LC_CTYPE)
        {
          char_u *mname;
#ifdef MSWIN
          mname = gettext_lang(name);
#else
          mname = name;
#endif
          vim_setenv((char_u *)"LC_MESSAGES", mname);
#ifdef FEAT_MULTI_LANG
          set_helplang_default(mname);
#endif
        }
      }

#ifdef FEAT_EVAL
      /* Set v:lang, v:lc_time and v:ctype to the final result. */
      set_lang_var();
#endif
    }
  }
}

#if defined(FEAT_CMDL_COMPL) || defined(PROTO)

static char_u **locales = NULL; /* Array of all available locales */

#ifndef MSWIN
static int did_init_locales = FALSE;

/* Return an array of strings for all available locales + NULL for the
 * last element.  Return NULL in case of error. */
static char_u **
find_locales(void)
{
  garray_T locales_ga;
  char_u *loc;

  /* Find all available locales by running command "locale -a".  If this
     * doesn't work we won't have completion. */
  char_u *locale_a = get_cmd_output((char_u *)"locale -a",
                                    NULL, SHELL_SILENT, NULL);
  if (locale_a == NULL)
    return NULL;
  ga_init2(&locales_ga, sizeof(char_u *), 20);

  /* Transform locale_a string where each locale is separated by "\n"
     * into an array of locale strings. */
  loc = (char_u *)strtok((char *)locale_a, "\n");

  while (loc != NULL)
  {
    if (ga_grow(&locales_ga, 1) == FAIL)
      break;
    loc = vim_strsave(loc);
    if (loc == NULL)
      break;

    ((char_u **)locales_ga.ga_data)[locales_ga.ga_len++] = loc;
    loc = (char_u *)strtok(NULL, "\n");
  }
  vim_free(locale_a);
  if (ga_grow(&locales_ga, 1) == FAIL)
  {
    ga_clear(&locales_ga);
    return NULL;
  }
  ((char_u **)locales_ga.ga_data)[locales_ga.ga_len] = NULL;
  return (char_u **)locales_ga.ga_data;
}
#endif

/*
 * Lazy initialization of all available locales.
 */
static void
init_locales(void)
{
#ifndef MSWIN
  if (!did_init_locales)
  {
    did_init_locales = TRUE;
    locales = find_locales();
  }
#endif
}

#if defined(EXITFREE) || defined(PROTO)
void free_locales(void)
{
  int i;
  if (locales != NULL)
  {
    for (i = 0; locales[i] != NULL; i++)
      vim_free(locales[i]);
    VIM_CLEAR(locales);
  }
}
#endif

/*
 * Function given to ExpandGeneric() to obtain the possible arguments of the
 * ":language" command.
 */
char_u *
get_lang_arg(expand_T *xp UNUSED, int idx)
{
  if (idx == 0)
    return (char_u *)"messages";
  if (idx == 1)
    return (char_u *)"ctype";
  if (idx == 2)
    return (char_u *)"time";

  init_locales();
  if (locales == NULL)
    return NULL;
  return locales[idx - 3];
}

/*
 * Function given to ExpandGeneric() to obtain the available locales.
 */
char_u *
get_locales(expand_T *xp UNUSED, int idx)
{
  init_locales();
  if (locales == NULL)
    return NULL;
  return locales[idx];
}
#endif

#endif
