void listdigraphs(void)
{
digr_T *dp;
msg_putchar('\n');
dp = digraphdefault;
for (int i = 0; dp->char1 != NUL && !got_int; ++i) {
digr_T tmp;
// May need to convert the result to 'encoding'.
tmp.char1 = dp->char1;
tmp.char2 = dp->char2;
tmp.result = getexactdigraph(tmp.char1, tmp.char2, FALSE);
if ((tmp.result != 0)
&& (tmp.result != tmp.char2)
&& (has_mbyte || (tmp.result <= 255))) {
printdigraph(&tmp);
}
dp++;
ui_breakcheck();
}
dp = (digr_T *)user_digraphs.ga_data;
for (int i = 0; i < user_digraphs.ga_len && !got_int; ++i) {
printdigraph(dp);
ui_breakcheck();
dp++;
}
// clear screen, because some digraphs may be wrong, in which case we messed
// up ScreenLines
must_redraw = CLEAR;
}
/*
* print the changelist
*/
void ex_changes(exarg_T *eap)
{
int i;
char_u *name;
/* Highlight title */
MSG_PUTS_TITLE(_("\nchange line col text"));
for (i = 0; i < curbuf->b_changelistlen && !got_int; ++i) {
if (curbuf->b_changelist[i].lnum != 0) {
msg_putchar('\n');
if (got_int)
break;
sprintf((char *)IObuff, "%c %3d %5ld %4d ",
i == curwin->w_changelistidx ? '>' : ' ',
i > curwin->w_changelistidx ? i - curwin->w_changelistidx
: curwin->w_changelistidx - i,
(long)curbuf->b_changelist[i].lnum,
curbuf->b_changelist[i].col);
msg_outtrans(IObuff);
name = mark_line(&curbuf->b_changelist[i], 17);
if (name == NULL)
break;
msg_outtrans_attr(name, hl_attr(HLF_D));
vim_free(name);
ui_breakcheck();
}
out_flush();
}
if (curwin->w_changelistidx == curbuf->b_changelistlen)
MSG_PUTS("\n>");
}
/*
* print the jumplist
*/
void ex_jumps(exarg_T *eap)
{
int i;
char_u *name;
cleanup_jumplist();
/* Highlight title */
MSG_PUTS_TITLE(_("\n jump line col file/text"));
for (i = 0; i < curwin->w_jumplistlen && !got_int; ++i) {
if (curwin->w_jumplist[i].fmark.mark.lnum != 0) {
if (curwin->w_jumplist[i].fmark.fnum == 0)
fname2fnum(&curwin->w_jumplist[i]);
name = fm_getname(&curwin->w_jumplist[i].fmark, 16);
if (name == NULL) /* file name not available */
continue;
msg_putchar('\n');
if (got_int) {
vim_free(name);
break;
}
sprintf((char *)IObuff, "%c %2d %5ld %4d ",
i == curwin->w_jumplistidx ? '>' : ' ',
i > curwin->w_jumplistidx ? i - curwin->w_jumplistidx
: curwin->w_jumplistidx - i,
curwin->w_jumplist[i].fmark.mark.lnum,
curwin->w_jumplist[i].fmark.mark.col);
msg_outtrans(IObuff);
msg_outtrans_attr(name,
curwin->w_jumplist[i].fmark.fnum == curbuf->b_fnum
? hl_attr(HLF_D) : 0);
vim_free(name);
ui_breakcheck();
}
out_flush();
}
if (curwin->w_jumplistidx == curwin->w_jumplistlen)
MSG_PUTS("\n>");
}
/*
* Find a file in a search context.
* The search context was created with vim_findfile_init() above.
* Return a pointer to an allocated file name or NULL if nothing found.
* To get all matching files call this function until you get NULL.
*
* If the passed search_context is NULL, NULL is returned.
*
* The search algorithm is depth first. To change this replace the
* stack with a list (don't forget to leave partly searched directories on the
* top of the list).
*/
char_u *vim_findfile(void *search_ctx_arg)
{
char_u *file_path;
char_u *rest_of_wildcards;
char_u *path_end = NULL;
ff_stack_T *stackp;
int len;
int i;
char_u *p;
char_u *suf;
ff_search_ctx_T *search_ctx;
if (search_ctx_arg == NULL)
return NULL;
search_ctx = (ff_search_ctx_T *)search_ctx_arg;
/*
* filepath is used as buffer for various actions and as the storage to
* return a found filename.
*/
file_path = xmalloc(MAXPATHL);
/* store the end of the start dir -- needed for upward search */
if (search_ctx->ffsc_start_dir != NULL)
path_end = &search_ctx->ffsc_start_dir[
STRLEN(search_ctx->ffsc_start_dir)];
/* upward search loop */
for (;; ) {
/* downward search loop */
for (;; ) {
/* check if user user wants to stop the search*/
ui_breakcheck();
if (got_int)
break;
/* get directory to work on from stack */
stackp = ff_pop(search_ctx);
if (stackp == NULL)
break;
/*
* TODO: decide if we leave this test in
*
* GOOD: don't search a directory(-tree) twice.
* BAD: - check linked list for every new directory entered.
* - check for double files also done below
*
* Here we check if we already searched this directory.
* We already searched a directory if:
* 1) The directory is the same.
* 2) We would use the same wildcard string.
*
* Good if you have links on same directory via several ways
* or you have selfreferences in directories (e.g. SuSE Linux 6.3:
* /etc/rc.d/init.d is linked to /etc/rc.d -> endless loop)
*
* This check is only needed for directories we work on for the
* first time (hence stackp->ff_filearray == NULL)
*/
if (stackp->ffs_filearray == NULL
&& ff_check_visited(&search_ctx->ffsc_dir_visited_list
->ffvl_visited_list,
stackp->ffs_fix_path
, stackp->ffs_wc_path
) == FAIL) {
#ifdef FF_VERBOSE
if (p_verbose >= 5) {
verbose_enter_scroll();
smsg((char_u *)"Already Searched: %s (%s)",
stackp->ffs_fix_path, stackp->ffs_wc_path);
/* don't overwrite this either */
msg_puts((char_u *)"\n");
verbose_leave_scroll();
}
#endif
ff_free_stack_element(stackp);
continue;
}
#ifdef FF_VERBOSE
else if (p_verbose >= 5) {
verbose_enter_scroll();
smsg((char_u *)"Searching: %s (%s)",
stackp->ffs_fix_path, stackp->ffs_wc_path);
/* don't overwrite this either */
msg_puts((char_u *)"\n");
verbose_leave_scroll();
}
#endif
/* check depth */
if (stackp->ffs_level <= 0) {
ff_free_stack_element(stackp);
continue;
}
file_path[0] = NUL;
/*
* If no filearray till now expand wildcards
* The function expand_wildcards() can handle an array of paths
* and all possible expands are returned in one array. We use this
* to handle the expansion of '**' into an empty string.
*/
if (stackp->ffs_filearray == NULL) {
char_u *dirptrs[2];
/* we use filepath to build the path expand_wildcards() should
* expand.
*/
dirptrs[0] = file_path;
dirptrs[1] = NULL;
/* if we have a start dir copy it in */
if (!vim_isAbsName(stackp->ffs_fix_path)
&& search_ctx->ffsc_start_dir) {
STRCPY(file_path, search_ctx->ffsc_start_dir);
add_pathsep(file_path);
}
/* append the fix part of the search path */
STRCAT(file_path, stackp->ffs_fix_path);
add_pathsep(file_path);
rest_of_wildcards = stackp->ffs_wc_path;
if (*rest_of_wildcards != NUL) {
len = (int)STRLEN(file_path);
if (STRNCMP(rest_of_wildcards, "**", 2) == 0) {
/* pointer to the restrict byte
* The restrict byte is not a character!
*/
p = rest_of_wildcards + 2;
if (*p > 0) {
(*p)--;
file_path[len++] = '*';
}
if (*p == 0) {
/* remove '**<numb> from wildcards */
STRMOVE(rest_of_wildcards, rest_of_wildcards + 3);
} else
rest_of_wildcards += 3;
if (stackp->ffs_star_star_empty == 0) {
/* if not done before, expand '**' to empty */
stackp->ffs_star_star_empty = 1;
dirptrs[1] = stackp->ffs_fix_path;
}
}
/*
* Here we copy until the next path separator or the end of
* the path. If we stop at a path separator, there is
* still something else left. This is handled below by
* pushing every directory returned from expand_wildcards()
* on the stack again for further search.
*/
while (*rest_of_wildcards
&& !vim_ispathsep(*rest_of_wildcards))
file_path[len++] = *rest_of_wildcards++;
file_path[len] = NUL;
if (vim_ispathsep(*rest_of_wildcards))
rest_of_wildcards++;
}
/*
* Expand wildcards like "*" and "$VAR".
* If the path is a URL don't try this.
*/
if (path_with_url(dirptrs[0])) {
stackp->ffs_filearray = (char_u **)xmalloc(sizeof(char *));
stackp->ffs_filearray[0] = vim_strsave(dirptrs[0]);
stackp->ffs_filearray_size = 1;
} else
/* Add EW_NOTWILD because the expanded path may contain
* wildcard characters that are to be taken literally.
* This is a bit of a hack. */
expand_wildcards((dirptrs[1] == NULL) ? 1 : 2, dirptrs,
&stackp->ffs_filearray_size,
&stackp->ffs_filearray,
EW_DIR|EW_ADDSLASH|EW_SILENT|EW_NOTWILD);
stackp->ffs_filearray_cur = 0;
stackp->ffs_stage = 0;
} else
rest_of_wildcards = &stackp->ffs_wc_path[
STRLEN(stackp->ffs_wc_path)];
if (stackp->ffs_stage == 0) {
/* this is the first time we work on this directory */
if (*rest_of_wildcards == NUL) {
/*
* We don't have further wildcards to expand, so we have to
* check for the final file now.
*/
for (i = stackp->ffs_filearray_cur;
i < stackp->ffs_filearray_size; ++i) {
if (!path_with_url(stackp->ffs_filearray[i])
&& !os_isdir(stackp->ffs_filearray[i]))
continue; /* not a directory */
/* prepare the filename to be checked for existence
* below */
STRCPY(file_path, stackp->ffs_filearray[i]);
add_pathsep(file_path);
STRCAT(file_path, search_ctx->ffsc_file_to_search);
/*
* Try without extra suffix and then with suffixes
* from 'suffixesadd'.
*/
len = (int)STRLEN(file_path);
if (search_ctx->ffsc_tagfile)
suf = (char_u *)"";
else
suf = curbuf->b_p_sua;
for (;; ) {
/* if file exists and we didn't already find it */
if ((path_with_url(file_path)
|| (os_file_exists(file_path)
&& (search_ctx->ffsc_find_what
== FINDFILE_BOTH
|| ((search_ctx->ffsc_find_what
== FINDFILE_DIR)
== os_isdir(file_path)))))
#ifndef FF_VERBOSE
&& (ff_check_visited(
&search_ctx->ffsc_visited_list->ffvl_visited_list,
file_path
, (char_u *)""
) == OK)
#endif
) {
#ifdef FF_VERBOSE
if (ff_check_visited(
&search_ctx->ffsc_visited_list->ffvl_visited_list,
file_path
, (char_u *)""
) == FAIL) {
if (p_verbose >= 5) {
verbose_enter_scroll();
smsg((char_u *)"Already: %s",
file_path);
/* don't overwrite this either */
msg_puts((char_u *)"\n");
verbose_leave_scroll();
}
continue;
}
#endif
/* push dir to examine rest of subdirs later */
stackp->ffs_filearray_cur = i + 1;
ff_push(search_ctx, stackp);
if (!path_with_url(file_path))
simplify_filename(file_path);
if (os_dirname(ff_expand_buffer, MAXPATHL)
== OK) {
p = path_shorten_fname(file_path,
ff_expand_buffer);
if (p != NULL)
STRMOVE(file_path, p);
}
#ifdef FF_VERBOSE
if (p_verbose >= 5) {
verbose_enter_scroll();
smsg((char_u *)"HIT: %s", file_path);
/* don't overwrite this either */
msg_puts((char_u *)"\n");
verbose_leave_scroll();
}
#endif
return file_path;
}
/* Not found or found already, try next suffix. */
if (*suf == NUL)
break;
copy_option_part(&suf, file_path + len,
MAXPATHL - len, ",");
}
}
} else {
/*
* still wildcards left, push the directories for further
* search
*/
for (i = stackp->ffs_filearray_cur;
i < stackp->ffs_filearray_size; ++i) {
if (!os_isdir(stackp->ffs_filearray[i]))
continue; /* not a directory */
ff_push(search_ctx,
ff_create_stack_element(
stackp->ffs_filearray[i],
rest_of_wildcards,
stackp->ffs_level - 1, 0));
}
}
stackp->ffs_filearray_cur = 0;
stackp->ffs_stage = 1;
}
/*
* if wildcards contains '**' we have to descent till we reach the
* leaves of the directory tree.
*/
if (STRNCMP(stackp->ffs_wc_path, "**", 2) == 0) {
for (i = stackp->ffs_filearray_cur;
i < stackp->ffs_filearray_size; ++i) {
if (fnamecmp(stackp->ffs_filearray[i],
stackp->ffs_fix_path) == 0)
continue; /* don't repush same directory */
if (!os_isdir(stackp->ffs_filearray[i]))
continue; /* not a directory */
ff_push(search_ctx,
ff_create_stack_element(stackp->ffs_filearray[i],
stackp->ffs_wc_path, stackp->ffs_level - 1, 1));
}
}
/* we are done with the current directory */
ff_free_stack_element(stackp);
}
/* If we reached this, we didn't find anything downwards.
* Let's check if we should do an upward search.
*/
if (search_ctx->ffsc_start_dir
&& search_ctx->ffsc_stopdirs_v != NULL && !got_int) {
ff_stack_T *sptr;
/* is the last starting directory in the stop list? */
if (ff_path_in_stoplist(search_ctx->ffsc_start_dir,
(int)(path_end - search_ctx->ffsc_start_dir),
search_ctx->ffsc_stopdirs_v) == TRUE)
break;
/* cut of last dir */
while (path_end > search_ctx->ffsc_start_dir
&& vim_ispathsep(*path_end))
path_end--;
while (path_end > search_ctx->ffsc_start_dir
&& !vim_ispathsep(path_end[-1]))
path_end--;
*path_end = 0;
path_end--;
if (*search_ctx->ffsc_start_dir == 0)
break;
STRCPY(file_path, search_ctx->ffsc_start_dir);
add_pathsep(file_path);
STRCAT(file_path, search_ctx->ffsc_fix_path);
/* create a new stack entry */
sptr = ff_create_stack_element(file_path,
search_ctx->ffsc_wc_path, search_ctx->ffsc_level, 0);
ff_push(search_ctx, sptr);
} else
break;
}
free(file_path);
return NULL;
}
/*
* Sync the memory file *mfp to disk.
* Flags:
* MFS_ALL If not given, blocks with negative numbers are not synced,
* even when they are dirty!
* MFS_STOP Stop syncing when a character becomes available, but sync at
* least one block.
* MFS_FLUSH Make sure buffers are flushed to disk, so they will survive a
* system crash.
* MFS_ZERO Only write block 0.
*
* Return FAIL for failure, OK otherwise
*/
int
mf_sync(memfile_T *mfp, int flags)
{
int status;
bhdr_T *hp;
#if defined(SYNC_DUP_CLOSE)
int fd;
#endif
int got_int_save = got_int;
if (mfp->mf_fd < 0) /* there is no file, nothing to do */
{
mfp->mf_dirty = FALSE;
return FAIL;
}
/* Only a CTRL-C while writing will break us here, not one typed
* previously. */
got_int = FALSE;
/*
* sync from last to first (may reduce the probability of an inconsistent
* file) If a write fails, it is very likely caused by a full filesystem.
* Then we only try to write blocks within the existing file. If that also
* fails then we give up.
*/
status = OK;
for (hp = mfp->mf_used_last; hp != NULL; hp = hp->bh_prev)
if (((flags & MFS_ALL) || hp->bh_bnum >= 0)
&& (hp->bh_flags & BH_DIRTY)
&& (status == OK || (hp->bh_bnum >= 0
&& hp->bh_bnum < mfp->mf_infile_count)))
{
if ((flags & MFS_ZERO) && hp->bh_bnum != 0)
continue;
if (mf_write(mfp, hp) == FAIL)
{
if (status == FAIL) /* double error: quit syncing */
break;
status = FAIL;
}
if (flags & MFS_STOP)
{
/* Stop when char available now. */
if (ui_char_avail())
break;
}
else
ui_breakcheck();
if (got_int)
break;
}
/*
* If the whole list is flushed, the memfile is not dirty anymore.
* In case of an error this flag is also set, to avoid trying all the time.
*/
if (hp == NULL || status == FAIL)
mfp->mf_dirty = FALSE;
if ((flags & MFS_FLUSH) && *p_sws != NUL)
{
#if defined(UNIX)
# ifdef HAVE_FSYNC
/*
* most Unixes have the very useful fsync() function, just what we need.
* However, with OS/2 and EMX it is also available, but there are
* reports of bad problems with it (a bug in HPFS.IFS).
* So we disable use of it here in case someone tries to be smart
* and changes os_os2_cfg.h... (even though there is no __EMX__ test
* in the #if, as __EMX__ does not have sync(); we hope for a timely
* sync from the system itself).
*/
# if defined(__EMX__)
error "Don't use fsync with EMX! Read emxdoc.doc or emxfix01.doc for info."
# endif
if (STRCMP(p_sws, "fsync") == 0)
{
if (fsync(mfp->mf_fd))
status = FAIL;
}
else
# endif
/* OpenNT is strictly POSIX (Benzinger) */
/* Tandem/Himalaya NSK-OSS doesn't have sync() */
/* No sync() on Stratus VOS */
# if defined(__OPENNT) || defined(__TANDEM) || defined(__VOS__)
fflush(NULL);
# else
sync();
# endif
#endif
#ifdef VMS
if (STRCMP(p_sws, "fsync") == 0)
{
if (fsync(mfp->mf_fd))
status = FAIL;
}
#endif
#ifdef SYNC_DUP_CLOSE
/*
* Win32 is a bit more work: Duplicate the file handle and close it.
* This should flush the file to disk.
*/
if ((fd = dup(mfp->mf_fd)) >= 0)
close(fd);
#endif
#ifdef AMIGA
# if defined(__AROS__) || defined(__amigaos4__)
if (fsync(mfp->mf_fd) != 0)
status = FAIL;
# else
/*
* Flush() only exists for AmigaDos 2.0.
* For 1.3 it should be done with close() + open(), but then the risk
* is that the open() may fail and lose the file....
*/
# ifdef FEAT_ARP
if (dos2)
# endif
# ifdef SASC
{
struct UFB *fp = chkufb(mfp->mf_fd);
if (fp != NULL)
Flush(fp->ufbfh);
}
# else
# if defined(_DCC) || defined(__GNUC__) || defined(__MORPHOS__)
{
# if defined(__GNUC__) && !defined(__MORPHOS__) && defined(__libnix__)
/* Have function (in libnix at least),
* but ain't got no prototype anywhere. */
extern unsigned long fdtofh(int filedescriptor);
# endif
# if !defined(__libnix__)
fflush(NULL);
# else
BPTR fh = (BPTR)fdtofh(mfp->mf_fd);
if (fh != 0)
Flush(fh);
# endif
}
# else /* assume Manx */
Flush(_devtab[mfp->mf_fd].fd);
# endif
# endif
# endif
#endif /* AMIGA */
}
