File: docnames.c

package info (click to toggle)
bow 19991122-4
  • links: PTS
  • area: main
  • in suites: woody
  • size: 2,544 kB
  • ctags: 2,987
  • sloc: ansic: 38,660; lisp: 1,072; makefile: 594; perl: 492; yacc: 149; sh: 91
file content (205 lines) | stat: -rw-r--r-- 6,040 bytes parent folder | download | duplicates (3)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
/* Managing lists of document names. */

/* Copyright (C) 1997, 1999 Andrew McCallum

   Written by:  Andrew Kachites McCallum <mccallum@cs.cmu.edu>

   This file is part of the Bag-Of-Words Library, `libbow'.

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public License
   as published by the Free Software Foundation, version 2.
   
   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public
   License along with this library; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA */

#include <bow/libbow.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>
#include <string.h>
#include <assert.h>
#include <stdio.h>

int bow_map_verbosity_level = bow_chatty;

/* Calls the function CALLBACK for each of the filenames encountered
   when recursively descending the directory named DIRNAME.  CALLBACK
   should be a pointer to function that takes a filename char-pointer,
   and a void-pointer as arguments and returns an integer.  Currently
   the return value is ignored, but it may be used in the future to
   cut short, causing bow_map_filesnames_from_dir to return
   immediately.  The value CONTEXT will be passed as the second
   argument to the CALLBACK function; it provides you with a way to
   transfer context you may need inside the implementation of the
   callback function.  EXCLUDE_PATTERNS is currently ignored. */
int
bow_map_filenames_from_dir (int (*callback)(const char *filename, 
					    void *context),
			    void *context,
			    const char *dirname_arg,
			    const char *exclude_patterns)
{
  DIR *dir;
  struct dirent *dirent_p;
  struct stat st;
  char cwd[PATH_MAX];
  int num_files = 0;
  char dirname[1024];

  strcpy (dirname, dirname_arg);
#if 0
  /* strcat (dirname, "/"); */

  stat (dirname, &st);
  if (!S_ISDIR (st.st_mode))
    {
      /* assert ((dirname[0] == '/') || (dirname[0] == '\\') || 
	      ((dirname[1] == ':') && (dirname[2] == '\\'))); */
      /* DIRNAME is not a directory, it's a file. */
      (*callback) (dirname, context);
      return 1;
    }
#endif

  if (!(dir = opendir (dirname)))
    {
      perror (__PRETTY_FUNCTION__);
      getcwd (cwd, PATH_MAX);
      fprintf (stderr, "CWD is `%s'\n", cwd);
      fprintf (stderr,"Couldn't open directory `%s'.  Skipping.\n", dirname);
      return 1;
#if 0
      fprintf ("Opening as file.", dirname);
      (*callback) (dirname, context);
      return 1;
      /*fprintf (stderr,"Couldn't open directory `%s'.  Skipping.", dirname);*/
      /*bow_error ("Couldn't open directory `%s'", dirname);*/
#endif
    }

#if 0
  getcwd (initial_cwd, PATH_MAX);
  chdir (dirname);
  getcwd (cwd, PATH_MAX);
  strcat (cwd, "/");
  cwdlen = strlen (cwd);
#endif

  if (bow_verbosity_use_backspace 
      && bow_verbosity_level >= bow_map_verbosity_level)
    bow_verbosify (bow_progress, "%s:       ", dirname);
  while ((dirent_p = readdir (dir)))
    {
      char subname[strlen(dirname) + strlen(dirent_p->d_name) + 5];
      strcpy (subname, dirname);
      strcat (subname, "/");
      strcat (subname, dirent_p->d_name);
      
      stat (subname, &st);
      if (S_ISDIR (st.st_mode)
	  && strcmp (dirent_p->d_name, ".")
	  && strcmp (dirent_p->d_name, ".."))
	{
	  /* This directory entry is a subdirectory.  Recursively 
	     descend into it and append its files also. */
	  num_files += 
	    bow_map_filenames_from_dir (callback, context,
					subname, exclude_patterns);
	}
      else if (S_ISREG (st.st_mode))
	{
	  /* It's a regular file; add it to the list. */

	  /* xxx Move this out of this function, and subsitute
             BOW_EXCLUDE_FILENAME with EXCLUDE_PATTERNS here? */
	  if (bow_exclude_filename
	      && !strcmp (dirent_p->d_name, bow_exclude_filename))
	    continue;

	  /* Here is where we actually call the map-function with
	     the filename. */
	  (*callback) (subname, context);
	  num_files++;
	  if (!bow_verbosify (bow_screaming, "%6d Adding %s\n",
			      num_files, subname))
	    if (bow_verbosity_level >= bow_map_verbosity_level)
	      bow_verbosify (bow_progress, "\b\b\b\b\b\b%6d", num_files);
	}
    }
  closedir (dir);
#if 0
  chdir (initial_cwd);
#endif

  if (bow_verbosity_use_backspace
      && bow_verbosity_level >= bow_map_verbosity_level)
    bow_verbosify (bow_progress, "\n");
  
  return num_files;
}

/* Create a linked list of filenames, and append the document list
   pointed to by DL to it; return the new concatenated lists in *DL.
   The function returns the total number of filenames.  When creating
   the list, look for files (and recursively descend directories) in
   the directory DIRNAME, but don't include those matching
   EXCLUDE_PATTERNS. */
int
bow_doc_list_append (bow_doc_list **dl,
		     const char *dirname,
		     const char *exclude_patterns)
{
  bow_doc_list *dl_next = NULL;
  int append_filename (const char *filename, void *context)
    {
      dl_next = *dl;
      *dl = bow_malloc (sizeof (bow_doc_list) + strlen (filename) + 1);
      (*dl)->next = dl_next;
      strcpy ((*dl)->filename, filename);
      return 0;
    }

  return bow_map_filenames_from_dir (append_filename, NULL,
				     dirname, exclude_patterns);
}

/* Return the number of entries in the "docname list" DL. */
int
bow_doc_list_length (bow_doc_list *dl)
{
  int c = 0;
  for ( ; dl; dl = dl->next)
    c++;
  return c;
}

void
bow_doc_list_fprintf (FILE *fp, bow_doc_list *dl)
{
  while (dl)
    {
      fprintf (fp, "%s\n", dl->filename);
      dl = dl->next;
    }
}

void
bow_doc_list_free (bow_doc_list *dl)
{
  bow_doc_list *next_dl;

  while (dl)
    {
      next_dl = dl->next;
      bow_free (dl);
      dl = next_dl;
    }
}