Added -clobber switch to mhstore(1) [Bug #11160].
[mmh] / docs / historical / mh-6.8.5 / miscellany / less-177 / filename.c
1 /*
2  * Routines to mess around with filenames (and files).
3  * Much of this is very OS dependent.
4  */
5
6 #include <stdio.h>
7 #include "less.h"
8
9 extern char *getenv();
10
11 extern int force_open;
12 extern IFILE curr_ifile;
13 extern IFILE old_ifile;
14
15 /*
16  * Return the full pathname of the given file in the "home directory".
17  */
18         public char *
19 homefile(filename)
20         char *filename;
21 {
22         register char *pathname;
23         register char *homedir;
24
25         homedir = getenv("HOME");
26 #if __MSDOS__
27         /*
28          * Most MSDOS users do not have $HOME defined,
29          * so if no $HOME then look for "_less" anywhere 
30          * on search path (always begins at current directory).
31          */
32         if (homedir == NULL)
33         {
34                 extern char *searchpath();
35                 pathname = searchpath(filename);
36                 if (pathname == NULL)
37                         return (NULL);
38                 pathname = save(pathname);
39         } else
40         {
41                 pathname = (char *) calloc(strlen(homedir)+strlen(filename)+2, 
42                                         sizeof(char));
43                 if (pathname == NULL)
44                         return (NULL);
45                 sprintf(pathname, "%s\\%s", homedir, filename);
46         }
47 #else
48         if (homedir == NULL)
49                 return (NULL);
50         pathname = (char *) calloc(strlen(homedir)+strlen(filename)+2,
51                                 sizeof(char));
52         if (pathname == NULL)
53                 return (NULL);
54         sprintf(pathname, "%s/%s", homedir, filename);
55 #endif
56         return (pathname);
57 }
58
59 /*
60  * Find out where the help file is.
61  */
62         public char *
63 find_helpfile()
64 {
65         register char *helpfile;
66 #if __MSDOS__
67         extern char *searchpath();
68
69         /*
70          * Look in current directory.
71          */
72         if (access(HELPFILE,0) == 0)
73                 return (HELPFILE);
74         /*
75          * Find the basename of HELPFILE,
76          * and look for it in each directory in the search path.
77          */
78         if ((helpfile = strrchr(HELPFILE, '\\')) == NULL)
79                 helpfile = HELPFILE;
80         else
81                 helpfile++;
82         return (save(searchpath(helpfile)));
83 #else
84         if ((helpfile = getenv("LESSHELP")) != NULL)
85                 return (save(helpfile));
86         return (save(HELPFILE));
87 #endif
88 }
89
90 /*
91  * Expand a string, substituting any "%" with the current filename,
92  * and any "#" with the previous filename.
93  */
94         public char *
95 fexpand(s)
96         char *s;
97 {
98         register char *fr, *to;
99         register int n;
100         register char *e;
101
102         /*
103          * Make one pass to see how big a buffer we 
104          * need to allocate for the expanded string.
105          */
106         n = 0;
107         for (fr = s;  *fr != '\0';  fr++)
108         {
109                 switch (*fr)
110                 {
111                 case '%':
112                         n += strlen(get_filename(curr_ifile));
113                         break;
114                 case '#':
115                         if (old_ifile == NULL_IFILE)
116                         {
117                                 error("No previous file", NULL_PARG);
118                                 return (NULL);
119                         }
120                         n += strlen(get_filename(old_ifile));
121                         break;
122                 default:
123                         n++;
124                         break;
125                 }
126         }
127
128         e = (char *) ecalloc(n+1, sizeof(char));
129
130         /*
131          * Now copy the string, expanding any "%" or "#".
132          */
133         to = e;
134         for (fr = s;  *fr != '\0';  fr++)
135         {
136                 switch (*fr)
137                 {
138                 case '%':
139                         strcpy(to, get_filename(curr_ifile));
140                         to += strlen(to);
141                         break;
142                 case '#':
143                         strcpy(to, get_filename(old_ifile));
144                         to += strlen(to);
145                         break;
146                 default:
147                         *to++ = *fr;
148                         break;
149                 }
150         }
151         *to = '\0';
152         return (e);
153 }
154
155 /*
156  * Try to determine if a file is "binary".
157  * This is just a guess, and we need not try too hard to make it accurate.
158  */
159         int
160 bin_file(f)
161         int f;
162 {
163         int i;
164         int n;
165         char data[64];
166
167         n = read(f, data, sizeof(data));
168         for (i = 0;  i < n;  i++)
169                 if (binary_char(data[i]))
170                         return (1);
171         return (0);
172 }
173
174 /*
175  * Try to determine the size of a file by seeking to the end.
176  */
177         static POSITION
178 seek_filesize(f)
179         int f;
180 {
181         offset_t spos;
182
183         spos = lseek(f, (offset_t)0, 2);
184         if (spos == BAD_LSEEK)
185                 return (NULL_POSITION);
186         return ((POSITION) spos);
187 }
188
189 /*
190  * Expand a filename, substituting any environment variables, etc.
191  */
192 #if GLOB
193
194 FILE *popen();
195
196         public char *
197 glob(filename)
198         char *filename;
199 {
200         FILE *f;
201         char *p;
202         int ch;
203         int len;
204         char *cmd;
205         char *gfilename;
206
207         filename = fexpand(filename);
208         if (filename == NULL)
209                 return (NULL);
210
211         /*
212          * We get the shell to expand the filename for us by passing
213          * an "echo" command to the shell and reading its output.
214          */
215         p = getenv("SHELL");
216         if (p == NULL || *p == '\0')
217         {
218                 /*
219                  * Read the output of <echo filename>.
220                  */
221                 cmd = (char *) ecalloc(strlen(filename)+6, sizeof(char));
222                 sprintf(cmd, "echo %s", filename);
223         } else
224         {
225                 /*
226                  * Read the output of <$SHELL -c "echo filename">.
227                  */
228                 cmd = (char *) ecalloc(strlen(p)+strlen(filename)+12, sizeof(char));
229                 sprintf(cmd, "%s -c \"echo %s\"", p, filename);
230         }
231
232         f = popen(cmd, "r");
233         free(cmd);
234         if (f == NULL)
235                 return (filename);
236         free(filename);
237
238         len = 100;
239         gfilename = (char *) ecalloc(len, sizeof(char));
240         for (p = gfilename;  ;  p++)
241         {
242                 if ((ch = getc(f)) == '\n' || ch == EOF)
243                         break;
244                 if (p - gfilename >= len-1)
245                 {
246                         len *= 2;
247                         *p = '\0';
248                         p = (char *) ecalloc(len, sizeof(char));
249                         strcpy(p, gfilename);
250                         free(gfilename);
251                         gfilename = p;
252                         p = gfilename + strlen(gfilename);
253                 }
254                 *p = ch;
255         }
256         *p = '\0';
257         pclose(f);
258         if (*gfilename == '\0')
259                 return (NULL);
260         return (gfilename);
261 }
262
263 #else
264
265         public char *
266 glob(filename)
267         char *filename;
268 {
269         return (fexpand(filename));
270 }
271
272 #endif
273
274
275 #if STAT
276
277 #include <sys/types.h>
278 #include <sys/stat.h>
279
280 /*
281  * Returns NULL if the file can be opened and
282  * is an ordinary file, otherwise an error message
283  * (if it cannot be opened or is a directory, etc.)
284  */
285         public char *
286 bad_file(filename)
287         char *filename;
288 {
289         register char *m;
290         struct stat statbuf;
291
292         if (stat(filename, &statbuf) < 0)
293                 return (errno_message(filename));
294
295         if (force_open)
296                 return (NULL);
297
298         if ((statbuf.st_mode & S_IFMT) == S_IFDIR)
299         {
300                 static char is_dir[] = " is a directory";
301                 m = (char *) ecalloc(strlen(filename) + sizeof(is_dir), 
302                         sizeof(char));
303                 strcpy(m, filename);
304                 strcat(m, is_dir);
305                 return (m);
306         }
307         if ((statbuf.st_mode & S_IFMT) != S_IFREG)
308         {
309                 static char not_reg[] = " is not a regular file";
310                 m = (char *) ecalloc(strlen(filename) + sizeof(not_reg), 
311                         sizeof(char));
312                 strcpy(m, filename);
313                 strcat(m, not_reg);
314                 return (m);
315         }
316
317         return (NULL);
318 }
319
320 /*
321  * Return the size of a file, as cheaply as possible.
322  * In Unix, we can stat the file.
323  */
324         public POSITION
325 filesize(f)
326         int f;
327 {
328         struct stat statbuf;
329
330         if (fstat(f, &statbuf) < 0)
331                 /*
332                  * Can't stat; try seeking to the end.
333                  */
334                 return (seek_filesize(f));
335
336         return ((POSITION) statbuf.st_size);
337 }
338
339 #else
340
341 /*
342  * If we have no way to find out, just say the file is good.
343  */
344         public char *
345 bad_file(filename)
346         char *filename;
347 {
348         return (NULL);
349 }
350
351 /*
352  * We can find the file size by seeking.
353  */
354         public POSITION
355 filesize(f)
356         int f;
357 {
358         return (seek_filesize(f));
359 }
360
361 #endif