void layout_status_update_image(LayoutWindow *lw)
{
gchar *text;
gchar *b;
if (!layout_valid(&lw) || !lw->image) return;
text = image_zoom_get_as_text(lw->image);
gtk_label_set_text(GTK_LABEL(lw->info_zoom), text);
g_free(text);
b = text_from_size(lw->image->size);
if (lw->image->unknown)
{
if (image_get_path(lw->image) && !access_file(image_get_path(lw->image), R_OK))
{
text = g_strdup_printf(_("(no read permission) %s bytes"), b);
}
else
{
text = g_strdup_printf(_("( ? x ? ) %s bytes"), b);
}
}
else
{
text = g_strdup_printf(_("( %d x %d ) %s bytes"),
lw->image->image_width, lw->image->image_height, b);
}
gtk_label_set_text(GTK_LABEL(lw->info_details), text);
g_free(b);
g_free(text);
}
int main(int argc, char **argv)
{
int line_number;
int fd;
char *line;
t_list *tokens;
if (argc < 2)
fatal_error(RAYTRACER, ERR_TOO_FEW_ARGS, 0);
if (argc > 2)
fatal_error(RAYTRACER, ERR_TOO_MANY_ARGS, 0);
line_number = 1;
fd = access_file(argv[1]);
while (get_next_line(fd, &line))
{
ft_lstappend(&tokens, tokenize(line, line_number));
line_number++;
free(line);
}
if (parse_exp(&tokens) && tokens == NULL)
ft_putendl("PARSE WIN");
else
{
WRITE(2, "Parse fail near : '");
ft_putstr_fd(get_token(&tokens)->lexeme, 2);
WRITE(2, "' at line ");
ft_putnbr_fd(get_token(&tokens)->line, 2);
ft_putchar('\n');
}
return (0);
}
static void vdtree_add_by_data(ViewDir *vd, FileData *fd, GtkTreeIter *parent)
{
GtkTreeStore *store;
GtkTreeIter child;
NodeData *nd;
GdkPixbuf *pixbuf;
NodeData *end;
GtkTreeIter empty;
if (!fd) return;
if (access_file(fd->path, R_OK | X_OK))
{
pixbuf = vd->pf->close;
}
else
{
pixbuf = vd->pf->deny;
}
nd = g_new0(NodeData, 1);
nd->fd = fd;
nd->version = fd->version;
nd->expanded = FALSE;
nd->last_update = time(NULL);
store = GTK_TREE_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(vd->view)));
gtk_tree_store_append(store, &child, parent);
gtk_tree_store_set(store, &child, DIR_COLUMN_POINTER, nd,
DIR_COLUMN_ICON, pixbuf,
DIR_COLUMN_NAME, nd->fd->name,
DIR_COLUMN_COLOR, FALSE, -1);
/* all nodes are created with an "empty" node, so that the expander is shown
* this is removed when the child is populated */
end = g_new0(NodeData, 1);
end->fd = file_data_new_simple("");
end->expanded = TRUE;
gtk_tree_store_append(store, &empty, &child);
gtk_tree_store_set(store, &empty, DIR_COLUMN_POINTER, end,
DIR_COLUMN_NAME, "empty", -1);
if (parent)
{
NodeData *pnd;
GtkTreePath *tpath;
gtk_tree_model_get(GTK_TREE_MODEL(store), parent, DIR_COLUMN_POINTER, &pnd, -1);
tpath = gtk_tree_model_get_path(GTK_TREE_MODEL(store), parent);
if (options->tree_descend_subdirs &&
gtk_tree_view_row_expanded(GTK_TREE_VIEW(vd->view), tpath) &&
!nd->expanded)
{
vdtree_populate_path_by_iter(vd, &child, FALSE, vd->dir_fd);
}
gtk_tree_path_free(tpath);
}
}
int main(){
srand(time(0));
get_numbers();
hits = 0;
misses = 0;
writes = 0;
access_file();
printf("hits: %d, misses: %d, writes: %d\n", hits, misses, writes);
//printf("num read: %d in %lf\nnum write: %d in %lf\n", bytes_read, read_time/CLOCKS_PER_SEC, bytes_write, write_time/CLOCKS_PER_SEC);
//double mbps_r = (bytes_read/read_time)*CLOCKS_PER_SEC/(1000000);
//double mbps_w = (bytes_write/write_time)*CLOCKS_PER_SEC/1000000;
//printf("Read MB/s: %lf\tWrite MB/s: %lf\n", mbps_r, mbps_w);
}
ERRORCODE HALOHelper::init(GRAPHIC_CREATE_STRUCT_PTR gcs)
{
SHORT i;
ERRORCODE error;
/* We need a file to read. */
StorageDevicePtr pSource;
ReadOnlyFile file;
if (gcs == NULL || (pSource = gcs->pSourceDevice) == NULL)
{
/* Go directly to disk. */
file.set_name(graphic->m_csFileName);
pSource = &file;
}
if ((error = read_halo_header(pSource,
(LPWORD)&graphic->record.x_size,
(LPWORD)&graphic->record.y_size,
(LPWORD)&graphic->record.x_resolution,
(LPWORD)&graphic->record.y_resolution)) == ERRORCODE_None)
{
graphic->record.storage = GRAPHIC_STORAGE_FILE;
/* Initialize the start of line variables. */
for (i = 0; i < 9; i++)
{
record.lines[i].line =
scale_number(graphic->record.y_size, i, 8);
record.lines[i].offset = 0L;
}
record.lines[0].offset = sizeof(HALO_HEADER);
CHAR buffer[_MAX_PATH];
strcpy(buffer, graphic->m_csFileName);
CHAR *extension = strrchr(buffer, '.')+1;
strcpy(extension, "PAL");
record.has_pal_file = (access_file(buffer) == 0);
}
return error;
}
static void real_collection_button_pressed(FileDialog *fd, gpointer data, gint append)
{
CollectionData *cd = data;
gboolean err = FALSE;
gchar *text = NULL;
if (!isname(fd->dest_path))
{
err = TRUE;
text = g_strdup_printf(_("No such file '%s'."), fd->dest_path);
}
if (!err && isdir(fd->dest_path))
{
err = TRUE;
text = g_strdup_printf(_("'%s' is a directory, not a collection file."), fd->dest_path);
}
if (!err && !access_file(fd->dest_path, R_OK))
{
err = TRUE;
text = g_strdup_printf(_("You do not have read permissions on the file '%s'."), fd->dest_path);
}
if (err) {
if (text)
{
file_util_warning_dialog(_("Can not open collection file"), text, GTK_STOCK_DIALOG_ERROR, NULL);
g_free(text);
}
return;
}
if (append)
{
collection_load(cd, fd->dest_path, TRUE);
collection_unref(cd);
}
else
{
collection_window_new(fd->dest_path);
}
file_dialog_sync_history(fd, TRUE);
file_dialog_close(fd);
}
static void editor_list_window_selection_changed_cb(GtkWidget *widget, gpointer data)
{
EditorListWindow *ewl = data;
GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(ewl->view));
GtkTreeIter iter;
if (gtk_tree_selection_get_selected(sel, NULL, &iter))
{
GtkTreeModel *store = gtk_tree_view_get_model(GTK_TREE_VIEW(ewl->view));
gchar *path;
gtk_tree_model_get(store, &iter,
DESKTOP_FILE_COLUMN_PATH, &path,
-1);
gtk_widget_set_sensitive(ewl->delete_button, access_file(path, W_OK));
gtk_widget_set_sensitive(ewl->edit_button, TRUE);
g_free(path);
}
}
gchar *cache_get_location(CacheType type, const gchar *source, gint include_name, mode_t *mode)
{
gchar *path = NULL;
gchar *base;
gchar *name = NULL;
const gchar *cache_rc;
const gchar *cache_local;
const gchar *cache_ext;
if (!source) return NULL;
cache_path_parts(type, &cache_rc, &cache_local, &cache_ext);
base = remove_level_from_path(source);
if (include_name)
{
name = g_strconcat(filename_from_path(source), cache_ext, NULL);
}
if (((type != CACHE_TYPE_METADATA && type != CACHE_TYPE_XMP_METADATA && options->thumbnails.cache_into_dirs) ||
((type == CACHE_TYPE_METADATA || type == CACHE_TYPE_XMP_METADATA) && options->metadata.enable_metadata_dirs)) &&
access_file(base, W_OK))
{
path = g_build_filename(base, cache_local, name, NULL);
if (mode) *mode = 0775;
}
if (!path)
{
path = g_build_filename(cache_rc, base, name, NULL);
if (mode) *mode = 0755;
}
g_free(base);
if (name) g_free(name);
return path;
}
gboolean editor_read_desktop_file(const gchar *path)
{
GKeyFile *key_file;
EditorDescription *editor;
gchar *extensions;
gchar *type;
const gchar *key = filename_from_path(path);
gchar **categories, **only_show_in, **not_show_in;
gchar *try_exec;
GtkTreeIter iter;
gboolean category_geeqie = FALSE;
if (g_hash_table_lookup(editors, key)) return FALSE; /* the file found earlier wins */
key_file = g_key_file_new();
if (!g_key_file_load_from_file(key_file, path, 0, NULL))
{
g_key_file_free(key_file);
return FALSE;
}
type = g_key_file_get_string(key_file, DESKTOP_GROUP, "Type", NULL);
if (!type || strcmp(type, "Application") != 0)
{
/* We only consider desktop entries of Application type */
g_key_file_free(key_file);
g_free(type);
return FALSE;
}
g_free(type);
editor = g_new0(EditorDescription, 1);
editor->key = g_strdup(key);
editor->file = g_strdup(path);
g_hash_table_insert(editors, editor->key, editor);
if (g_key_file_get_boolean(key_file, DESKTOP_GROUP, "Hidden", NULL)
|| g_key_file_get_boolean(key_file, DESKTOP_GROUP, "NoDisplay", NULL))
{
editor->hidden = TRUE;
}
categories = g_key_file_get_string_list(key_file, DESKTOP_GROUP, "Categories", NULL, NULL);
if (categories)
{
gboolean found = FALSE;
gint i;
for (i = 0; categories[i]; i++)
{
/* IMHO "Graphics" is exactly the category that we are interested in, so this does not have to be configurable */
if (strcmp(categories[i], "Graphics") == 0)
{
found = TRUE;
}
if (strcmp(categories[i], "X-Geeqie") == 0)
{
found = TRUE;
category_geeqie = TRUE;
break;
}
}
if (!found) editor->ignored = TRUE;
g_strfreev(categories);
}
else
{
editor->ignored = TRUE;
}
only_show_in = g_key_file_get_string_list(key_file, DESKTOP_GROUP, "OnlyShowIn", NULL, NULL);
if (only_show_in)
{
gboolean found = FALSE;
gint i;
for (i = 0; only_show_in[i]; i++)
if (strcmp(only_show_in[i], "X-Geeqie") == 0)
{
found = TRUE;
break;
}
if (!found) editor->ignored = TRUE;
g_strfreev(only_show_in);
}
not_show_in = g_key_file_get_string_list(key_file, DESKTOP_GROUP, "NotShowIn", NULL, NULL);
if (not_show_in)
{
gboolean found = FALSE;
gint i;
for (i = 0; not_show_in[i]; i++)
if (strcmp(not_show_in[i], "X-Geeqie") == 0)
{
found = TRUE;
break;
}
if (found) editor->ignored = TRUE;
g_strfreev(not_show_in);
}
try_exec = g_key_file_get_string(key_file, DESKTOP_GROUP, "TryExec", NULL);
if (try_exec && !editor->hidden && !editor->ignored)
{
gchar *try_exec_res = g_find_program_in_path(try_exec);
if (!try_exec_res) editor->hidden = TRUE;
g_free(try_exec_res);
g_free(try_exec);
}
if (editor->ignored)
{
/* ignored editors will be deleted, no need to parse the rest */
g_key_file_free(key_file);
return TRUE;
}
editor->name = g_key_file_get_locale_string(key_file, DESKTOP_GROUP, "Name", NULL, NULL);
editor->icon = g_key_file_get_string(key_file, DESKTOP_GROUP, "Icon", NULL);
/* Icon key can be either a full path (absolute with file name extension) or an icon name (without extension) */
if (editor->icon && !g_path_is_absolute(editor->icon))
{
gchar *ext = strrchr(editor->icon, '.');
if (ext && strlen(ext) == 4 &&
(!strcmp(ext, ".png") || !strcmp(ext, ".xpm") || !strcmp(ext, ".svg")))
{
log_printf(_("Desktop file '%s' should not include extension in Icon key: '%s'\n"),
editor->file, editor->icon);
// drop extension
*ext = '\0';
}
}
if (editor->icon && !register_theme_icon_as_stock(editor->key, editor->icon))
{
g_free(editor->icon);
editor->icon = NULL;
}
editor->exec = g_key_file_get_string(key_file, DESKTOP_GROUP, "Exec", NULL);
editor->menu_path = g_key_file_get_string(key_file, DESKTOP_GROUP, "X-Geeqie-Menu-Path", NULL);
if (!editor->menu_path) editor->menu_path = g_strdup("PluginsMenu");
editor->hotkey = g_key_file_get_string(key_file, DESKTOP_GROUP, "X-Geeqie-Hotkey", NULL);
editor->comment = g_key_file_get_string(key_file, DESKTOP_GROUP, "Comment", NULL);
extensions = g_key_file_get_string(key_file, DESKTOP_GROUP, "X-Geeqie-File-Extensions", NULL);
if (extensions)
editor->ext_list = filter_to_list(extensions);
else
{
gchar **mime_types = g_key_file_get_string_list(key_file, DESKTOP_GROUP, "MimeType", NULL, NULL);
if (mime_types)
{
editor->ext_list = editor_mime_types_to_extensions(mime_types);
g_strfreev(mime_types);
if (!editor->ext_list) editor->hidden = TRUE;
}
}
if (g_key_file_get_boolean(key_file, DESKTOP_GROUP, "X-Geeqie-Keep-Fullscreen", NULL)) editor->flags |= EDITOR_KEEP_FS;
if (g_key_file_get_boolean(key_file, DESKTOP_GROUP, "X-Geeqie-Verbose", NULL)) editor->flags |= EDITOR_VERBOSE;
if (g_key_file_get_boolean(key_file, DESKTOP_GROUP, "X-Geeqie-Verbose-Multi", NULL)) editor->flags |= EDITOR_VERBOSE_MULTI;
if (g_key_file_get_boolean(key_file, DESKTOP_GROUP, "X-Geeqie-Filter", NULL)) editor->flags |= EDITOR_DEST;
if (g_key_file_get_boolean(key_file, DESKTOP_GROUP, "Terminal", NULL)) editor->flags |= EDITOR_TERMINAL;
editor->flags |= editor_command_parse(editor, NULL, FALSE, NULL);
if ((editor->flags & EDITOR_NO_PARAM) && !category_geeqie) editor->hidden = TRUE;
g_key_file_free(key_file);
if (editor->ignored) return TRUE;
gtk_list_store_append(desktop_file_list, &iter);
gtk_list_store_set(desktop_file_list, &iter,
DESKTOP_FILE_COLUMN_KEY, key,
DESKTOP_FILE_COLUMN_NAME, editor->name,
DESKTOP_FILE_COLUMN_HIDDEN, editor->hidden ? _("yes") : _("no"),
DESKTOP_FILE_COLUMN_WRITABLE, access_file(path, W_OK),
DESKTOP_FILE_COLUMN_PATH, path, -1);
return TRUE;
}
/**
This internal helper function does all the real work. By using two
functions, the internal function can return on various places in
the code, and the caller can take care of various cleanup work.
cmd: the command name ('grep')
really_load: whether to actually parse it as a function, or just check it it exists
reload: whether to reload it if it's already loaded
path_list: the set of paths to check
Result: if really_load is true, returns whether the function was loaded. Otherwise returns whether the function existed.
*/
bool autoload_t::locate_file_and_maybe_load_it(const wcstring &cmd, bool really_load, bool reload, const wcstring_list_t &path_list)
{
/* Note that we are NOT locked in this function! */
bool reloaded = 0;
/* Try using a cached function. If we really want the function to be loaded, require that it be really loaded. If we're not reloading, allow stale functions. */
{
bool allow_stale_functions = ! reload;
/* Take a lock */
scoped_lock locker(lock);
/* Get the function */
autoload_function_t * func = this->get_node(cmd);
/* Determine if we can use this cached function */
bool use_cached;
if (! func)
{
/* Can't use a function that doesn't exist */
use_cached = false;
}
else if (really_load && ! func->is_placeholder && ! func->is_loaded)
{
/* Can't use an unloaded function */
use_cached = false;
}
else if (! allow_stale_functions && is_stale(func))
{
/* Can't use a stale function */
use_cached = false;
}
else
{
/* I guess we can use it */
use_cached = true;
}
/* If we can use this function, return whether we were able to access it */
if (use_cached)
{
return func->is_internalized || func->access.accessible;
}
}
/* The source of the script will end up here */
wcstring script_source;
bool has_script_source = false;
/* Whether we found an accessible file */
bool found_file = false;
/* Look for built-in scripts via a binary search */
const builtin_script_t *matching_builtin_script = NULL;
if (builtin_script_count > 0)
{
const builtin_script_t test_script = {cmd.c_str(), NULL};
const builtin_script_t *array_end = builtin_scripts + builtin_script_count;
const builtin_script_t *found = std::lower_bound(builtin_scripts, array_end, test_script, script_name_precedes_script_name);
if (found != array_end && ! wcscmp(found->name, test_script.name))
{
/* We found it */
matching_builtin_script = found;
}
}
if (matching_builtin_script)
{
has_script_source = true;
script_source = str2wcstring(matching_builtin_script->def);
/* Make a node representing this function */
scoped_lock locker(lock);
autoload_function_t *func = this->get_autoloaded_function_with_creation(cmd, really_load);
/* This function is internalized */
func->is_internalized = true;
/* It's a fiction to say the script is loaded at this point, but we're definitely going to load it down below. */
if (really_load) func->is_loaded = true;
}
if (! has_script_source)
{
/* Iterate over path searching for suitable completion files */
for (size_t i=0; i<path_list.size(); i++)
{
wcstring next = path_list.at(i);
wcstring path = next + L"/" + cmd + L".fish";
const file_access_attempt_t access = access_file(path, R_OK);
if (access.accessible)
{
/* Found it! */
found_file = true;
/* Now we're actually going to take the lock. */
scoped_lock locker(lock);
autoload_function_t *func = this->get_node(cmd);
/* Generate the source if we need to load it */
bool need_to_load_function = really_load && (func == NULL || func->access.mod_time != access.mod_time || ! func->is_loaded);
if (need_to_load_function)
{
/* Generate the script source */
wcstring esc = escape_string(path, 1);
script_source = L". " + esc;
has_script_source = true;
/* Remove any loaded command because we are going to reload it. Note that this will deadlock if command_removed calls back into us. */
if (func && func->is_loaded)
{
command_removed(cmd);
func->is_placeholder = false;
}
/* Mark that we're reloading it */
reloaded = true;
}
/* Create the function if we haven't yet. This does not load it. Do not trigger eviction unless we are actually loading, because we don't want to evict off of the main thread. */
if (! func)
{
func = get_autoloaded_function_with_creation(cmd, really_load);
}
/* It's a fiction to say the script is loaded at this point, but we're definitely going to load it down below. */
if (need_to_load_function) func->is_loaded = true;
/* Unconditionally record our access time */
func->access = access;
break;
}
}
/*
If no file or builtin script was found we insert a placeholder function.
Later we only research if the current time is at least five seconds later.
This way, the files won't be searched over and over again.
*/
if (! found_file && ! has_script_source)
{
scoped_lock locker(lock);
/* Generate a placeholder */
autoload_function_t *func = this->get_node(cmd);
if (! func)
{
func = new autoload_function_t(cmd);
func->is_placeholder = true;
if (really_load)
{
this->add_node(func);
}
else
{
this->add_node_without_eviction(func);
}
}
func->access.last_checked = time(NULL);
}
}
/* If we have a script, either built-in or a file source, then run it */
if (really_load && has_script_source)
{
if (exec_subshell(script_source, false /* do not apply exit status */) == -1)
{
/* Do nothing on failure */
}
}
if (really_load)
{
return reloaded;
}
else
{
return found_file || has_script_source;
}
}
static gboolean vdlist_populate(ViewDir *vd, gboolean clear)
{
GtkListStore *store;
GList *work;
GtkTreeIter iter;
gboolean valid;
gchar *filepath;
GList *old_list;
gboolean ret;
FileData *fd;
SortType sort_type = SORT_NAME;
gboolean sort_ascend = TRUE;
old_list = VDLIST(vd)->list;
ret = filelist_read(vd->dir_fd, NULL, &VDLIST(vd)->list);
VDLIST(vd)->list = filelist_sort(VDLIST(vd)->list, sort_type, sort_ascend);
/* add . and .. */
if (options->file_filter.show_parent_directory && strcmp(vd->dir_fd->path, G_DIR_SEPARATOR_S) != 0)
{
filepath = g_build_filename(vd->dir_fd->path, "..", NULL);
fd = file_data_new_dir(filepath);
VDLIST(vd)->list = g_list_prepend(VDLIST(vd)->list, fd);
g_free(filepath);
}
if (options->file_filter.show_dot_directory)
{
filepath = g_build_filename(vd->dir_fd->path, ".", NULL);
fd = file_data_new_dir(filepath);
VDLIST(vd)->list = g_list_prepend(VDLIST(vd)->list, fd);
g_free(filepath);
}
store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(vd->view)));
if (clear) gtk_list_store_clear(store);
valid = gtk_tree_model_iter_children(GTK_TREE_MODEL(store), &iter, NULL);
work = VDLIST(vd)->list;
while (work)
{
gint match;
GdkPixbuf *pixbuf;
const gchar *date = "";
gboolean done = FALSE;
fd = work->data;
if (access_file(fd->path, R_OK | X_OK) && fd->name)
{
if (fd->name[0] == '.' && fd->name[1] == '\0')
{
pixbuf = vd->pf->open;
}
else if (fd->name[0] == '.' && fd->name[1] == '.' && fd->name[2] == '\0')
{
pixbuf = vd->pf->parent;
}
else
{
pixbuf = vd->pf->close;
if (vd->layout && vd->layout->options.show_directory_date)
date = text_from_time(fd->date);
}
}
else
{
pixbuf = vd->pf->deny;
}
while (!done)
{
FileData *old_fd = NULL;
if (valid)
{
gtk_tree_model_get(GTK_TREE_MODEL(store), &iter,
DIR_COLUMN_POINTER, &old_fd,
-1);
if (fd == old_fd)
{
match = 0;
}
else
{
match = filelist_sort_compare_filedata_full(fd, old_fd, sort_type, sort_ascend);
if (match == 0) g_warning("multiple fd for the same path");
}
}
else
{
match = -1;
}
if (match < 0)
{
GtkTreeIter new;
if (valid)
{
gtk_list_store_insert_before(store, &new, &iter);
}
else
{
gtk_list_store_append(store, &new);
}
gtk_list_store_set(store, &new,
DIR_COLUMN_POINTER, fd,
DIR_COLUMN_ICON, pixbuf,
DIR_COLUMN_NAME, fd->name,
DIR_COLUMN_DATE, date,
-1);
done = TRUE;
}
else if (match > 0)
static int AccessFile (
char* path,
char* pathbuf,
int len_pathbuf,
char** pathret)
{
unsigned long drives;
int i, len;
char* drive;
char buf[MAX_PATH];
char* bufp;
/* just try the "raw" name first and see if it works */
if (access_file (path, pathbuf, len_pathbuf, pathret))
return 1;
#if defined(WIN32) && defined(__MINGW32__)
/* don't try others */
return 0;
#endif
/* try the places set in the environment */
drive = getenv ("_XBASEDRIVE");
#ifdef __UNIXOS2__
if (!drive)
drive = getenv ("X11ROOT");
#endif
if (!drive)
drive = "C:";
len = strlen (drive) + strlen (path);
bufp = XtStackAlloc (len + 1, buf);
strcpy (bufp, drive);
strcat (bufp, path);
if (access_file (bufp, pathbuf, len_pathbuf, pathret)) {
XtStackFree (bufp, buf);
return 1;
}
#ifndef __UNIXOS2__
/* one last place to look */
drive = getenv ("HOMEDRIVE");
if (drive) {
len = strlen (drive) + strlen (path);
bufp = XtStackAlloc (len + 1, buf);
strcpy (bufp, drive);
strcat (bufp, path);
if (access_file (bufp, pathbuf, len_pathbuf, pathret)) {
XtStackFree (bufp, buf);
return 1;
}
}
/* does OS/2 (with or with gcc-emx) have getdrives()? */
/* tried everywhere else, go fishing */
drives = _getdrives ();
#define C_DRIVE ('C' - 'A')
#define Z_DRIVE ('Z' - 'A')
for (i = C_DRIVE; i <= Z_DRIVE; i++) { /* don't check on A: or B: */
if ((1 << i) & drives) {
len = 2 + strlen (path);
bufp = XtStackAlloc (len + 1, buf);
*bufp = 'A' + i;
*(bufp + 1) = ':';
*(bufp + 2) = '\0';
strcat (bufp, path);
if (access_file (bufp, pathbuf, len_pathbuf, pathret)) {
XtStackFree (bufp, buf);
return 1;
}
}
}
#endif
return 0;
}
