ls.c

Go to the documentation of this file.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <dirent.h>
#include <unistd.h>

#include <grass/gis.h>
#include <grass/config.h>
#include <grass/glocale.h>

#ifdef HAVE_SYS_IOCTL_H
#  include <sys/ioctl.h>
#endif

typedef int ls_filter_func(const char * /*filename */ , void * /*closure */ );

static ls_filter_func *ls_filter;
static void *ls_closure;

static ls_filter_func *ls_ex_filter;
static void *ls_ex_closure;

static int cmp_names(const void *aa, const void *bb)
{
    char *const *a = (char *const *)aa;
    char *const *b = (char *const *)bb;

    return strcmp(*a, *b);
}

void G_set_ls_filter(ls_filter_func *func, void *closure)
{
    ls_filter = func;
    ls_closure = closure;
}

void G_set_ls_exclude_filter(ls_filter_func *func, void *closure)
{
    ls_ex_filter = func;
    ls_ex_closure = closure;
}

char **G__ls(const char *dir, int *num_files)
{
    struct dirent *dp;
    DIR *dfd;
    char **dir_listing = NULL;
    int n = 0;

    if ((dfd = opendir(dir)) == NULL)
        G_fatal_error(_("Unable to open directory %s"), dir);

    while ((dp = readdir(dfd)) != NULL) {
        if (dp->d_name[0] == '.')       /* Don't list hidden files */
            continue;
        if (ls_filter && !(*ls_filter)(dp->d_name, ls_closure))
            continue;
        if (ls_ex_filter && (*ls_ex_filter)(dp->d_name, ls_ex_closure))
            continue;
        dir_listing = (char **)G_realloc(dir_listing, (1 + n) * sizeof(char *));
        dir_listing[n] = G_store(dp->d_name);
        n++;
    }

    /* Sort list of filenames alphabetically */
    qsort(dir_listing, n, sizeof(char *), cmp_names);

    *num_files = n;
    return dir_listing;
}

void G_ls(const char *dir, FILE * stream)
{
    int i, n;
    char **dir_listing = G__ls(dir, &n);

    G_ls_format(dir_listing, n, 0, stream);

    for (i = 0; i < n; i++)
        G_free(dir_listing[i]);

    G_free(dir_listing);

    return;
}

void G_ls_format(char **list, int num_items, int perline, FILE * stream)
{
    int i;

    int field_width, column_height;
    int screen_width = 80;      /* Default width of 80 columns */

    if (num_items < 1)
        return;                 /* Nothing to print */

#ifdef TIOCGWINSZ
    /* Determine screen_width if possible */
    {
        struct winsize size;

        if (ioctl(fileno(stream), TIOCGWINSZ, (char *)&size) == 0)
            screen_width = size.ws_col;
    }
#endif

    if (perline == 0) {
        int max_len = 0;

        for (i = 0; i < num_items; i++) {
            /* Find maximum filename length */
            if (strlen(list[i]) > max_len)
                max_len = strlen(list[i]);
        }
        /* Auto-fit the number of items that will
         * fit per line (+1 because of space after item) */
        perline = screen_width / (max_len + 1);
        if (perline < 1)
            perline = 1;
    }

    /* Field width to accomodate longest filename */
    field_width = screen_width / perline;
    /* Longest column height (i.e. num_items <= perline * column_height) */
    column_height = (num_items / perline) + ((num_items % perline) > 0);

    {
        const int max
            = num_items + column_height - (num_items % column_height);
        char **next;

        for (i = 1, next = list; i <= num_items; i++) {
            char **cur = next;

            next += column_height;
            if (next >= list + num_items) {
                /* the next item has to be on the other line */
                next -= (max - 1 - (next < list + max ? column_height : 0));
                fprintf(stream, "%s\n", *cur);
            }
            else {
                fprintf(stream, "%-*s", field_width, *cur);
            }
        }
    }

    return;
}