![[BACK]](/icons/back.gif){kind=icon}
Return to filename.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / less|
Return to filename.c CVS log | Up to [local] / src / usr.bin / less |
1.1 etheisen 1: /*
2: * Copyright (c) 1984,1985,1989,1994,1995 Mark Nudelman
3: * All rights reserved.
4: *
5: * Redistribution and use in source and binary forms, with or without
6: * modification, are permitted provided that the following conditions
7: * are met:
8: * 1. Redistributions of source code must retain the above copyright
9: * notice, this list of conditions and the following disclaimer.
10: * 2. Redistributions in binary form must reproduce the above copyright
11: * notice in the documentation and/or other materials provided with
12: * the distribution.
13: *
14: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY
15: * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
17: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE
18: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
19: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
20: * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
21: * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
22: * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
23: * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
24: * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25: */
26:
27:
28: /*
29: * Routines to mess around with filenames (and files).
30: * Much of this is very OS dependent.
31: */
32:
33: #include "less.h"
34: #if MSOFTC
35: #include <dos.h>
36: #endif
37:
38: extern int force_open;
39: extern IFILE curr_ifile;
40: extern IFILE old_ifile;
41:
42: /*
43: * Return a pathname that points to a specified file in a specified directory.
44: * Return NULL if the file does not exist in the directory.
45: */
46: static char *
47: dirfile(dirname, filename)
48: char *dirname;
49: char *filename;
50: {
51: char *pathname;
52: int f;
53:
54: if (dirname == NULL || *dirname == '\0')
55: return (NULL);
56: /*
57: * Construct the full pathname.
58: */
59: pathname = (char *) calloc(strlen(dirname) + strlen(filename) + 2,
60: sizeof(char));
61: if (pathname == NULL)
62: return (NULL);
63: #if MSOFTC || OS2
64: sprintf(pathname, "%s\\%s", dirname, filename);
65: #else
66: sprintf(pathname, "%s/%s", dirname, filename);
67: #endif
68: /*
69: * Make sure the file exists.
70: */
71: f = open(pathname, OPEN_READ);
72: if (f < 0)
73: {
74: free(pathname);
75: pathname = NULL;
76: } else
77: {
78: close (f);
79: }
80: return (pathname);
81: }
82:
83: /*
84: * Return the full pathname of the given file in the "home directory".
85: */
86: public char *
87: homefile(filename)
88: char *filename;
89: {
90: register char *pathname;
91:
92: /*
93: * Try $HOME/filename.
94: */
95: pathname = dirfile(getenv("HOME"), filename);
96: if (pathname != NULL)
97: return (pathname);
98: #if OS2
99: /*
100: * Try $INIT/filename.
101: */
102: pathname = dirfile(getenv("INIT"), filename);
103: if (pathname != NULL)
104: return (pathname);
105: #endif
106: #if MSOFTC || OS2
107: /*
108: * Look for the file anywhere on search path.
109: */
110: pathname = (char *) calloc(_MAX_PATH, sizeof(char));
111: _searchenv(filename, "PATH", pathname);
112: if (*pathname != '\0')
113: return (pathname);
114: free(pathname);
115: #endif
116: return (NULL);
117: }
118:
119: /*
120: * Find out where the help file is.
121: */
122: public char *
123: find_helpfile()
124: {
125: register char *helpfile;
126:
127: if ((helpfile = getenv("LESSHELP")) != NULL)
128: return (save(helpfile));
129: #if MSOFTC || OS2
130: return (homefile(HELPFILE));
131: #else
132: return (save(HELPFILE));
133: #endif
134: }
135:
136: /*
137: * Expand a string, substituting any "%" with the current filename,
138: * and any "#" with the previous filename.
139: * {{ This is a lot of work just to support % and #. }}
140: */
141: public char *
142: fexpand(s)
143: char *s;
144: {
145: register char *fr, *to;
146: register int n;
147: register char *e;
148:
149: /*
150: * Make one pass to see how big a buffer we
151: * need to allocate for the expanded string.
152: */
153: n = 0;
154: for (fr = s; *fr != '\0'; fr++)
155: {
156: switch (*fr)
157: {
158: case '%':
159: if (curr_ifile == NULL_IFILE)
160: {
161: /* error("No current file", NULL_PARG); */
162: return (save(s));
163: }
164: n += strlen(get_filename(curr_ifile));
165: break;
166: case '#':
167: if (old_ifile == NULL_IFILE)
168: {
169: /* error("No previous file", NULL_PARG); */
170: return (save(s));
171: }
172: n += strlen(get_filename(old_ifile));
173: break;
174: default:
175: n++;
176: break;
177: }
178: }
179:
180: e = (char *) ecalloc(n+1, sizeof(char));
181:
182: /*
183: * Now copy the string, expanding any "%" or "#".
184: */
185: to = e;
186: for (fr = s; *fr != '\0'; fr++)
187: {
188: switch (*fr)
189: {
190: case '%':
191: strcpy(to, get_filename(curr_ifile));
192: to += strlen(to);
193: break;
194: case '#':
195: strcpy(to, get_filename(old_ifile));
196: to += strlen(to);
197: break;
198: default:
199: *to++ = *fr;
200: break;
201: }
202: }
203: *to = '\0';
204: return (e);
205: }
206:
207: #if TAB_COMPLETE_FILENAME
208:
209: /*
210: * Return a blank-separated list of filenames which "complete"
211: * the given string.
212: */
213: public char *
214: fcomplete(s)
215: char *s;
216: {
217: char *fpat;
218: /*
219: * Complete the filename "s" by globbing "s*".
220: */
221: #if MSOFTC
222: /*
223: * But in DOS, we have to glob "s*.*".
224: * But if the final component of the filename already has
225: * a dot in it, just do "s*".
226: * (Thus, "FILE" is globbed as "FILE*.*",
227: * but "FILE.A" is globbed as "FILE.A*").
228: */
229: char *slash;
230: for (slash = s+strlen(s)-1; slash > s; slash--)
231: if (*slash == '/' || *slash == '\\')
232: break;
233: fpat = (char *) ecalloc(strlen(s)+4, sizeof(char));
234: if (strchr(slash, '.') == NULL)
235: sprintf(fpat, "%s*.*", s);
236: else
237: sprintf(fpat, "%s*", s);
238: #else
239: fpat = (char *) ecalloc(strlen(s)+2, sizeof(char));
240: sprintf(fpat, "%s*", s);
241: #endif
242: s = glob(fpat);
243: if (strcmp(s,fpat) == 0)
244: {
245: /*
246: * The filename didn't expand.
247: */
248: free(s);
249: s = NULL;
250: }
251: free(fpat);
252: return (s);
253: }
254: #endif
255:
256: /*
257: * Try to determine if a file is "binary".
258: * This is just a guess, and we need not try too hard to make it accurate.
259: */
260: public int
261: bin_file(f)
262: int f;
263: {
264: int i;
265: int n;
266: unsigned char data[64];
267:
268: if (!seekable(f))
269: return (0);
270: if (lseek(f, (off_t)0, 0) == BAD_LSEEK)
271: return (0);
272: n = read(f, data, sizeof(data));
273: for (i = 0; i < n; i++)
274: if (binary_char(data[i]))
275: return (1);
276: return (0);
277: }
278:
279: /*
280: * Try to determine the size of a file by seeking to the end.
281: */
282: static POSITION
283: seek_filesize(f)
284: int f;
285: {
286: off_t spos;
287:
288: spos = lseek(f, (off_t)0, 2);
289: if (spos == BAD_LSEEK)
290: return (NULL_POSITION);
291: return ((POSITION) spos);
292: }
293:
294: #if GLOB
295:
296: FILE *popen();
297:
298: /*
299: * Read a string from a file.
300: * Return a pointer to the string in memory.
301: */
302: static char *
303: readfd(fd)
304: FILE *fd;
305: {
306: int len;
307: int ch;
308: char *buf;
309: char *p;
310:
311: /*
312: * Make a guess about how many chars in the string
313: * and allocate a buffer to hold it.
314: */
315: len = 100;
316: buf = (char *) ecalloc(len, sizeof(char));
317: for (p = buf; ; p++)
318: {
319: if ((ch = getc(fd)) == '\n' || ch == EOF)
320: break;
321: if (p - buf >= len-1)
322: {
323: /*
324: * The string is too big to fit in the buffer we have.
325: * Allocate a new buffer, twice as big.
326: */
327: len *= 2;
328: *p = '\0';
329: p = (char *) ecalloc(len, sizeof(char));
330: strcpy(p, buf);
331: free(buf);
332: buf = p;
333: p = buf + strlen(buf);
334: }
335: *p = ch;
336: }
337: *p = '\0';
338: return (buf);
339: }
340:
341: /*
342: * Execute a shell command.
343: * Return a pointer to a pipe connected to the shell command's standard output.
344: */
345: static FILE *
346: shellcmd(cmd, s1, s2)
347: char *cmd;
348: char *s1;
349: char *s2;
350: {
351: char *scmd;
352: char *scmd2;
353: char *shell;
354: FILE *fd;
355: int len;
356:
357: len = strlen(cmd) +
358: (s1 == NULL ? 0 : strlen(s1)) +
359: (s2 == NULL ? 0 : strlen(s2)) + 1;
360: scmd = (char *) ecalloc(len, sizeof(char));
361: sprintf(scmd, cmd, s1, s2);
362: #if HAVE_SHELL
363: shell = getenv("SHELL");
364: if (shell != NULL && *shell != '\0')
365: {
366: /*
367: * Read the output of <$SHELL -c "cmd">.
368: */
369: scmd2 = (char *) ecalloc(strlen(shell) + strlen(scmd) + 7,
370: sizeof(char));
371: sprintf(scmd2, "%s -c \"%s\"", shell, scmd);
372: free(scmd);
373: scmd = scmd2;
374: }
375: #endif
376: fd = popen(scmd, "r");
377: free(scmd);
378: return (fd);
379: }
380:
381: /*
382: * Expand a filename, doing any shell-level substitutions.
383: */
384: public char *
385: glob(filename)
386: char *filename;
387: {
388: char *gfilename;
389:
390: filename = fexpand(filename);
391: #if OS2
392: {
393: char **list;
394: int cnt;
395: int length;
396:
397: list = _fnexplode(filename);
398: if (list == NULL)
399: return (filename);
400: length = 0;
401: for (cnt = 0; list[cnt] != NULL; cnt++)
402: length += strlen(list[cnt]) + 1;
403: gfilename = (char *) ecalloc(length, sizeof(char));
404: for (cnt = 0; list[cnt] != NULL; cnt++)
405: {
406: strcat(gfilename, list[cnt]);
407: strcat(gfilename, " ");
408: }
409: _fnexplodefree(list);
410: }
411: #else
412: {
413: FILE *fd;
414:
415: /*
416: * We get the shell to expand the filename for us by passing
417: * an "echo" command to the shell and reading its output.
418: */
419: fd = shellcmd("echo %s", filename, (char*)NULL);
420: if (fd == NULL)
421: {
422: /*
423: * Cannot create the pipe.
424: * Just return the original (fexpanded) filename.
425: */
426: return (filename);
427: }
428: gfilename = readfd(fd);
429: pclose(fd);
430: if (*gfilename == '\0')
431: {
432: free(gfilename);
433: return (filename);
434: }
435: free(filename);
436: }
437: #endif
438: return (gfilename);
439: }
440:
441: /*
442: * See if we should open a "replacement file"
443: * instead of the file we're about to open.
444: */
445: public char *
446: open_altfile(filename, pf, pfd)
447: char *filename;
448: int *pf;
449: void **pfd;
450: {
451: char *lessopen;
452: char *gfilename;
453: int returnfd = 0;
454: FILE *fd;
455:
456: ch_ungetchar(-1);
457: if ((lessopen = getenv("LESSOPEN")) == NULL)
458: return (NULL);
459: if (strcmp(filename, "-") == 0)
460: return (NULL);
461: if (*lessopen == '|')
462: {
463: /*
464: * If LESSOPEN starts with a |, it indicates
465: * a "pipe preprocessor".
466: */
467: lessopen++;
468: returnfd = 1;
469: }
470: fd = shellcmd(lessopen, filename, (char*)NULL);
471: if (fd == NULL)
472: {
473: /*
474: * Cannot create the pipe.
475: */
476: return (NULL);
477: }
478: if (returnfd)
479: {
480: #if HAVE_FILENO
481: int f;
482: char c;
483:
484: /*
485: * Read one char to see if the pipe will produce any data.
486: * If it does, push the char back on the pipe.
487: */
488: f = fileno(fd);
489: if (read(f, &c, 1) != 1)
490: {
491: /*
492: * Pipe is empty. This means there is no alt file.
493: */
494: pclose(fd);
495: return (NULL);
496: }
497: ch_ungetchar(c);
498: *pfd = (void *) fd;
499: *pf = f;
500: return (save("-"));
501: #else
502: error("LESSOPEN pipe is not supported", NULL_PARG);
503: return (NULL);
504: #endif
505: }
506: gfilename = readfd(fd);
507: pclose(fd);
508: if (*gfilename == '\0')
509: /*
510: * Pipe is empty. This means there is no alt file.
511: */
512: return (NULL);
513: return (gfilename);
514: }
515:
516: /*
517: * Close a replacement file.
518: */
519: public void
520: close_altfile(altfilename, filename, pipefd)
521: char *altfilename;
522: char *filename;
523: void *pipefd;
524: {
525: char *lessclose;
526: FILE *fd;
527:
528: if (pipefd != NULL)
529: pclose((FILE*) pipefd);
530: if ((lessclose = getenv("LESSCLOSE")) == NULL)
531: return;
532: fd = shellcmd(lessclose, filename, altfilename);
533: pclose(fd);
534: }
535:
536: #else
537: #if MSOFTC
538:
539: public char *
540: glob(filename)
541: char *filename;
542: {
543: register char *gfilename;
544: register char *p;
545: register int len;
546: register int n;
547: struct find_t fnd;
548: char drive[_MAX_DRIVE];
549: char dir[_MAX_DIR];
550: char fname[_MAX_FNAME];
551: char ext[_MAX_EXT];
552:
553: filename = fexpand(filename);
554: if (_dos_findfirst(filename, ~0, &fnd) != 0)
555: return (filename);
556:
557: _splitpath(filename, drive, dir, fname, ext);
558: len = 100;
559: gfilename = (char *) ecalloc(len, sizeof(char));
560: p = gfilename;
561: do {
562: n = strlen(drive) + strlen(dir) + strlen(fnd.name);
563: while (p - gfilename + n+2 >= len)
564: {
565: len *= 2;
566: *p = '\0';
567: p = (char *) ecalloc(len, sizeof(char));
568: strcpy(p, gfilename);
569: free(gfilename);
570: gfilename = p;
571: p = gfilename + strlen(gfilename);
572: }
573: sprintf(p, "%s%s%s", drive, dir, fnd.name);
574: p += n;
575: *p++ = ' ';
576: } while (_dos_findnext(&fnd) == 0);
577:
578: *--p = '\0';
579: return (gfilename);
580: }
581:
582: public char *
583: open_altfile(filename)
584: char *filename;
585: {
586: return (NULL);
587: }
588:
589: public void
590: close_altfile(altfilename, filename)
591: char *altfilename;
592: char *filename;
593: {
594: }
595:
596: #else
597:
598: public char *
599: glob(filename)
600: char *filename;
601: {
602: return (fexpand(filename));
603: }
604:
605:
606: public char *
607: open_altfile(filename)
608: char *filename;
609: {
610: return (NULL);
611: }
612:
613: public void
614: close_altfile(altfilename, filename)
615: char *altfilename;
616: char *filename;
617: {
618: }
619:
620: #endif
621: #endif
622:
623:
624: #if HAVE_STAT
625:
626: #include <sys/stat.h>
627: #ifndef S_ISDIR
628: #define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
629: #endif
630: #ifndef S_ISREG
631: #define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
632: #endif
633:
634: /*
635: * Returns NULL if the file can be opened and
636: * is an ordinary file, otherwise an error message
637: * (if it cannot be opened or is a directory, etc.)
638: */
639: public char *
640: bad_file(filename)
641: char *filename;
642: {
643: register char *m;
644: struct stat statbuf;
645:
646: if (stat(filename, &statbuf) < 0)
647: return (errno_message(filename));
648:
649: if (force_open)
650: return (NULL);
651:
652: if (S_ISDIR(statbuf.st_mode))
653: {
654: static char is_dir[] = " is a directory";
655: m = (char *) ecalloc(strlen(filename) + sizeof(is_dir),
656: sizeof(char));
657: strcpy(m, filename);
658: strcat(m, is_dir);
659: return (m);
660: }
661: if (!S_ISREG(statbuf.st_mode))
662: {
663: static char not_reg[] = " is not a regular file";
664: m = (char *) ecalloc(strlen(filename) + sizeof(not_reg),
665: sizeof(char));
666: strcpy(m, filename);
667: strcat(m, not_reg);
668: return (m);
669: }
670:
671: return (NULL);
672: }
673:
674: /*
675: * Return the size of a file, as cheaply as possible.
676: * In Unix, we can stat the file.
677: */
678: public POSITION
679: filesize(f)
680: int f;
681: {
682: struct stat statbuf;
683:
684: if (fstat(f, &statbuf) < 0)
685: /*
686: * Can't stat; try seeking to the end.
687: */
688: return (seek_filesize(f));
689:
690: return ((POSITION) statbuf.st_size);
691: }
692:
693: #else
694:
695: /*
696: * If we have no way to find out, just say the file is good.
697: */
698: public char *
699: bad_file(filename)
700: char *filename;
701: {
702: return (NULL);
703: }
704:
705: /*
706: * We can find the file size by seeking.
707: */
708: public POSITION
709: filesize(f)
710: int f;
711: {
712: return (seek_filesize(f));
713: }
714:
715: #endif