wrap and sort CLEANFILES
[alioth/cvs.git] / src / ignore.c
1 /* This program is free software; you can redistribute it and/or modify
2    it under the terms of the GNU General Public License as published by
3    the Free Software Foundation; either version 2, or (at your option)
4    any later version.
5
6    This program is distributed in the hope that it will be useful,
7    but WITHOUT ANY WARRANTY; without even the implied warranty of
8    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
9    GNU General Public License for more details.  */
10
11 /*
12  * .cvsignore file support contributed by David G. Grubbs <dgg@odi.com>
13  */
14
15 #include "cvs.h"
16 #include "getline.h"
17 #include "lstat.h"
18
19 /*
20  * Ignore file section.
21  * 
22  *      "!" may be included any time to reset the list (i.e. ignore nothing);
23  *      "*" may be specified to ignore everything.  It stays as the first
24  *          element forever, unless a "!" clears it out.
25  */
26
27 static char **ign_list;                 /* List of files to ignore in update
28                                          * and import */
29 static char **s_ign_list = NULL;
30 static int ign_count;                   /* Number of active entries */
31 static int s_ign_count = 0;
32 static int ign_size;                    /* This many slots available (plus
33                                          * one for a NULL) */
34 static int ign_hold = -1;               /* Index where first "temporary" item
35                                          * is held */
36
37 const char *ign_default = ". .. core RCSLOG tags TAGS RCS SCCS .make.state\
38  .nse_depinfo #* .#* cvslog.* ,* CVS CVS.adm .del-* *.a *.olb *.o *.obj\
39  *.so *.Z *~ *.old *.elc *.ln *.bak *.BAK *.orig *.rej *.exe _$* *$";
40
41 #define IGN_GROW 16                     /* grow the list by 16 elements at a
42                                          * time */
43
44 /* Nonzero if we have encountered an -I ! directive, which means one should
45    no longer ask the server about what is in CVSROOTADM_IGNORE.  */
46 int ign_inhibit_server;
47
48
49
50 /*
51  * To the "ignore list", add the hard-coded default ignored wildcards above,
52  * the wildcards found in $CVSROOT/CVSROOT/cvsignore, the wildcards found in
53  * ~/.cvsignore and the wildcards found in the CVSIGNORE environment
54  * variable.
55  */
56 void
57 ign_setup (void)
58 {
59     char *home_dir;
60     char *tmp;
61
62     ign_inhibit_server = 0;
63
64     /* Start with default list and special case */
65     tmp = xstrdup (ign_default);
66     ign_add (tmp, 0);
67     free (tmp);
68
69     /* The client handles another way, by (after it does its own ignore file
70        processing, and only if !ign_inhibit_server), letting the server
71        know about the files and letting it decide whether to ignore
72        them based on CVSROOOTADM_IGNORE.  */
73     if (!current_parsed_root->isremote)
74     {
75         char *file = Xasprintf ("%s/%s/%s", current_parsed_root->directory,
76                                 CVSROOTADM, CVSROOTADM_IGNORE);
77         /* Then add entries found in repository, if it exists */
78         ign_add_file (file, 0);
79         free (file);
80     }
81
82     /* Then add entries found in home dir, (if user has one) and file exists */
83     home_dir = get_homedir ();
84     /* If we can't find a home directory, ignore ~/.cvsignore.  This may
85        make tracking down problems a bit of a pain, but on the other
86        hand it might be obnoxious to complain when CVS will function
87        just fine without .cvsignore (and many users won't even know what
88        .cvsignore is).  */
89     if (home_dir)
90     {
91         char *file = strcat_filename_onto_homedir (home_dir, CVSDOTIGNORE);
92         ign_add_file (file, 0);
93         free (file);
94     }
95
96     /* Then add entries found in CVSIGNORE environment variable. */
97     ign_add (getenv (IGNORE_ENV), 0);
98
99     /* Later, add ignore entries found in -I arguments */
100 }
101
102
103
104 /*
105  * Open a file and read lines, feeding each line to a line parser. Arrange
106  * for keeping a temporary list of wildcards at the end, if the "hold"
107  * argument is set.
108  */
109 void
110 ign_add_file (char *file, int hold)
111 {
112     FILE *fp;
113     char *line = NULL;
114     size_t line_allocated = 0;
115
116     /* restore the saved list (if any) */
117     if (s_ign_list != NULL)
118     {
119         int i;
120
121         for (i = 0; i < s_ign_count; i++)
122             ign_list[i] = s_ign_list[i];
123         ign_count = s_ign_count;
124         ign_list[ign_count] = NULL;
125
126         s_ign_count = 0;
127         free (s_ign_list);
128         s_ign_list = NULL;
129     }
130
131     /* is this a temporary ignore file? */
132     if (hold)
133     {
134         /* re-set if we had already done a temporary file */
135         if (ign_hold >= 0)
136         {
137             int i;
138
139             for (i = ign_hold; i < ign_count; i++)
140                 free (ign_list[i]);
141             ign_count = ign_hold;
142             ign_list[ign_count] = NULL;
143         }
144         else
145         {
146             ign_hold = ign_count;
147         }
148     }
149
150     /* load the file */
151     fp = CVS_FOPEN (file, "r");
152     if (fp == NULL)
153     {
154         if (! existence_error (errno))
155             error (0, errno, "cannot open %s", file);
156         return;
157     }
158     while (getline (&line, &line_allocated, fp) >= 0)
159         ign_add (line, hold);
160     if (ferror (fp))
161         error (0, errno, "cannot read %s", file);
162     if (fclose (fp) < 0)
163         error (0, errno, "cannot close %s", file);
164     free (line);
165 }
166
167
168
169 /* Parse a line of space-separated wildcards and add them to the list. */
170 void
171 ign_add (char *ign, int hold)
172 {
173     if (!ign || !*ign)
174         return;
175
176     for (; *ign; ign++)
177     {
178         char *mark;
179         char save;
180
181         /* ignore whitespace before the token */
182         if (isspace ((unsigned char) *ign))
183             continue;
184
185         /* If we have used up all the space, add some more.  Do this before
186            processing `!', since an "empty" list still contains the `CVS'
187            entry.  */
188         if (ign_count >= ign_size)
189         {
190             ign_size += IGN_GROW;
191             ign_list = xnrealloc (ign_list, ign_size + 1, sizeof (char *));
192         }
193
194         /*
195          * if we find a single character !, we must re-set the ignore list
196          * (saving it if necessary).  We also catch * as a special case in a
197          * global ignore file as an optimization
198          */
199         if ((!*(ign+1) || isspace ((unsigned char) *(ign+1)))
200             && (*ign == '!' || *ign == '*'))
201         {
202             if (!hold)
203             {
204                 /* permanently reset the ignore list */
205                 int i;
206
207                 for (i = 0; i < ign_count; i++)
208                     free (ign_list[i]);
209                 ign_count = 1;
210                 /* Always ignore the "CVS" directory.  */
211                 ign_list[0] = xstrdup ("CVS");
212                 ign_list[1] = NULL;
213
214                 /* if we are doing a '!', continue; otherwise add the '*' */
215                 if (*ign == '!')
216                 {
217                     ign_inhibit_server = 1;
218                     continue;
219                 }
220             }
221             else if (*ign == '!')
222             {
223                 /* temporarily reset the ignore list */
224                 int i;
225
226                 if (ign_hold >= 0)
227                 {
228                     for (i = ign_hold; i < ign_count; i++)
229                         free (ign_list[i]);
230                     ign_hold = -1;
231                 }
232                 if (s_ign_list)
233                 {
234                     /* Don't save the ignore list twice - if there are two
235                      * bangs in a local .cvsignore file then we don't want to
236                      * save the new list the first bang created.
237                      *
238                      * We still need to free the "new" ignore list.
239                      */
240                     for (i = 0; i < ign_count; i++)
241                         free (ign_list[i]);
242                 }
243                 else
244                 {
245                     /* Save the ignore list for later.  */
246                     s_ign_list = xnmalloc (ign_count, sizeof (char *));
247                     for (i = 0; i < ign_count; i++)
248                         s_ign_list[i] = ign_list[i];
249                     s_ign_count = ign_count;
250                 }
251                 ign_count = 1;
252                     /* Always ignore the "CVS" directory.  */
253                 ign_list[0] = xstrdup ("CVS");
254                 ign_list[1] = NULL;
255                 continue;
256             }
257         }
258
259         /* find the end of this token */
260         for (mark = ign; *mark && !isspace ((unsigned char) *mark); mark++)
261              /* do nothing */ ;
262
263         save = *mark;
264         *mark = '\0';
265
266         ign_list[ign_count++] = xstrdup (ign);
267         ign_list[ign_count] = NULL;
268
269         *mark = save;
270         if (save)
271             ign = mark;
272         else
273             ign = mark - 1;
274     }
275 }
276
277
278
279 /* Return true if the given filename should be ignored by update or import,
280  * else return false.
281  */
282 int
283 ign_name (char *name)
284 {
285     char **cpp = ign_list;
286
287     if (cpp == NULL)
288         return 0;
289
290     while (*cpp)
291         if (CVS_FNMATCH (*cpp++, name, 0) == 0)
292             return 1;
293
294     return 0;
295 }
296
297
298
299 /* FIXME: This list of dirs to ignore stuff seems not to be used.
300    Really?  send_dirent_proc and update_dirent_proc both call
301    ignore_directory and do_module calls ign_dir_add.  No doubt could
302    use some documentation/testsuite work.  */
303
304 static char **dir_ign_list = NULL;
305 static int dir_ign_max = 0;
306 static int dir_ign_current = 0;
307
308 /* Add a directory to list of dirs to ignore.  */
309 void
310 ign_dir_add (char *name)
311 {
312     /* Make sure we've got the space for the entry.  */
313     if (dir_ign_current <= dir_ign_max)
314     {
315         dir_ign_max += IGN_GROW;
316         dir_ign_list = xnrealloc (dir_ign_list,
317                                   dir_ign_max + 1, sizeof (char *));
318     }
319
320     dir_ign_list[dir_ign_current++] = xstrdup (name);
321 }
322
323
324 /* Return nonzero if NAME is part of the list of directories to ignore.  */
325
326 int
327 ignore_directory (const char *name)
328 {
329     int i;
330
331     if (!dir_ign_list)
332         return 0;
333
334     i = dir_ign_current;
335     while (i--)
336     {
337         if (strncmp (name, dir_ign_list[i], strlen (dir_ign_list[i])+1) == 0)
338             return 1;
339     }
340
341     return 0;
342 }
343
344
345
346 /*
347  * Process the current directory, looking for files not in ILIST and
348  * not on the global ignore list for this directory.  If we find one,
349  * call PROC passing it the name of the file and the update dir.
350  * ENTRIES is the entries list, which is used to identify known
351  * directories.  ENTRIES may be NULL, in which case we assume that any
352  * directory with a CVS administration directory is known.
353  */
354 void
355 ignore_files (List *ilist, List *entries, const char *update_dir,
356               Ignore_proc proc)
357 {
358     int subdirs;
359     DIR *dirp;
360     struct dirent *dp;
361     struct stat sb;
362     char *file;
363     const char *xdir;
364     List *files;
365     Node *p;
366
367     /* Set SUBDIRS if we have subdirectory information in ENTRIES.  */
368     if (entries == NULL)
369         subdirs = 0;
370     else
371     {
372         struct stickydirtag *sdtp = entries->list->data;
373
374         subdirs = sdtp == NULL || sdtp->subdirs;
375     }
376
377     /* we get called with update_dir set to "." sometimes... strip it */
378     if (strcmp (update_dir, ".") == 0)
379         xdir = "";
380     else
381         xdir = update_dir;
382
383     dirp = CVS_OPENDIR (".");
384     if (dirp == NULL)
385     {
386         error (0, errno, "cannot open current directory");
387         return;
388     }
389
390     ign_add_file (CVSDOTIGNORE, 1);
391     wrap_add_file (CVSDOTWRAPPER, 1);
392
393     /* Make a list for the files.  */
394     files = getlist ();
395
396     while (errno = 0, (dp = CVS_READDIR (dirp)) != NULL)
397     {
398         file = dp->d_name;
399         if (strcmp (file, ".") == 0 || strcmp (file, "..") == 0)
400             continue;
401         if (findnode_fn (ilist, file) != NULL)
402             continue;
403         if (subdirs)
404         {
405             Node *node;
406
407             node = findnode_fn (entries, file);
408             if (node != NULL
409                 && ((Entnode *) node->data)->type == ENT_SUBDIR)
410             {
411                 char *p;
412                 int dir;
413
414                 /* For consistency with past behaviour, we only ignore
415                    this directory if there is a CVS subdirectory.
416                    This will normally be the case, but the user may
417                    have messed up the working directory somehow.  */
418                 p = Xasprintf ("%s/%s", file, CVSADM);
419                 dir = isdir (p);
420                 free (p);
421                 if (dir)
422                     continue;
423             }
424         }
425
426         /* We could be ignoring FIFOs and other files which are neither
427            regular files nor directories here.  */
428         if (ign_name (file))
429             continue;
430
431         if (
432 #ifdef DT_DIR
433             dp->d_type != DT_UNKNOWN ||
434 #endif
435             lstat (file, &sb) != -1)
436         {
437
438             if (
439 #ifdef DT_DIR
440                 dp->d_type == DT_DIR
441                 || (dp->d_type == DT_UNKNOWN && S_ISDIR (sb.st_mode))
442 #else
443                 S_ISDIR (sb.st_mode)
444 #endif
445                 )
446             {
447                 if (!subdirs)
448                 {
449                     char *temp = Xasprintf ("%s/%s", file, CVSADM);
450                     if (isdir (temp))
451                     {
452                         free (temp);
453                         continue;
454                     }
455                     free (temp);
456                 }
457             }
458 #ifdef S_ISLNK
459             else if (
460 #ifdef DT_DIR
461                      dp->d_type == DT_LNK
462                      || (dp->d_type == DT_UNKNOWN && S_ISLNK (sb.st_mode))
463 #else
464                      S_ISLNK (sb.st_mode)
465 #endif
466                      )
467             {
468                 continue;
469             }
470 #endif
471         }
472
473         p = getnode ();
474         p->type = FILES;
475         p->key = xstrdup (file);
476         (void) addnode (files, p);
477     }
478     if (errno != 0)
479         error (0, errno, "error reading current directory");
480     (void) CVS_CLOSEDIR (dirp);
481
482     sortlist (files, fsortcmp);
483     for (p = files->list->next; p != files->list; p = p->next)
484         (*proc) (p->key, xdir);
485     dellist (&files);
486 }