![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dired.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / emacs / src|
Return to dired.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / emacs / src |
1.1 root 1: /* Lisp functions for making directory listings.
2: Copyright (C) 1985 Richard M. Stallman.
3:
4: This file is part of GNU Emacs.
5:
6: GNU Emacs is distributed in the hope that it will be useful,
7: but WITHOUT ANY WARRANTY. No author or distributor
8: accepts responsibility to anyone for the consequences of using it
9: or for whether it serves any particular purpose or works at all,
10: unless he says so in writing. Refer to the GNU Emacs General Public
11: License for full details.
12:
13: Everyone is granted permission to copy, modify and redistribute
14: GNU Emacs, but only under the conditions described in the
15: GNU Emacs General Public License. A copy of this license is
16: supposed to have been given to you along with GNU Emacs so you
17: can know your rights and responsibilities. It should be in a
18: file named COPYING. Among other things, the copyright notice
19: and this notice must be preserved on all copies. */
20:
21:
22: #include <stdio.h>
23: #include <sys/types.h>
24: #include <sys/stat.h>
25:
26: #include "config.h"
27:
28: #ifdef NONSYSTEM_DIR_LIBRARY
29: #include "ndir.h"
30: #else /* not NONSYSTEM_DIR_LIBRARY */
31: #include <sys/dir.h>
32: #endif /* not NONSYSTEM_DIR_LIBRARY */
33:
34: #undef NULL
35:
36: #include "lisp.h"
37: #include "buffer.h"
38: #include "commands.h"
39:
40: #define min(a, b) ((a) < (b) ? (a) : (b))
41:
42: /* if system does not have symbolic links, it does not have lstat.
43: In that case, use ordinary stat instead. */
44:
45: #ifndef S_IFLNK
46: #define lstat stat
47: #endif
48:
49: extern DIR *opendir ();
50: extern struct direct *readdir ();
51:
52: Lisp_Object Vcompletion_ignored_extensions;
53:
54: DEFUN ("directory-files", Fdirectory_files, Sdirectory_files, 1, 2, 0,
55: "Return a list of names of files in DIRECTORY.\n\
56: If FULL is non-NIL, absolute pathnames of the files are returned.")
57: (dirname, full)
58: Lisp_Object dirname, full;
59: {
60: DIR *d;
61: struct direct *dp;
62: char slashfilename[MAXNAMLEN+2];
63: char *filename = slashfilename;
64: int length;
65: Lisp_Object list, name;
66:
67: dirname = Fexpand_file_name (dirname, Qnil);
68: if (!(d = opendir (XSTRING (dirname)->data)))
69: report_file_error ("Opening directory", Fcons (dirname, Qnil));
70:
71: list = Qnil;
72: length = XSTRING (dirname)->size;
73: if (length == 0 || XSTRING (dirname)->data[length - 1] != '/')
74: *filename++ = '/';
75:
76: /* Loop reading blocks */
77: while (1)
78: {
79: dp = readdir (d);
80: if (!dp) break;
81: if (dp->d_ino)
82: {
83: strncpy (filename, dp->d_name, dp->d_namlen);
84: filename[dp->d_namlen] = 0;
85: if (!NULL (full))
86: name = concat2 (dirname, build_string (slashfilename));
87: else
88: name = build_string (filename);
89: list = Fcons (name, list);
90: }
91: }
92: closedir (d);
93: return Fsort (Fnreverse (list), Qstring_lessp);
94: }
95:
96: Lisp_Object file_name_completion ();
97:
98: DEFUN ("file-name-completion", Ffile_name_completion, Sfile_name_completion,
99: 2, 2, 0,
100: "Complete file name FILE in directory DIR.\n\
101: Returns the longest string common to all filenames in DIR\n\
102: that start with FILE.\n\
103: If there is only one and FILE matches it exactly, returns t.\n\
104: Returns nil if DIR contains no name starting with FILE.")
105: (file, dirname)
106: Lisp_Object file, dirname;
107: {
108: /* Don't waste time trying to complete a null string.
109: Besides, this case happens when user is being asked for
110: a directory name and has supplied one ending in a /.
111: We would not want to add anything in that case
112: even if there are some unique characters in that directory. */
113: if (XTYPE (file) == Lisp_String && XSTRING (file)->size == 0)
114: return file;
115: return file_name_completion (file, dirname, 0);
116: }
117:
118: DEFUN ("file-name-all-completions", Ffile_name_all_completions,
119: Sfile_name_all_completions, 2, 2, 0,
120: "Return a list of all completions of file name FILE in directory DIR.")
121: (file, dirname)
122: Lisp_Object file, dirname;
123: {
124: return file_name_completion (file, dirname, 1);
125: }
126:
127: Lisp_Object
128: file_name_completion (file, dirname, all_flag)
129: Lisp_Object file, dirname;
130: int all_flag;
131: {
132: DIR *d;
133: struct direct *dp;
134: int bestmatchsize, skip;
135: register int compare, matchsize;
136: unsigned char *p1, *p2;
137: int matchcount = 0;
138: Lisp_Object bestmatch, tem, elt, name;
139: struct stat st;
140: int directoryp;
141: int passcount;
142:
143: dirname = Fexpand_file_name (dirname, Qnil);
144: bestmatch = Qnil;
145:
146: /* passcount = 0, ignore files that end in an ignored extension.
147: If nothing found then try again with passcount = 1, don't ignore them.
148: If looking for all completions, start with passcount = 1,
149: so always take even the ignored ones. */
150: for (passcount = !!all_flag; NULL (bestmatch) && passcount < 2; passcount++)
151: {
152: if (!(d = opendir (XSTRING (dirname)->data)))
153: report_file_error ("Opening directory", Fcons (dirname, Qnil));
154:
155: /* Loop reading blocks */
156: while (dp = readdir (d))
157: {
158: if (!NULL (Vquit_flag) && NULL (Vinhibit_quit))
159: goto quit;
160: if (!dp->d_ino ||
161: dp->d_namlen < XSTRING (file)->size ||
162: bcmp (dp->d_name, XSTRING (file)->data, XSTRING (file)->size))
163: continue;
164:
165: tem = Qnil;
166: /* Compare extensions-to-be-ignored against end of this file name */
167: /* if name is not an exact match against specified string */
168: if (!passcount && dp->d_namlen > XSTRING (file)->size)
169: /* and exit this for loop if a match is found */
170: for (tem = Vcompletion_ignored_extensions;
171: LISTP (tem); tem = XCONS (tem)->cdr)
172: {
173: elt = XCONS (tem)->car;
174: if (XTYPE (elt) != Lisp_String) continue;
175: skip = dp->d_namlen - XSTRING (elt)->size;
176: if (skip < 0) continue;
177:
178: if (bcmp (dp->d_name + skip,
179: XSTRING (elt)->data,
180: XSTRING (elt)->size))
181: continue;
182: break;
183: }
184:
185: /* Unless a match was found, process this name as a completion */
186: if ((passcount || NULL (tem))
187: && file_name_completion_stat (dirname, dp, &st) >= 0)
188: {
189: /* Update computation of how much all possible completions match */
190:
191: matchcount++;
192: directoryp = ((st.st_mode & S_IFMT) == S_IFDIR);
193: if (all_flag || NULL (bestmatch))
194: {
195: /* This is a possible completion */
196: if (directoryp)
197: {
198: /* This completion is a directory; make it end with '/' */
199: name = make_string (dp->d_name, dp->d_namlen + 1);
200: XSTRING (name)->data[dp->d_namlen] = '/';
201: }
202: else
203: name = make_string (dp->d_name, dp->d_namlen);
204: if (all_flag)
205: {
206: bestmatch = Fcons (name, bestmatch);
207: }
208: else
209: {
210: bestmatch = name;
211: bestmatchsize = XSTRING (name)->size;
212: }
213: }
214: else
215: {
216: compare = min (bestmatchsize, dp->d_namlen);
217: p1 = XSTRING (bestmatch)->data;
218: p2 = (unsigned char *) dp->d_name;
219: for (matchsize = 0; matchsize < compare; matchsize++)
220: if (p1[matchsize] != p2[matchsize]) break;
221: /* If this dirname all matches,
222: see if implicit following slash does too. */
223: if (directoryp &&
224: compare == matchsize &&
225: bestmatchsize > matchsize &&
226: p1[matchsize] == '/')
227: matchsize++;
228: bestmatchsize = min (matchsize, bestmatchsize);
229: }
230: }
231: }
232: closedir (d);
233: }
234:
235: if (all_flag || NULL (bestmatch))
236: return bestmatch;
237: if (matchcount == 1 && bestmatchsize == XSTRING (file)->size)
238: return Qt;
239: return Fsubstring (bestmatch, make_number (0), make_number (bestmatchsize));
240: quit:
241: if (d) closedir (d);
242: Vquit_flag = Qnil;
243: return Fsignal (Qquit, Qnil);
244: }
245:
246: file_name_completion_stat (dirname, dp, st_addr)
247: Lisp_Object dirname;
248: struct direct *dp;
249: struct stat *st_addr;
250: {
251: char *fullname = (char *) alloca (dp->d_namlen + XSTRING (dirname)->size + 2);
252: int pos = XSTRING (dirname)->size;
253:
254: bcopy (XSTRING (dirname)->data, fullname, pos);
255: if (fullname[pos - 1] != '/')
256: fullname[pos++] = '/';
257:
258: bcopy (dp->d_name, fullname + pos, dp->d_namlen);
259: fullname[pos + dp->d_namlen] = 0;
260:
261: return stat (fullname, st_addr);
262: }
263:
264: Lisp_Object
265: make_time (time)
266: int time;
267: {
268: return Fcons (make_number (time >> 16),
269: Fcons (make_number (time & 0177777), Qnil));
270: }
271:
272: DEFUN ("file-attributes", Ffile_attributes, Sfile_attributes, 1, 1, 0,
273: "Return a list of attributes of file FILENAME.\n\
274: Elements are:\n\
275: 0. t for directory, string (name linked to) for symbolic link, or nil.\n\
276: 1. Number of links to file.\n\
277: 2. File uid.\n\
278: 3. File gid.\n\
279: 4. Last access time, as a list of two integers.\n\
280: First integer has high-order 16 bits of time, second has low 16 bits.\n\
281: 5. Last modification time, likewise.\n\
282: 6. Last status change time, likewise.\n\
283: 7. Size in bytes.\n\
284: 8. File modes, as a string of nine letters or dashes as in ls -l.")
285: (filename)
286: Lisp_Object filename;
287: {
288: Lisp_Object values[9];
289: struct stat s;
290: char modes[10];
291:
292: filename = Fexpand_file_name (filename, Qnil);
293: if (lstat(XSTRING (filename)->data, &s)<0)
294: return Qnil;
295:
296: values[0] = ((s.st_mode & S_IFMT)==S_IFDIR) ? Qt : Qnil;
297: #ifdef S_IFLNK
298: if ((s.st_mode & S_IFMT) == S_IFLNK)
299: values[0] = Ffile_symlink_p (filename);
300: #endif
301: XFASTINT (values[1]) = s.st_nlink;
302: XFASTINT (values[2]) = s.st_uid;
303: XFASTINT (values[3]) = s.st_gid;
304: values[4] = make_time(s.st_atime);
305: values[5] = make_time(s.st_mtime);
306: values[6] = make_time(s.st_ctime);
307: XFASTINT (values[7]) = s.st_size;
308: filemodestring (&s, modes);
309: values[8] = make_string (modes, 10);
310: return Flist (9, values);
311: }
312:
313: syms_of_dired ()
314: {
315: defsubr (&Sdirectory_files);
316: defsubr (&Sfile_name_completion);
317: defsubr (&Sfile_name_all_completions);
318: defsubr (&Sfile_attributes);
319:
320: DefLispVar ("completion-ignored-extensions", &Vcompletion_ignored_extensions,
321: "*Completion ignores filenames ending in any string in this list.");
322: Vcompletion_ignored_extensions = Qnil;
323: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.