---

dutree.cpp File Reference

#include <gtk--/main.h>
#include <gtk--/window.h>
#include <gtk--/button.h>
#include <gtk--/box.h>
#include <gtk--/drawingarea.h>
#include <gtk--/style.h>
#include <gtk--/label.h>
#include <gtk--/widget.h>
#include <sigc++-1.0/sigc++/slot.h>
#include <sigc++-1.0/sigc++/signal_system.h>
#include "errno.h"
#include <sys/stat.h>
#include "save-cwd.h"
#include <unistd.h>
#include "savedir.h"
#include "config.h"
#include <fcntl.h>
#include <sstream>
#include <vector>
#include <cmath>
#include <cstdlib>
#include "context.h"
#include "drawerdep.h"
#include "drawervisitordep.h"
#include "colorpickerdep.h"
#include "dutree.h"
#include "rotatedrawer.h"
#include <stdio.h>
#include <sys/types.h>
#include "pathmax.h"

Include dependency graph for dutree.cpp:

Compounds
struct	exclude_st
class	RotateDrawerCmd
class	RotateColorCmd
Defines
#define	NAME_SIZE_DEFAULT   512
#define	FNM_PATHNAME   (1 << 0)
#define	FNM_NOESCAPE   (1 << 1)
#define	FNM_PERIOD   (1 << 2)
#define	FNM_FILE_NAME   FNM_PATHNAME
#define	FNM_LEADING_DIR   (1 << 3)
#define	FNM_CASEFOLD   (1 << 4)
#define	FNM_NOMATCH   1
#define	FOLD(c)
#define	S_ISLNK(s)   0
Functions
std::ostream &	operator<< (std::ostream &output, Exception &err)
	Writes an exception to an ostream.
void	destroy_handler ()
char *	getcwd ()
char *	xgetcwd ()
void	free_cwd (struct saved_cwd *cwd)
void xalloc_fail_func	PARAMS ((void))=0
void	xalloc_die (void)
char *	savedir (const char *dir, off_t name_size)
int	restore_cwd (const struct saved_cwd *cwd, const char *dest, const char *from)
int	save_cwd (struct saved_cwd *cwd)
int	fnmatch (const char *pattern, const char *string, int flags)
exclude_st *	new_exclude (void)
int	excluded_filename (struct exclude_st const *ex, char const *f, int options)
int	main (int argc, char *argv[])
Variables
int	errno

---

Define Documentation

#define NAME_SIZE_DEFAULT   512

#define FNM_PATHNAME   (1 << 0)

#define FNM_NOESCAPE   (1 << 1)

#define FNM_PERIOD   (1 << 2)

#define FNM_FILE_NAME   FNM_PATHNAME

#define FNM_LEADING_DIR   (1 << 3)

#define FNM_CASEFOLD   (1 << 4)

#define FNM_NOMATCH   1

#define FOLD (  c    )

Value: ((flags & FNM_CASEFOLD) && ISUPPER ((unsigned char) (c)) \ ? tolower ((unsigned char) (c)) \ : (c))

#define S_ISLNK (  s    )     0

---

Function Documentation

std::ostream& operator<< (  std::ostream &    output, Exception &    err )

Writes an exception to an ostream. Note: a wrapper on Exception::write so normal syntax can be used { err.write(output); return output; }

void destroy_handler (    )

{ Gtk::Main::quit(); }

char* getcwd (    )

char* xgetcwd (    )

{ char *ret; unsigned path_max; char buf[1024]; errno = 0; ret = getcwd (buf, sizeof (buf)); if (ret != NULL) return xstrdup (buf); if (errno != ERANGE) return NULL; path_max = (unsigned) PATH_MAX; path_max += 2; /* The getcwd docs say to do this. */ for (;;) { char *cwd = (char *) xmalloc (path_max); errno = 0; ret = getcwd (cwd, path_max); if (ret != NULL) return ret; if (errno != ERANGE) { int save_errno = errno; free (cwd); errno = save_errno; return NULL; } free (cwd); path_max += path_max / 16; path_max += 32; } }

void free_cwd (  struct saved_cwd *    cwd )

{ if (cwd->desc >= 0) close (cwd->desc); if (cwd->name) free (cwd->name); }

void xalloc_fail_func PARAMS (  (void)    )  [pure virtual]

void xalloc_die (  void    )

