void delete_from_filelist (int filetype, const char *fname)
{
char *tmp[MAXRECENT];
char **filep;
int i, match = -1;
filep = get_file_list(filetype);
if (filep == NULL) {
return;
}
/* save pointers to current order */
for (i=0; i<MAXRECENT; i++) {
tmp[i] = filep[i];
if (!fnamecmp(filep[i], fname)) {
match = i;
}
}
if (match == -1) {
return;
}
/* clear menu files list before rebuilding */
clear_files_list(filetype, filep);
for (i=match; i<MAXRECENT-1; i++) {
filep[i] = tmp[i+1];
}
filep[MAXRECENT-1] = tmp[match];
filep[MAXRECENT-1][0] = '\0';
add_files_to_menu(filetype);
}
/*
* maintains the list of already visited files and dirs
* returns FAIL if the given file/dir is already in the list
* returns OK if it is newly added
*/
static int ff_check_visited(ff_visited_T **visited_list, char_u *fname, char_u *wc_path)
{
ff_visited_T *vp;
bool url = false;
FileInfo file_info;
// For a URL we only compare the name, otherwise we compare the
// device/inode.
if (path_with_url(fname)) {
STRLCPY(ff_expand_buffer, fname, MAXPATHL);
url = true;
} else {
ff_expand_buffer[0] = NUL;
if (!os_get_file_info((char *)fname, &file_info)) {
return FAIL;
}
}
/* check against list of already visited files */
for (vp = *visited_list; vp != NULL; vp = vp->ffv_next) {
if ((url && fnamecmp(vp->ffv_fname, ff_expand_buffer) == 0)
|| (!url && vp->ffv_dev_valid
&& vp->ffv_dev == file_info.stat.st_dev
&& vp->ffv_ino == file_info.stat.st_ino)) {
/* are the wildcard parts equal */
if (ff_wc_equal(vp->ffv_wc_path, wc_path) == TRUE)
/* already visited */
return FAIL;
}
}
/*
* New file/dir. Add it to the list of visited files/dirs.
*/
vp = xmalloc(sizeof(ff_visited_T) + STRLEN(ff_expand_buffer));
if (!url) {
vp->ffv_dev_valid = TRUE;
vp->ffv_ino = file_info.stat.st_ino;
vp->ffv_dev = file_info.stat.st_dev;
vp->ffv_fname[0] = NUL;
} else {
vp->ffv_dev_valid = FALSE;
STRCPY(vp->ffv_fname, ff_expand_buffer);
}
if (wc_path != NULL)
vp->ffv_wc_path = vim_strsave(wc_path);
else
vp->ffv_wc_path = NULL;
vp->ffv_next = *visited_list;
*visited_list = vp;
return OK;
}
static void fmarks_check_one(xfmark_T *fm, char_u *name, buf_T *buf)
{
if (fm->fmark.fnum == 0
&& fm->fname != NULL
&& fnamecmp(name, fm->fname) == 0) {
fm->fmark.fnum = buf->b_fnum;
vim_free(fm->fname);
fm->fname = NULL;
}
}
/*
* maintains the list of already visited files and dirs
* returns FAIL if the given file/dir is already in the list
* returns OK if it is newly added
*/
static int ff_check_visited(ff_visited_T **visited_list, char_u *fname, char_u *wc_path)
{
ff_visited_T *vp;
bool url = false;
FileID file_id;
// For an URL we only compare the name, otherwise we compare the
// device/inode.
if (path_with_url((char *)fname)) {
STRLCPY(ff_expand_buffer, fname, MAXPATHL);
url = true;
} else {
ff_expand_buffer[0] = NUL;
if (!os_fileid((char *)fname, &file_id)) {
return FAIL;
}
}
/* check against list of already visited files */
for (vp = *visited_list; vp != NULL; vp = vp->ffv_next) {
if ((url && fnamecmp(vp->ffv_fname, ff_expand_buffer) == 0)
|| (!url && vp->file_id_valid
&& os_fileid_equal(&(vp->file_id), &file_id))) {
// are the wildcard parts equal
if (ff_wc_equal(vp->ffv_wc_path, wc_path)) {
// already visited
return FAIL;
}
}
}
/*
* New file/dir. Add it to the list of visited files/dirs.
*/
vp = xmalloc(sizeof(ff_visited_T) + STRLEN(ff_expand_buffer));
if (!url) {
vp->file_id_valid = true;
vp->file_id = file_id;
vp->ffv_fname[0] = NUL;
} else {
vp->file_id_valid = false;
STRCPY(vp->ffv_fname, ff_expand_buffer);
}
if (wc_path != NULL)
vp->ffv_wc_path = vim_strsave(wc_path);
else
vp->ffv_wc_path = NULL;
vp->ffv_next = *visited_list;
*visited_list = vp;
return OK;
}
/*
* Returns the already visited list for the given filename. If none is found it
* allocates a new one.
*/
static ff_visited_list_hdr_T *ff_get_visited_list(char_u *filename, ff_visited_list_hdr_T **list_headp)
{
ff_visited_list_hdr_T *retptr = NULL;
/* check if a visited list for the given filename exists */
if (*list_headp != NULL) {
retptr = *list_headp;
while (retptr != NULL) {
if (fnamecmp(filename, retptr->ffvl_filename) == 0) {
#ifdef FF_VERBOSE
if (p_verbose >= 5) {
verbose_enter_scroll();
smsg((char_u *)"ff_get_visited_list: FOUND list for %s",
filename);
/* don't overwrite this either */
msg_puts((char_u *)"\n");
verbose_leave_scroll();
}
#endif
return retptr;
}
retptr = retptr->ffvl_next;
}
}
#ifdef FF_VERBOSE
if (p_verbose >= 5) {
verbose_enter_scroll();
smsg((char_u *)"ff_get_visited_list: new list for %s", filename);
/* don't overwrite this either */
msg_puts((char_u *)"\n");
verbose_leave_scroll();
}
#endif
/*
* if we reach this we didn't find a list and we have to allocate new list
*/
retptr = (ff_visited_list_hdr_T*)alloc((unsigned)sizeof(*retptr));
if (retptr == NULL)
return NULL;
retptr->ffvl_visited_list = NULL;
retptr->ffvl_filename = vim_strsave(filename);
if (retptr->ffvl_filename == NULL) {
vim_free(retptr);
return NULL;
}
retptr->ffvl_next = *list_headp;
*list_headp = retptr;
return retptr;
}
/// Sort "gap" and remove duplicate entries. "gap" is expected to contain a
/// list of file names in allocated memory.
///
/// @param gap
void ga_remove_duplicate_strings(garray_T *gap)
{
int i;
int j;
char_u **fnames = (char_u **)gap->ga_data;
sort_strings(fnames, gap->ga_len);
for (i = gap->ga_len - 1; i > 0; --i)
if (fnamecmp(fnames[i - 1], fnames[i]) == 0) {
vim_free(fnames[i]);
for (j = i + 1; j < gap->ga_len; ++j)
fnames[j - 1] = fnames[j];
--gap->ga_len;
}
}
/// Sort "gap" and remove duplicate entries. "gap" is expected to contain a
/// list of file names in allocated memory.
///
/// @param gap
void ga_remove_duplicate_strings(garray_T *gap)
{
char_u **fnames = gap->ga_data;
// sort the growing array, which puts duplicates next to each other
sort_strings(fnames, gap->ga_len);
// loop over the growing array in reverse
for (int i = gap->ga_len - 1; i > 0; i--) {
if (fnamecmp(fnames[i - 1], fnames[i]) == 0) {
vim_free(fnames[i]);
// close the gap (move all strings one slot lower)
for (int j = i + 1; j < gap->ga_len; j++) {
fnames[j - 1] = fnames[j];
}
--gap->ga_len;
}
}
}
/*
* 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;
}
/*
* args_ok
*
* prepare args, check & parse user args, display error and
* help message if neccessary
*
* result: TRUE, if all args ok
*/
BOOL args_ok(HSCPRC * hp, int argc, char *argv[])
{
BOOL ok; /* return value */
DLLIST *ignore_list = NULL; /* dummy */
EXPSTR *destdir = init_estr(32); /* destination dir */
EXPSTR *rel_destdir = init_estr(32); /* relative destination dir */
EXPSTR *kack_name = init_estr(0); /* temp. str for outfilename */
struct arglist *hsc_args; /* argument structure */
arg_hp = hp;
arg_mode_CB(DEFAULT_MODE_STR);
/* create arg-table */
hsc_args =
prepare_args("HSC_ARGS",
/* file args */
"FROM/M", &incfile,
"include- and input-file(s)",
"TO/K", &arg_outfname,
"output file (default: stdout)",
"PRJFILE/T/K", &prjfilename,
"project file (default: none)",
"PREFSFILE/T/K", &prefsfilename,
"syntax preferences (default: hsc.prefs)",
"MSGFILE=MF/T/K", &msgfilename,
"message file (default: stderr)",
"MSGFORMAT/T/K", &msg_format,
"how to display message",
/* numeric */
"MAXERR/N/K", &max_error,
"max. number of errors (default: 20)",
"EXTENSION/T/K", &arg_extension,
"output-file-extension (default: " DEFAULT_EXTENSION ")",
"DEFINE=DEF/T/K/M", &define_list,
"define global attribute",
"IGNORE=IGN/N/K/M/$", arg_ignore_CB, &ignore_list,
"ignore message number",
"MODE/E/K/$", arg_mode_CB, MODE_ENUMSTR, &arg_mode,
"mode for syntax check (" MODE_ENUMSTR ")",
"QUOTESTYLE=QS/E/K", QMODE_ENUMSTR, &arg_quotemode,
"defines how quotes appear (" QMODE_ENUMSTR ")",
#if 0
"ENTITYSTYLE=ES/E/K", EMODE_ENUMSTR, &entmode,
"defines how special chars. appear (" EMODE_ENUMSTR ")",
/* switches */
#endif
"COMPACT=CO/S", &arg_compact,
"strip useless LFs and white-spaces",
"GETSIZE/S", &arg_getsize,
"get width and height of images",
"MSGANSI/S", &msg_ansi,
"use ansi-sequences in messages",
"RPLCENT=RE/S", &arg_rplc_ent,
"replace special characters",
"RPLCQUOTE=RQ/S", &arg_rplc_quote,
"replace quotes in text by `"'",
"SMARTENT=SA/S", &arg_smart_ent,
"replace special entities (`&<>\"')",
"JENS/S", &arg_jens,
"don't try this at home",
"STRIPCOMMENT=SC/S", &arg_strip_cmt,
"strip SGML-comments",
"STRIPEXTERNAL=SX/S", &arg_strip_ext,
"strip tags with external URIs",
"STRIPTAGS=ST/K", &arg_striptags,
"tags to be stripped",
"ICONBASE/T/K", &arg_iconbase,
"base-uri for icon-entities",
"STATUS/E/K/$", arg_status_CB,
STATUS_ENUM_STR, &disp_status,
"status message (" STATUS_ENUM_STR ")",
"-DEBUG/S", &arg_debug, "enable debugging output",
/* help */
"HELP=?/S", &arg_help, "display this text",
"LICENSE/S", &arg_license, "display license",
NULL);
/* remove dummy list TODO: this sucks */
del_dllist(ignore_list);
ok = (hsc_args != NULL);
/* set & test args */
if (ok)
{
BOOL use_stdout = FALSE; /* flag: use stdout as output-file */
ok = set_args(argc, argv, hsc_args);
/* display help, if requested vie HELP switch, or no
* input to pipe or read is passed */
ok &= (!arg_help &&
(arg_pipe_in || (incfile && dll_first(incfile))));
if (arg_license)
{
/* display license text */
fprintf_prginfo(stderr);
show_license();
set_return_code(RC_WARN);
}
else if (!ok)
{
/* display help, if error in args or HELP-switch set */
fprintf_prginfo(stderr);
fprintf_arghelp(stderr, hsc_args);
set_return_code(RC_WARN);
}
else
{
BOOL fnsux = FALSE; /* flag: TRUE = can't evaluate out-filename */
/* set debugging switch */
hsc_set_debug(hp, arg_debug);
/* autoset depending options */
if (hsc_get_debug(hp))
disp_status = STATUS_VERBOSE;
/* set default options */
if (!arg_extension)
arg_extension = DEFAULT_EXTENSION;
/* disable ID-warning if no project-file */
if (!prjfilename)
hsc_set_msg_ignore(hp, MSG_NO_DOCENTRY, TRUE);
/* compute name of input file */
arg_inpfname = NULL;
if (dll_first(incfile) && !arg_pipe_in)
{
/* use last FROM as input file */
arg_inpfname = dln_data(dll_last(incfile));
set_estr(inpfilename, arg_inpfname);
/* get path part of inputfilename as relative
* destination directory */
get_fpath(rel_destdir, arg_inpfname);
/* TODO: set reldir when including first file */
/* TODO: find out why the above TODO is there */
/* remove input filename from incfile */
del_dlnode(incfile, dll_last(incfile));
D(fprintf(stderr, DHSC "input : use `%s'\n"
DHSC "reldir: use `%s'\n",
estr2str(inpfilename), estr2str(rel_destdir)));
}
/* display include files */
D(
{
DLNODE * nd = dll_first(incfile);
while (nd)
{
fprintf(stderr, DHSC "includ: use `%s'\n", (
STRPTR) dln_data(nd));
nd = dln_next(nd);
}
}
);
/*
* if no output-filename given,
* outfilename stays NULL. this let open_output
* open stdout as output-file
*/
if (arg_outfname)
{
/* check, if last char of outputfilename is a
* directory separator; if so, use the filename
* as destination directory
*/
if (arg_outfname)
{
UBYTE lastch = 0;
/* get last char of outfname to determine
* if it's a directory
*/
if (strlen(arg_outfname))
lastch = arg_outfname[strlen(arg_outfname) - 1];
#ifdef AMIGA
/* for Amiga, execpt empty string for current dir */
if (!lastch)
{
lastch = (PATH_SEPARATOR[0]);
D(fprintf(stderr, DHSC "AMIGA: use current dir\n"));
}
#endif
if (strchr(PATH_SEPARATOR, lastch))
{
/* use outfilename as destdir */
set_estr(destdir, arg_outfname);
arg_outfname = NULL;
D(fprintf(stderr, DHSC "output: use `%s' as destdir\n",
estr2str(destdir)));
}
else if (arg_inpfname)
{
/* output-filename already specified */
/* separate it to destdir + reldir + name */
EXPSTR *kack_destdir = init_estr(0);
EXPSTR *kack_reldir = init_estr(0);
STRPTR inp_reldir = estr2str(rel_destdir);
STRPTR out_reldir = NULL;
STRPTR ou2_reldir = NULL;
get_fname(kack_name, arg_outfname);
get_fpath(kack_destdir, arg_outfname);
/* check corresponding dirs for
* consistency: check if last strlen(rel_destdir)
* chars are equal */
out_reldir = estr2str(kack_destdir);
ou2_reldir = out_reldir;
out_reldir = out_reldir
+ (strlen(out_reldir) - strlen(inp_reldir));
if (out_reldir[0])
{
/* search for next dir-sparator backwards */
/* (this ones only needed for a smart error message) */
while ((out_reldir != ou2_reldir)
&& (!strchr(PATH_SEPARATOR, out_reldir[0]))
)
{
out_reldir--;
}
out_reldir++;
}
D(fprintf(stderr, DHSC "corr_inp: `%s'\n"
DHSC "corr_out: `%s'\n",
inp_reldir, out_reldir)
);
/* check if correspondig relative in/out-dirs
* are equal */
if (!fnamecmp(inp_reldir, out_reldir))
{
/* they match.. */
STRPTR tmp_name = NULL; /* copy of kack_nam */
/* cut corresponding chars */
get_left_estr(kack_destdir, kack_destdir,
estrlen(kack_destdir)
- strlen(out_reldir));
set_estr(kack_reldir, inp_reldir);
D(fprintf(stderr, DHSC "kack_dst: `%s'\n"
DHSC "kack_rel: `%s'\n"
DHSC "kack_nam: `%s'\n",
estr2str(kack_destdir),
estr2str(kack_reldir),
estr2str(kack_name))
);
/* just copy these values where they are
* expected to be */
estrcpy(destdir, kack_destdir);
estrcpy(rel_destdir, kack_reldir);
/* create output filename */
tmp_name = strclone(estr2str(kack_name));
estrcpy(kack_name, kack_destdir);
estrcat(kack_name, kack_reldir);
app_estr(kack_name, tmp_name);
ufreestr(tmp_name);
arg_outfname = estr2str(kack_name);
}
else
{
/* unmatched corresponding dirs */
fprintf(stderr, "unmatched corresponding relative directories:\n"
" input `%s'\n output `%s'\n",
inp_reldir, out_reldir);
ok = FALSE;
}
/* free temp. vars */
del_estr(kack_reldir);
del_estr(kack_destdir);
}
}
if (arg_outfname)
{
/* set outputfilename with value passed iwithin args */
outfilename = init_estr(32);
set_estr(outfilename, arg_outfname);
D(fprintf(stderr, DHSC "output: set to `%s'\n",
estr2str(outfilename)));
}
else
{
if (!arg_pipe_in)
{
/* no outfilename given */
/* ->outfilename = destdir + inpfilename + ".html" */
/* link destdir & input filename */
outfilename = init_estr(32);
link_fname(outfilename, estr2str(destdir),
arg_inpfname);
if (strcmp(arg_extension, "."))
set_fext(outfilename, arg_extension);
D(fprintf(stderr,
DHSC "output: concat destdir+inpfile+`.%s'\n"
DHSC "output: set to `%s'\n",
arg_extension, estr2str(outfilename)));
}
else
fnsux = TRUE;
}
if (fnsux)
{
/* no way to find out output filename */
status_error("unable to evaluate output filename\n");
arg_outfname = NULL;
ok = FALSE;
}
}
else
{
D(fprintf(stderr, DHSC "output: use stdout\n"));
use_stdout = TRUE;
}
if (!ok)
set_return_code(RC_ERROR);
}
if (ok)
{
if (arg_iconbase)
hsc_set_iconbase(hp, arg_iconbase);
if (!use_stdout)
hsc_set_filename_document(hp, estr2str(outfilename));
}
/* display argument error message */
if (!ok)
{
/* NOTE: no strclone() is used on outfilename, if an
* error already occured within set_args(). therefore,
* you must not call ufreestr( outfilename ) */
pargerr();
arg_outfname = NULL;
set_return_code(RC_ERROR);
}
else
{
EXPSTR *tmp_fname = init_estr(32); /* filename only part */
fileattr_str = init_estr(64);
if (outfilename)
get_fname(tmp_fname, estr2str(outfilename));
set_dest_attribs(hp, estr2str(rel_destdir),
estr2str(tmp_fname));
if (!arg_pipe_in)
{
if (outfilename)
get_fname(tmp_fname, estr2str(outfilename));
else
clr_estr(tmp_fname);
set_source_attribs(hp, estr2str(rel_destdir),
estr2str(tmp_fname));
}
else
set_source_attribs(hp, NULL, NULL);
D(
{
HSCMSG_ID i;
fprintf(stderr, "\n"
DHSC "input : `%s'\n", estr2str(inpfilename));
fprintf(stderr, DHSC "output: `%s'\n", get_outfilename());
fprintf(stderr, DHSC "destdr: `%s'\n", estr2str(destdir));
fprintf(stderr, DHSC "reldst: `%s'\n", estr2str(rel_destdir));
if (prjfilename)
fprintf(stderr, DHSC "projct: `%s'\n", prjfilename);
if (!use_stdout)
fprintf(stderr, DHSC "procss: `%s'\n", estr2str(outfilename));
fprintf(stderr, DHSC "ignore:");
for (i = 0; i < MAX_MSGID; i++)
if (hsc_get_msg_ignore(hp, i))
fprintf(stderr, " %lu", i);
fprintf(stderr, "\n");
}
);
del_estr(tmp_fname);
}
/*
* Handle marks in the viminfo file:
* fp_out != NULL: copy marks for buffers not in buffer list
* fp_out == NULL && (flags & VIF_WANT_MARKS): read marks for curbuf only
* fp_out == NULL && (flags & VIF_GET_OLDFILES | VIF_FORCEIT): fill v:oldfiles
*/
void copy_viminfo_marks(vir_T *virp, FILE *fp_out, int count, int eof, int flags)
{
char_u *line = virp->vir_line;
buf_T *buf;
int num_marked_files;
int load_marks;
int copy_marks_out;
char_u *str;
int i;
char_u *p;
char_u *name_buf;
pos_T pos;
list_T *list = NULL;
if ((name_buf = alloc(LSIZE)) == NULL)
return;
*name_buf = NUL;
if (fp_out == NULL && (flags & (VIF_GET_OLDFILES | VIF_FORCEIT))) {
list = list_alloc();
if (list != NULL)
set_vim_var_list(VV_OLDFILES, list);
}
num_marked_files = get_viminfo_parameter('\'');
while (!eof && (count < num_marked_files || fp_out == NULL)) {
if (line[0] != '>') {
if (line[0] != '\n' && line[0] != '\r' && line[0] != '#') {
if (viminfo_error("E576: ", _("Missing '>'"), line))
break; /* too many errors, return now */
}
eof = vim_fgets(line, LSIZE, virp->vir_fd);
continue; /* Skip this dud line */
}
/*
* Handle long line and translate escaped characters.
* Find file name, set str to start.
* Ignore leading and trailing white space.
*/
str = skipwhite(line + 1);
str = viminfo_readstring(virp, (int)(str - virp->vir_line), FALSE);
if (str == NULL)
continue;
p = str + STRLEN(str);
while (p != str && (*p == NUL || vim_isspace(*p)))
p--;
if (*p)
p++;
*p = NUL;
if (list != NULL)
list_append_string(list, str, -1);
/*
* If fp_out == NULL, load marks for current buffer.
* If fp_out != NULL, copy marks for buffers not in buflist.
*/
load_marks = copy_marks_out = FALSE;
if (fp_out == NULL) {
if ((flags & VIF_WANT_MARKS) && curbuf->b_ffname != NULL) {
if (*name_buf == NUL) /* only need to do this once */
home_replace(NULL, curbuf->b_ffname, name_buf, LSIZE, TRUE);
if (fnamecmp(str, name_buf) == 0)
load_marks = TRUE;
}
} else { /* fp_out != NULL */
/* This is slow if there are many buffers!! */
for (buf = firstbuf; buf != NULL; buf = buf->b_next)
if (buf->b_ffname != NULL) {
home_replace(NULL, buf->b_ffname, name_buf, LSIZE, TRUE);
if (fnamecmp(str, name_buf) == 0)
break;
}
/*
* copy marks if the buffer has not been loaded
*/
if (buf == NULL || !buf->b_marks_read) {
copy_marks_out = TRUE;
fputs("\n> ", fp_out);
viminfo_writestring(fp_out, str);
count++;
}
}
vim_free(str);
pos.coladd = 0;
while (!(eof = viminfo_readline(virp)) && line[0] == TAB) {
if (load_marks) {
if (line[1] != NUL) {
unsigned u;
sscanf((char *)line + 2, "%ld %u", &pos.lnum, &u);
pos.col = u;
switch (line[1]) {
case '"': curbuf->b_last_cursor = pos; break;
case '^': curbuf->b_last_insert = pos; break;
case '.': curbuf->b_last_change = pos; break;
case '+':
/* changelist positions are stored oldest
* first */
if (curbuf->b_changelistlen == JUMPLISTSIZE)
/* list is full, remove oldest entry */
mch_memmove(curbuf->b_changelist,
curbuf->b_changelist + 1,
sizeof(pos_T) * (JUMPLISTSIZE - 1));
else
++curbuf->b_changelistlen;
curbuf->b_changelist[
curbuf->b_changelistlen - 1] = pos;
break;
default: if ((i = line[1] - 'a') >= 0 && i < NMARKS)
curbuf->b_namedm[i] = pos;
}
}
} else if (copy_marks_out)
fputs((char *)line, fp_out);
}
if (load_marks) {
win_T *wp;
FOR_ALL_WINDOWS(wp)
{
if (wp->w_buffer == curbuf)
wp->w_changelistidx = curbuf->b_changelistlen;
}
break;
}
}
vim_free(name_buf);
}
/*
* maintains the list of already visited files and dirs
* returns FAIL if the given file/dir is already in the list
* returns OK if it is newly added
*
* TODO: What to do on memory allocation problems?
* -> return TRUE - Better the file is found several times instead of
* never.
*/
static int ff_check_visited(ff_visited_T **visited_list, char_u *fname, char_u *wc_path)
{
ff_visited_T *vp;
#ifdef UNIX
struct stat st;
int url = FALSE;
#endif
/* For an URL we only compare the name, otherwise we compare the
* device/inode (unix) or the full path name (not Unix). */
if (path_with_url(fname)) {
vim_strncpy(ff_expand_buffer, fname, MAXPATHL - 1);
#ifdef UNIX
url = TRUE;
#endif
} else {
ff_expand_buffer[0] = NUL;
#ifdef UNIX
if (mch_stat((char *)fname, &st) < 0)
#else
if (vim_FullName(fname, ff_expand_buffer, MAXPATHL, TRUE) == FAIL)
#endif
return FAIL;
}
/* check against list of already visited files */
for (vp = *visited_list; vp != NULL; vp = vp->ffv_next) {
if (
#ifdef UNIX
!url ? (vp->ffv_dev_valid && vp->ffv_dev == st.st_dev
&& vp->ffv_ino == st.st_ino)
:
#endif
fnamecmp(vp->ffv_fname, ff_expand_buffer) == 0
) {
/* are the wildcard parts equal */
if (ff_wc_equal(vp->ffv_wc_path, wc_path) == TRUE)
/* already visited */
return FAIL;
}
}
/*
* New file/dir. Add it to the list of visited files/dirs.
*/
vp = (ff_visited_T *)alloc((unsigned)(sizeof(ff_visited_T)
+ STRLEN(ff_expand_buffer)));
if (vp != NULL) {
#ifdef UNIX
if (!url) {
vp->ffv_dev_valid = TRUE;
vp->ffv_ino = st.st_ino;
vp->ffv_dev = st.st_dev;
vp->ffv_fname[0] = NUL;
} else {
vp->ffv_dev_valid = FALSE;
#endif
STRCPY(vp->ffv_fname, ff_expand_buffer);
#ifdef UNIX
}
#endif
if (wc_path != NULL)
vp->ffv_wc_path = vim_strsave(wc_path);
else
vp->ffv_wc_path = NULL;
vp->ffv_next = *visited_list;
*visited_list = vp;
}
return OK;
}
static int real_archive_files (const char *targ, const char **filenames,
int level, ZipOption opt, int task,
GError **gerr)
{
int attr; /* attributes of zip file */
flist *f; /* steps through found linked list */
int i; /* arg counter, root directory flag */
int k; /* marked counter, comment size, entry count */
int openerr = 0; /* true if there were any ZE_OPEN errors */
guint32 t; /* file time, length of central directory */
zlist **w; /* pointer to last link in zfiles list */
zlist *z; /* steps through zfiles linked list */
FILE *fr = NULL; /* for reading from original zipfile */
char tempzip[FILENAME_MAX]; /* name for temporary zipfile */
int err = 0;
zfile zf;
*tempzip = '\0';
if (level < 0 || level > 9) {
fprintf(stderr, "invalid compression level %d: setting to 6\n", level);
level = 6;
}
zfile_init(&zf, level, opt);
trace(1, "real_archive_files: targ = '%s'\n", targ);
zf.fname = g_strdup(targ);
if (zf.fname == NULL) {
err = ziperr(ZE_MEM, "was processing arguments");
goto bailout;
}
if (task != ZIP_DO_NEW) {
/* if ZIP_DO_NEW, disregard any existing zipfile */
err = read_zipfile(&zf, ZIP_DO_ZIP);
if (err) {
err = ziperr(err, zf.fname);
goto bailout;
}
}
/* assemble list of filenames to be added/updated */
k = 0;
for (i=0; filenames[i] != NULL; i++) {
if (!gretl_file_test(filenames[i], G_FILE_TEST_EXISTS)) {
err = ziperr(ZE_OPEN, "file '%s' was not found", filenames[i]);
goto bailout;
}
err = add_filenames(filenames[i], &zf);
if (err) {
ziperr(err, filenames[i]);
goto bailout;
} else {
k++;
}
}
if (k == 0) {
err = ziperr(ZE_NONE, NULL);
goto bailout;
}
if (zf.zcount) {
free(zf.zsort);
zf.zsort = NULL;
}
/* For each marked entry, check if it exists, and, if updating,
compare date with entry in existing zipfile. Unmark if it
doesn't exist or is too old, else update marked count.
*/
k = 0;
for (z = zfiles; z != NULL; z = z->nxt) {
if (z->mark == MARK_ZIP) {
if (dont_keep_file(z, &zf)) {
z->mark = MARK_NONE;
} else {
k++;
}
}
}
/* Remove entries from "found" list that do not exist or are
otherwise invalid
*/
for (f = found; f != NULL; ) {
t = file_mod_time(f->name, NULL, NULL, NULL, &zf);
if (t == 0 || !fnamecmp(f->zname, zf.fname)) {
f = flist_expel(f, &zf.fcount);
} else {
f = f->nxt;
}
}
err = zipfile_write_check(&zf, task, &attr);
if (err) {
goto bailout;
}
if (zfiles != NULL || zf.zstart) {
trace(1, "opening original zip file for reading\n");
fr = fopen(zf.fname, "rb");
if (fr == NULL) {
err = ziperr(ZE_NAME, zf.fname);
goto bailout;
}
}
strcpy(tempzip, zf.fname);
zf.fp = ztempfile(tempzip);
if (zf.fp == NULL) {
fprintf(stderr, " real_archive_files: ztempfile failed\n");
err = ziperr(ZE_TEMP, tempzip);
goto bailout;
}
if (zf.zstart > 0) {
/* copy initial chunk of old zipfile as is */
err = fcopy(fr, zf.fp, zf.zstart);
if (err != Z_OK) {
err = ziperr(err, (err == ZE_TEMP)? tempzip : zf.fname);
goto bailout;
}
}
zf.tempzn = zf.zstart;
trace(2, "after initial read, tempzn = %d\n", (int) zf.tempzn);
err = process_zfiles(&zf, fr, &w, &openerr);
if (err) {
fclose(zf.fp);
if (fr != NULL) {
fclose(fr);
}
goto bailout;
}
/* Process the edited found list, adding them to the zip file */
trace(2, "now zipping up new entries, fcount=%u\n", (unsigned) zf.fcount);
for (f = found; f != NULL; f = flist_expel(f, &zf.fcount)) {
/* add a new zfiles entry and set the name */
z = zlist_entry_new(f);
if (z == NULL) {
err = ziperr(ZE_MEM, "was adding files to zip file");
goto bailout;
}
err = zipup(&zf, z);
if (err && err != ZE_OPEN && err != ZE_MISS) {
err = ziperr(err, "was zipping %s", z->zname);
goto bailout;
}
if (err == ZE_OPEN || err == ZE_MISS) {
openerr = 1;
if (err == ZE_OPEN) {
perror("zip warning");
}
free_zlist_entry(z);
} else {
*w = z;
w = &z->nxt;
zf.zcount += 1;
}
}
err = write_central_and_end(&zf, tempzip);
fclose(zf.fp);
zf.fp = NULL;
if (fr != NULL) {
fclose(fr);
}
/* Replace old zip file with new zip file, leaving only the new one */
if (!err) {
trace(1, "moving %s into position as %s\n", tempzip, zf.fname);
err = replace_file(zf.fname, tempzip);
if (err) {
ziperr(err, "was replacing %s", zf.fname);
} else if (attr) {
chmod(zf.fname, attr);
}
}
bailout:
zlib_deflate_free(&zf);
if (err && *tempzip != '\0') {
/* clean up */
gretl_remove(tempzip);
}
zip_finish(&zf);
if (err && gerr != NULL) {
make_gerr(err, gerr);
}
trace(1, "returning err = %d\n", err);
return err;
}
void mkfilelist (int filetype, char *fname)
{
char *tmp[MAXRECENT-1];
char **filep;
int i, pos = -1;
#if FDEBUG
fprintf(stderr, "mkfilelist: type=%d, fname='%s'\n",
filetype, fname);
#endif
gretl_normalize_path(fname);
filep = get_file_list(filetype);
if (filep == NULL) {
return;
}
/* see if this file is already on the list */
for (i=0; i<MAXRECENT; i++) {
if (!fnamecmp(filep[i], fname)) {
pos = i;
#if FDEBUG
fprintf(stderr, "file already on list at pos %d\n", i);
#endif
break;
}
}
if (pos == 0) {
/* file is on top: no change is needed */
return;
}
/* clear menu files list before rebuilding */
clear_files_list(filetype, filep);
/* save pointers to current order */
for (i=0; i<MAXRECENT-1; i++) {
tmp[i] = filep[i];
}
/* copy fname into array, if not already present */
if (pos == -1) {
/* look for an empty slot */
for (i=1; i<MAXRECENT; i++) {
if (filep[i][0] == '\0') {
strcpy(filep[i], fname);
pos = i;
break;
}
}
if (pos == -1) {
/* no empty slot available */
pos = MAXRECENT - 1;
strcpy(filep[pos], fname);
}
}
/* set first pointer to newest file */
filep[0] = filep[pos];
/* and rearrange the other pointers */
for (i=1; i<=pos; i++) {
filep[i] = tmp[i-1];
}
add_files_to_menu(filetype);
}
