Bump year
[yaz-moved-to-github.git] / src / file_glob.c
1 /* This file is part of the YAZ toolkit.
2  * Copyright (C) 1995-2013 Index Data
3  * See the file LICENSE for details.
4  */
5
6 /** \file
7     \brief File globbing (ala POSIX glob, but simpler)
8 */
9 #if HAVE_CONFIG_H
10 #include <config.h>
11 #endif
12
13 #include <sys/types.h>
14 #include <sys/stat.h>
15 #include <stdio.h>
16 #include <string.h>
17 #include <stdlib.h>
18 #include <assert.h>
19 #include <yaz/wrbuf.h>
20 #include <yaz/tpath.h>
21 #include <yaz/log.h>
22 #include <yaz/dirent.h>
23 #include <yaz/nmem.h>
24 #include <yaz/file_glob.h>
25 #include <yaz/match_glob.h>
26
27 struct res_entry {
28     struct res_entry *next;
29     char *file;
30 };
31
32 struct glob_res {
33     NMEM nmem;
34     size_t number_of_entries;
35     struct res_entry **last_entry;
36     struct res_entry *entries;
37 };
38
39 static void glob_r(yaz_glob_res_t res, const char *pattern, size_t off,
40                    char *prefix)
41 {
42     size_t prefix_len = strlen(prefix);
43     int is_pattern = 0;
44     size_t i = off;
45     while (pattern[i] && !strchr("/\\", pattern[i]))
46     {
47         if (strchr("?*", pattern[i]))
48             is_pattern = 1;
49         i++;
50     }
51
52     if (!is_pattern && pattern[i]) /* no pattern and directory part */
53     {
54         i++; /* skip dir sep */
55         memcpy(prefix + prefix_len, pattern + off, i - off);
56         prefix[prefix_len + i - off] = '\0';
57         glob_r(res, pattern, i, prefix);
58         prefix[prefix_len] = '\0';
59     }
60     else
61     {
62         DIR * dir = opendir(*prefix ? prefix : "." );
63
64         if (dir)
65         {
66             struct dirent *ent;
67
68             while ((ent = readdir(dir)))
69             {
70                 int r;
71                 memcpy(prefix + prefix_len, pattern + off, i - off);
72                 prefix[prefix_len + i - off] = '\0';
73                 r = yaz_match_glob(prefix + prefix_len, ent->d_name);
74                 prefix[prefix_len] = '\0';
75
76                 if (r)
77                 {
78                     strcpy(prefix + prefix_len, ent->d_name);
79                     if (pattern[i])
80                     {
81                         glob_r(res, pattern, i, prefix);
82                     }
83                     else
84                     {
85                         struct res_entry *ent =
86                             nmem_malloc(res->nmem, sizeof(*ent));
87                         ent->file = nmem_strdup(res->nmem, prefix);
88                         ent->next = 0;
89                         *res->last_entry = ent;
90                         res->last_entry = &ent->next;
91                         res->number_of_entries++;
92                     }
93                     prefix[prefix_len] = '\0';
94                 }
95             }
96             closedir(dir);
97         }
98     }
99 }
100
101 static int cmp_entry(const void *a, const void *b)
102 {
103     struct res_entry *ent_a = *(struct res_entry **) a;
104     struct res_entry *ent_b = *(struct res_entry **) b;
105     return strcmp(ent_a->file, ent_b->file);
106 }
107
108 static void sort_them(yaz_glob_res_t res)
109 {
110     size_t i;
111     struct res_entry **ent_p;
112     struct res_entry **ent = nmem_malloc(res->nmem, sizeof(*ent) * res->number_of_entries);
113     struct res_entry *ent_i = res->entries;
114     for (i = 0; i < res->number_of_entries; i++)
115     {
116         ent[i] = ent_i;
117         ent_i = ent_i->next;
118     }
119     qsort(ent, res->number_of_entries, sizeof(*ent), cmp_entry);
120     ent_p = &res->entries;
121     for (i = 0; i < res->number_of_entries; i++)
122     {
123         *ent_p = ent[i];
124         ent_p = &ent[i]->next;
125     }
126     *ent_p = 0;
127 }
128
129 int yaz_file_glob(const char *pattern, yaz_glob_res_t *res)
130 {
131     char prefix[FILENAME_MAX+1];
132     NMEM nmem = nmem_create();
133
134     *prefix = '\0';
135     *res = nmem_malloc(nmem, sizeof(**res));
136     (*res)->number_of_entries = 0;
137     (*res)->nmem = nmem;
138     (*res)->entries = 0;
139     (*res)->last_entry = &(*res)->entries;
140     glob_r(*res, pattern, 0, prefix);
141     sort_them(*res);
142     return 0;
143 }
144
145 void yaz_file_globfree(yaz_glob_res_t *res)
146 {
147     if (*res)
148     {
149         /* must free entries as well */
150         nmem_destroy((*res)->nmem);
151         *res = 0;
152     }
153 }
154
155 const char *yaz_file_glob_get_file(yaz_glob_res_t res, size_t idx)
156 {
157     struct res_entry *ent = res->entries;
158     while (idx && ent)
159     {
160         ent = ent->next;
161         idx--;
162     }
163     if (!ent)
164         return 0;
165     return ent->file;
166 }
167
168 size_t yaz_file_glob_get_num(yaz_glob_res_t res)
169 {
170     return res->number_of_entries;
171 }
172
173 /*
174  * Local variables:
175  * c-basic-offset: 4
176  * c-file-style: "Stroustrup"
177  * indent-tabs-mode: nil
178  * End:
179  * vim: shiftwidth=4 tabstop=8 expandtab
180  */
181