dir.c revision 1.2 
1/* dir.c -- How to build a special "dir" node from "localdir" files.
2   $Id: dir.c,v 1.2 1999/01/11 16:38:06 espie Exp $
3
4   Copyright (C) 1993, 97 Free Software Foundation, Inc.
5
6   This program is free software; you can redistribute it and/or modify
7   it under the terms of the GNU General Public License as published by
8   the Free Software Foundation; either version 2, or (at your option)
9   any later version.
10
11   This program is distributed in the hope that it will be useful,
12   but WITHOUT ANY WARRANTY; without even the implied warranty of
13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14   GNU General Public License for more details.
15
16   You should have received a copy of the GNU General Public License
17   along with this program; if not, write to the Free Software
18   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19
20   Written by Brian Fox (bfox@ai.mit.edu). */
21
22#include "info.h"
23#include "info-utils.h"
24#include "filesys.h"
25#include "tilde.h"
26
27/* The "dir" node can be built from the contents of a file called "dir",
28   with the addition of the menus of every file named in the array
29   dirs_to_add which are found in INFOPATH. */
30
31static void add_menu_to_file_buffer (), insert_text_into_fb_at_binding ();
32
33static char *dirs_to_add[] = {
34  "dir", "localdir", (char *)NULL
35};
36
37
38/* Return zero if the file represented in the stat structure TEST has
39   already been seen, nonzero else.  */
40
41typedef struct
42{
43  unsigned long device;
44  unsigned long inode;
45} dir_file_list_entry_type;
46
47static int
48new_dir_file_p (test)
49    struct stat *test;
50{
51  static unsigned dir_file_list_len = 0;
52  static dir_file_list_entry_type *dir_file_list = NULL;
53  unsigned i;
54
55  for (i = 0; i < dir_file_list_len; i++)
56    {
57      dir_file_list_entry_type entry;
58      entry = dir_file_list[i];
59      if (entry.device == test->st_dev && entry.inode == test->st_ino)
60        return 0;
61    }
62
63  dir_file_list_len++;
64  dir_file_list = xrealloc (dir_file_list,
65                        dir_file_list_len * sizeof (dir_file_list_entry_type));
66  dir_file_list[dir_file_list_len - 1].device = test->st_dev;
67  dir_file_list[dir_file_list_len - 1].inode = test->st_ino;
68  return 1;
69}
70
71
72void
73maybe_build_dir_node (dirname)
74     char *dirname;
75{
76  int path_index, update_tags;
77  char *this_dir;
78  FILE_BUFFER *dir_buffer = info_find_file (dirname);
79
80  /* If there is no "dir" in the current info path, we cannot build one
81     from nothing. */
82  if (!dir_buffer)
83    return;
84
85  /* If this directory has already been built, return now. */
86  if (dir_buffer->flags & N_CannotGC)
87    return;
88
89  /* Initialize the list we use to avoid reading the same dir file twice
90     with the dir file just found.  */
91  new_dir_file_p (&dir_buffer->finfo);
92
93  path_index = update_tags = 0;
94
95  /* Using each element of the path, check for one of the files in
96     DIRS_TO_ADD.  Do not check for "localdir.info.Z" or anything else.
97     Only files explictly named are eligible.  This is a design decision.
98     There can be an info file name "localdir.info" which contains
99     information on the setting up of "localdir" files. */
100  while ((this_dir = extract_colon_unit (infopath, &path_index)))
101    {
102      register int da_index;
103      char *from_file;
104
105      /* Expand a leading tilde if one is present. */
106      if (*this_dir == '~')
107        {
108          char *tilde_expanded_dirname;
109
110          tilde_expanded_dirname = tilde_expand_word (this_dir);
111          if (tilde_expanded_dirname != this_dir)
112            {
113              free (this_dir);
114              this_dir = tilde_expanded_dirname;
115            }
116        }
117
118      /* For every different file named in DIRS_TO_ADD found in the
119         search path, add that file's menu to our "dir" node. */
120      for (da_index = 0; (from_file = dirs_to_add[da_index]); da_index++)
121        {
122          struct stat finfo;
123          int statable;
124          int namelen = strlen (from_file);
125          char *fullpath = xmalloc (3 + strlen (this_dir) + namelen);
126
127          strcpy (fullpath, this_dir);
128          if (fullpath[strlen (fullpath) - 1] != '/')
129            strcat (fullpath, "/");
130          strcat (fullpath, from_file);
131
132          statable = (stat (fullpath, &finfo) == 0);
133
134          /* Only add this file if we have not seen it before.  */
135          if (statable && S_ISREG (finfo.st_mode) && new_dir_file_p (&finfo))
136            {
137              long filesize;
138              char *contents = filesys_read_info_file (fullpath, &filesize,
139                                                       &finfo);
140              if (contents)
141                {
142                  update_tags++;
143                  add_menu_to_file_buffer (contents, filesize, dir_buffer);
144                  free (contents);
145                }
146            }
147
148          free (fullpath);
149        }
150      free (this_dir);
151    }
152
153  if (update_tags)
154    build_tags_and_nodes (dir_buffer);
155
156  /* Flag that the dir buffer has been built. */
157  dir_buffer->flags |= N_CannotGC;
158}
159
160/* Given CONTENTS and FB (a file buffer), add the menu found in CONTENTS
161   to the menu found in FB->contents.  Second argument SIZE is the total
162   size of CONTENTS. */
163static void
164add_menu_to_file_buffer (contents, size, fb)
165     char *contents;
166     long size;
167     FILE_BUFFER *fb;
168{
169  SEARCH_BINDING contents_binding, fb_binding;
170  long contents_offset, fb_offset;
171
172  contents_binding.buffer = contents;
173  contents_binding.start = 0;
174  contents_binding.end = size;
175  contents_binding.flags = S_FoldCase | S_SkipDest;
176
177  fb_binding.buffer = fb->contents;
178  fb_binding.start = 0;
179  fb_binding.end = fb->filesize;
180  fb_binding.flags = S_FoldCase | S_SkipDest;
181
182  /* Move to the start of the menus in CONTENTS and FB. */
183  contents_offset = search_forward (INFO_MENU_LABEL, &contents_binding);
184  fb_offset = search_forward (INFO_MENU_LABEL, &fb_binding);
185
186  /* If there is no menu in CONTENTS, quit now. */
187  if (contents_offset == -1)
188    return;
189
190  /* There is a menu in CONTENTS, and contents_offset points to the first
191     character following the menu starter string.  Skip all whitespace
192     and newline characters. */
193  contents_offset += skip_whitespace_and_newlines (contents + contents_offset);
194
195  /* If there is no menu in FB, make one. */
196  if (fb_offset == -1)
197    {
198      /* Find the start of the second node in this file buffer.  If there
199         is only one node, we will be adding the contents to the end of
200         this node. */
201      fb_offset = find_node_separator (&fb_binding);
202
203      /* If not even a single node separator, give up. */
204      if (fb_offset == -1)
205        return;
206
207      fb_binding.start = fb_offset;
208      fb_binding.start +=
209        skip_node_separator (fb_binding.buffer + fb_binding.start);
210
211      /* Try to find the next node separator. */
212      fb_offset = find_node_separator (&fb_binding);
213
214      /* If found one, consider that the start of the menu.  Otherwise, the
215         start of this menu is the end of the file buffer (i.e., fb->size). */
216      if (fb_offset != -1)
217        fb_binding.start = fb_offset;
218      else
219        fb_binding.start = fb_binding.end;
220
221      insert_text_into_fb_at_binding
222        (fb, &fb_binding, INFO_MENU_LABEL, strlen (INFO_MENU_LABEL));
223
224      fb_binding.buffer = fb->contents;
225      fb_binding.start = 0;
226      fb_binding.end = fb->filesize;
227      fb_offset = search_forward (INFO_MENU_LABEL, &fb_binding);
228      if (fb_offset == -1)
229        abort ();
230    }
231
232  /* CONTENTS_OFFSET and FB_OFFSET point to the starts of the menus that
233     appear in their respective buffers.  Add the remainder of CONTENTS
234     to the end of FB's menu. */
235  fb_binding.start = fb_offset;
236  fb_offset = find_node_separator (&fb_binding);
237  if (fb_offset != -1)
238    fb_binding.start = fb_offset;
239  else
240    fb_binding.start = fb_binding.end;
241
242  /* Leave exactly one blank line between directory entries. */
243  {
244    int num_found = 0;
245
246    while ((fb_binding.start > 0) &&
247           (whitespace_or_newline (fb_binding.buffer[fb_binding.start - 1])))
248      {
249        num_found++;
250        fb_binding.start--;
251      }
252
253    /* Optimize if possible. */
254    if (num_found >= 2)
255      {
256        fb_binding.buffer[fb_binding.start++] = '\n';
257        fb_binding.buffer[fb_binding.start++] = '\n';
258      }
259    else
260      {
261        /* Do it the hard way. */
262        insert_text_into_fb_at_binding (fb, &fb_binding, "\n\n", 2);
263        fb_binding.start += 2;
264      }
265  }
266
267  /* Insert the new menu. */
268  insert_text_into_fb_at_binding
269    (fb, &fb_binding, contents + contents_offset, size - contents_offset);
270}
271
272static void
273insert_text_into_fb_at_binding (fb, binding, text, textlen)
274     FILE_BUFFER *fb;
275     SEARCH_BINDING *binding;
276     char *text;
277     int textlen;
278{
279  char *contents;
280  long start, end;
281
282  start = binding->start;
283  end = fb->filesize;
284
285  contents = (char *)xmalloc (fb->filesize + textlen + 1);
286  memcpy (contents, fb->contents, start);
287  memcpy (contents + start, text, textlen);
288  memcpy (contents + start + textlen, fb->contents + start, end - start);
289  free (fb->contents);
290  fb->contents = contents;
291  fb->filesize += textlen;
292  fb->finfo.st_size = fb->filesize;
293}
294