{ if (xalloc_fail_func) (*xalloc_fail_func) (); //error (xalloc_exit_failure, 0, "%s", _(xalloc_msg_memory_exhausted)); /* The `noreturn' cannot be given to error, since it may return if its first argument is 0. To help compilers understand the xalloc_die does terminate, call exit. */ exit (EXIT_FAILURE); }

char* savedir (  const char *    dir, off_t    name_size )

{ DIR *dirp; struct dirent *dp; char *name_space; size_t allocated = name_size; /* Overflow is checked indirectly below. */ size_t used = 0; int save_errno; dirp = opendir (dir); if (dirp == NULL) return NULL; /* Use the default if the size is not known. Be sure "allocated" is at least `1' so there's room for the final NUL byte. Do not simply test name_size <= 0, because the initialization of "allocated" might have overflowed. */ if (name_size < 0 || allocated == 0) allocated = NAME_SIZE_DEFAULT; name_space = static_cast<char *>(xmalloc (allocated)); errno = 0; while ((dp = readdir (dirp)) != NULL) { /* Skip "", ".", and "..". "" is returned by at least one buggy implementation: Solaris 2.4 readdir on NFS filesystems. */ char const *entry = dp->d_name; if (entry[entry[0] != '.' ? 0 : entry[1] != '.' ? 1 : 2] != '\0') { size_t entry_size = strlen (entry) + 1; if (used + entry_size < used) xalloc_die (); if (allocated <= used + entry_size) { do { if (2 * allocated < allocated) xalloc_die (); allocated *= 2; } while (allocated <= used + entry_size); name_space = static_cast<char *>(xrealloc (name_space, allocated)); } memcpy (name_space + used, entry, entry_size); used += entry_size; } } name_space[used] = '\0'; save_errno = errno; if (CLOSEDIR (dirp) != 0) save_errno = errno; if (save_errno != 0) { free (name_space); errno = save_errno; return NULL; } return name_space; }

int restore_cwd (  const struct saved_cwd *    cwd, const char *    dest, const char *    from )

{ int fail = 0; if (cwd->desc >= 0) { if (fchdir (cwd->desc)) { /*error (0, errno, "cannot return to %s%s%s", (dest ? dest : "saved working directory"), (from ? " from " : ""), (from ? from : ""));*/ fail = 1; } } else if (chdir (cwd->name) < 0) { // error (0, errno, "%s", cwd->name); fail = 1; } return fail; }

int save_cwd (  struct saved_cwd *    cwd )

{ static int have_working_fchdir = 1; cwd->desc = -1; cwd->name = NULL; if (have_working_fchdir) { #if HAVE_FCHDIR cwd->desc = open (".", O_RDONLY | O_DIRECTORY); if (cwd->desc < 0) { //error (0, errno, "cannot open current directory"); return 1; } # if __sun__ || sun /* On SunOS 4, fchdir returns EINVAL if accounting is enabled, so we have to fall back to chdir. */ if (fchdir (cwd->desc)) { if (errno == EINVAL) { close (cwd->desc); cwd->desc = -1; have_working_fchdir = 0; } else { error (0, errno, "current directory"); close (cwd->desc); cwd->desc = -1; return 1; } } # endif /* __sun__ || sun */ #else # define fchdir(x) (abort (), 0) have_working_fchdir = 0; #endif } if (!have_working_fchdir) { cwd->name = xgetcwd (); if (cwd->name == NULL) { // error (0, errno, "cannot get current directory"); return 1; } } return 0; }

int fnmatch (  const char *    pattern, const char *    string, int    flags )

{ register const char *p = pattern, *n = string; register char c; /* Note that this evaluates C many times. */ #define FOLD(c) ((flags & FNM_CASEFOLD) && ISUPPER ((unsigned char) (c)) \ ? tolower ((unsigned char) (c)) \ : (c)) while ((c = *p++) != '\0') { c = FOLD (c); switch (c) { case '?': if (*n == '\0') return FNM_NOMATCH; else if ((flags & FNM_FILE_NAME) && *n == '/') return FNM_NOMATCH; else if ((flags & FNM_PERIOD) && *n == '.' && (n == string || ((flags & FNM_FILE_NAME) && n[-1] == '/'))) return FNM_NOMATCH; break; case '\\': if (!(flags & FNM_NOESCAPE)) { c = *p++; if (c == '\0') /* Trailing \ loses. */ return FNM_NOMATCH; c = FOLD (c); } if (FOLD (*n) != c) return FNM_NOMATCH; break; case '*': if ((flags & FNM_PERIOD) && *n == '.' && (n == string || ((flags & FNM_FILE_NAME) && n[-1] == '/'))) return FNM_NOMATCH; for (c = *p++; c == '?' || c == '*'; c = *p++) { if (c == '?') { /* A ? needs to match one character. */ if (*n == '\0' || (*n == '/' && (flags & FNM_FILE_NAME))) /* There isn't another character; no match. */ return FNM_NOMATCH; else /* One character of the string is consumed in matching this ? wildcard, so *??? won't match if there are less than three characters. */ ++n; } } if (c == '\0') { if ((flags & (FNM_FILE_NAME | FNM_LEADING_DIR)) == FNM_FILE_NAME) for (; *n != '\0'; n++) if (*n == '/') return FNM_NOMATCH; return 0; } { char c1 = (!(flags & FNM_NOESCAPE) && c == '\\') ? *p : c; c1 = FOLD (c1); for (--p; *n != '\0'; ++n) if ((c == '[' || FOLD (*n) == c1) && fnmatch (p, n, flags & ~FNM_PERIOD) == 0) return 0; else if (*n == '/' && (flags & FNM_FILE_NAME)) break; return FNM_NOMATCH; } case '[': { /* Nonzero if the sense of the character class is inverted. */ register int noot; if (*n == '\0') return FNM_NOMATCH; if ((flags & FNM_PERIOD) && *n == '.' && (n == string || ((flags & FNM_FILE_NAME) && n[-1] == '/'))) return FNM_NOMATCH; noot = (*p == '!' || *p == '^'); if (noot) ++p; c = *p++; for (;;) { register char cstart = c, cend = c; if (!(flags & FNM_NOESCAPE) && c == '\\') { if (*p == '\0') return FNM_NOMATCH; cstart = cend = *p++; } cstart = cend = FOLD (cstart); if (c == '\0') /* [ (unterminated) loses. */ return FNM_NOMATCH; c = *p++; c = FOLD (c); if ((flags & FNM_FILE_NAME) && c == '/') /* [/] can never match. */ return FNM_NOMATCH; if (c == '-' && *p != ']') { cend = *p++; if (!(flags & FNM_NOESCAPE) && cend == '\\') cend = *p++; if (cend == '\0') return FNM_NOMATCH; cend = FOLD (cend); c = *p++; } if (FOLD (*n) >= cstart && FOLD (*n) <= cend) goto matched; if (c == ']') break; } if (!noot) return FNM_NOMATCH; break; matched:; /* Skip the rest of the [...] that already matched. */ while (c != ']') { if (c == '\0') /* [... (unterminated) loses. */ return FNM_NOMATCH; c = *p++; if (!(flags & FNM_NOESCAPE) && c == '\\') { if (*p == '\0') return FNM_NOMATCH; /* XXX 1003.2d11 is unclear if this is right. */ ++p; } } if (noot) return FNM_NOMATCH; } break; default: if (c != FOLD (*n)) return FNM_NOMATCH; } ++n; } if (*n == '\0') return 0; if ((flags & FNM_LEADING_DIR) && *n == '/') /* The FNM_LEADING_DIR flag says that "foo*" matches "foobar/frobozz". */ return 0; return FNM_NOMATCH; #undef FOLD }

struct exclude_st* new_exclude (  void    )

{ struct exclude_st *ex = (struct exclude_st *) xmalloc (sizeof (struct exclude_st)); ex->exclude_count = 0; ex->exclude_alloc = 64; ex->exclude = (char const **) xmalloc (ex->exclude_alloc * sizeof (char *)); return ex; }

int excluded_filename (  struct exclude_st const *    ex, char const *    f, int    options )

{ char const * const *exclude = ex->exclude; int exclude_count = ex->exclude_count; int i; for (i = 0; i < exclude_count; i++) if (fnmatch (exclude[i], f, options) == 0) return 1; return 0; }

int main (  int    argc, char *    argv[] )

{ Context cx1("main()"); try { // all GTK applications must have a gtk_main(). Control ends here // and waits for an event to occur (like a key press or mouse event). Gtk::Main kit(argc, argv); MainWindow dutree; { Context cx2("Update thread"); kit.run(); } } catch (Exception &err) { cout << err; } catch (ContException &cxe) { cxe.print(); } return 0; }

---

Variable Documentation

int errno

---