Annotation of embedaddon/readline/examples/fileman.c, revision 1.1.1.1
1.1 misho 1: /* fileman.c - file manager example for readline library. */
2:
3: /* Copyright (C) 1987-2009 Free Software Foundation, Inc.
4:
5: This file is part of the GNU Readline Library (Readline), a library for
6: reading lines of text with interactive input and history editing.
7:
8: Readline is free software: you can redistribute it and/or modify
9: it under the terms of the GNU General Public License as published by
10: the Free Software Foundation, either version 3 of the License, or
11: (at your option) any later version.
12:
13: Readline is distributed in the hope that it will be useful,
14: but WITHOUT ANY WARRANTY; without even the implied warranty of
15: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16: GNU General Public License for more details.
17:
18: You should have received a copy of the GNU General Public License
19: along with Readline. If not, see <http://www.gnu.org/licenses/>.
20: */
21:
22: /* fileman.c -- A tiny application which demonstrates how to use the
23: GNU Readline library. This application interactively allows users
24: to manipulate files and their modes. */
25:
26: #ifdef HAVE_CONFIG_H
27: # include <config.h>
28: #endif
29:
30: #include <sys/types.h>
31: #ifdef HAVE_SYS_FILE_H
32: # include <sys/file.h>
33: #endif
34: #include <sys/stat.h>
35:
36: #ifdef HAVE_UNISTD_H
37: # include <unistd.h>
38: #endif
39:
40: #include <fcntl.h>
41: #include <stdio.h>
42: #include <errno.h>
43:
44: #if defined (HAVE_STRING_H)
45: # include <string.h>
46: #else /* !HAVE_STRING_H */
47: # include <strings.h>
48: #endif /* !HAVE_STRING_H */
49:
50: #ifdef HAVE_STDLIB_H
51: # include <stdlib.h>
52: #endif
53:
54: #include <time.h>
55:
56: #ifdef READLINE_LIBRARY
57: # include "readline.h"
58: # include "history.h"
59: #else
60: # include <readline/readline.h>
61: # include <readline/history.h>
62: #endif
63:
64: extern char *xmalloc PARAMS((size_t));
65:
66: /* The names of functions that actually do the manipulation. */
67: int com_list PARAMS((char *));
68: int com_view PARAMS((char *));
69: int com_rename PARAMS((char *));
70: int com_stat PARAMS((char *));
71: int com_pwd PARAMS((char *));
72: int com_delete PARAMS((char *));
73: int com_help PARAMS((char *));
74: int com_cd PARAMS((char *));
75: int com_quit PARAMS((char *));
76:
77: /* A structure which contains information on the commands this program
78: can understand. */
79:
80: typedef struct {
81: char *name; /* User printable name of the function. */
82: rl_icpfunc_t *func; /* Function to call to do the job. */
83: char *doc; /* Documentation for this function. */
84: } COMMAND;
85:
86: COMMAND commands[] = {
87: { "cd", com_cd, "Change to directory DIR" },
88: { "delete", com_delete, "Delete FILE" },
89: { "help", com_help, "Display this text" },
90: { "?", com_help, "Synonym for `help'" },
91: { "list", com_list, "List files in DIR" },
92: { "ls", com_list, "Synonym for `list'" },
93: { "pwd", com_pwd, "Print the current working directory" },
94: { "quit", com_quit, "Quit using Fileman" },
95: { "rename", com_rename, "Rename FILE to NEWNAME" },
96: { "stat", com_stat, "Print out statistics on FILE" },
97: { "view", com_view, "View the contents of FILE" },
98: { (char *)NULL, (rl_icpfunc_t *)NULL, (char *)NULL }
99: };
100:
101: /* Forward declarations. */
102: char *stripwhite ();
103: COMMAND *find_command ();
104:
105: /* The name of this program, as taken from argv[0]. */
106: char *progname;
107:
108: /* When non-zero, this global means the user is done using this program. */
109: int done;
110:
111: char *
112: dupstr (s)
113: char *s;
114: {
115: char *r;
116:
117: r = xmalloc (strlen (s) + 1);
118: strcpy (r, s);
119: return (r);
120: }
121:
122: main (argc, argv)
123: int argc;
124: char **argv;
125: {
126: char *line, *s;
127:
128: progname = argv[0];
129:
130: initialize_readline (); /* Bind our completer. */
131:
132: /* Loop reading and executing lines until the user quits. */
133: for ( ; done == 0; )
134: {
135: line = readline ("FileMan: ");
136:
137: if (!line)
138: break;
139:
140: /* Remove leading and trailing whitespace from the line.
141: Then, if there is anything left, add it to the history list
142: and execute it. */
143: s = stripwhite (line);
144:
145: if (*s)
146: {
147: add_history (s);
148: execute_line (s);
149: }
150:
151: free (line);
152: }
153: exit (0);
154: }
155:
156: /* Execute a command line. */
157: int
158: execute_line (line)
159: char *line;
160: {
161: register int i;
162: COMMAND *command;
163: char *word;
164:
165: /* Isolate the command word. */
166: i = 0;
167: while (line[i] && whitespace (line[i]))
168: i++;
169: word = line + i;
170:
171: while (line[i] && !whitespace (line[i]))
172: i++;
173:
174: if (line[i])
175: line[i++] = '\0';
176:
177: command = find_command (word);
178:
179: if (!command)
180: {
181: fprintf (stderr, "%s: No such command for FileMan.\n", word);
182: return (-1);
183: }
184:
185: /* Get argument to command, if any. */
186: while (whitespace (line[i]))
187: i++;
188:
189: word = line + i;
190:
191: /* Call the function. */
192: return ((*(command->func)) (word));
193: }
194:
195: /* Look up NAME as the name of a command, and return a pointer to that
196: command. Return a NULL pointer if NAME isn't a command name. */
197: COMMAND *
198: find_command (name)
199: char *name;
200: {
201: register int i;
202:
203: for (i = 0; commands[i].name; i++)
204: if (strcmp (name, commands[i].name) == 0)
205: return (&commands[i]);
206:
207: return ((COMMAND *)NULL);
208: }
209:
210: /* Strip whitespace from the start and end of STRING. Return a pointer
211: into STRING. */
212: char *
213: stripwhite (string)
214: char *string;
215: {
216: register char *s, *t;
217:
218: for (s = string; whitespace (*s); s++)
219: ;
220:
221: if (*s == 0)
222: return (s);
223:
224: t = s + strlen (s) - 1;
225: while (t > s && whitespace (*t))
226: t--;
227: *++t = '\0';
228:
229: return s;
230: }
231:
232: /* **************************************************************** */
233: /* */
234: /* Interface to Readline Completion */
235: /* */
236: /* **************************************************************** */
237:
238: char *command_generator PARAMS((const char *, int));
239: char **fileman_completion PARAMS((const char *, int, int));
240:
241: /* Tell the GNU Readline library how to complete. We want to try to complete
242: on command names if this is the first word in the line, or on filenames
243: if not. */
244: initialize_readline ()
245: {
246: /* Allow conditional parsing of the ~/.inputrc file. */
247: rl_readline_name = "FileMan";
248:
249: /* Tell the completer that we want a crack first. */
250: rl_attempted_completion_function = fileman_completion;
251: }
252:
253: /* Attempt to complete on the contents of TEXT. START and END bound the
254: region of rl_line_buffer that contains the word to complete. TEXT is
255: the word to complete. We can use the entire contents of rl_line_buffer
256: in case we want to do some simple parsing. Return the array of matches,
257: or NULL if there aren't any. */
258: char **
259: fileman_completion (text, start, end)
260: const char *text;
261: int start, end;
262: {
263: char **matches;
264:
265: matches = (char **)NULL;
266:
267: /* If this word is at the start of the line, then it is a command
268: to complete. Otherwise it is the name of a file in the current
269: directory. */
270: if (start == 0)
271: matches = rl_completion_matches (text, command_generator);
272:
273: return (matches);
274: }
275:
276: /* Generator function for command completion. STATE lets us know whether
277: to start from scratch; without any state (i.e. STATE == 0), then we
278: start at the top of the list. */
279: char *
280: command_generator (text, state)
281: const char *text;
282: int state;
283: {
284: static int list_index, len;
285: char *name;
286:
287: /* If this is a new word to complete, initialize now. This includes
288: saving the length of TEXT for efficiency, and initializing the index
289: variable to 0. */
290: if (!state)
291: {
292: list_index = 0;
293: len = strlen (text);
294: }
295:
296: /* Return the next name which partially matches from the command list. */
297: while (name = commands[list_index].name)
298: {
299: list_index++;
300:
301: if (strncmp (name, text, len) == 0)
302: return (dupstr(name));
303: }
304:
305: /* If no names matched, then return NULL. */
306: return ((char *)NULL);
307: }
308:
309: /* **************************************************************** */
310: /* */
311: /* FileMan Commands */
312: /* */
313: /* **************************************************************** */
314:
315: /* String to pass to system (). This is for the LIST, VIEW and RENAME
316: commands. */
317: static char syscom[1024];
318:
319: /* List the file(s) named in arg. */
320: com_list (arg)
321: char *arg;
322: {
323: if (!arg)
324: arg = "";
325:
326: sprintf (syscom, "ls -FClg %s", arg);
327: return (system (syscom));
328: }
329:
330: com_view (arg)
331: char *arg;
332: {
333: if (!valid_argument ("view", arg))
334: return 1;
335:
336: #if defined (__MSDOS__)
337: /* more.com doesn't grok slashes in pathnames */
338: sprintf (syscom, "less %s", arg);
339: #else
340: sprintf (syscom, "more %s", arg);
341: #endif
342: return (system (syscom));
343: }
344:
345: com_rename (arg)
346: char *arg;
347: {
348: too_dangerous ("rename");
349: return (1);
350: }
351:
352: com_stat (arg)
353: char *arg;
354: {
355: struct stat finfo;
356:
357: if (!valid_argument ("stat", arg))
358: return (1);
359:
360: if (stat (arg, &finfo) == -1)
361: {
362: perror (arg);
363: return (1);
364: }
365:
366: printf ("Statistics for `%s':\n", arg);
367:
368: printf ("%s has %d link%s, and is %d byte%s in length.\n",
369: arg,
370: finfo.st_nlink,
371: (finfo.st_nlink == 1) ? "" : "s",
372: finfo.st_size,
373: (finfo.st_size == 1) ? "" : "s");
374: printf ("Inode Last Change at: %s", ctime (&finfo.st_ctime));
375: printf (" Last access at: %s", ctime (&finfo.st_atime));
376: printf (" Last modified at: %s", ctime (&finfo.st_mtime));
377: return (0);
378: }
379:
380: com_delete (arg)
381: char *arg;
382: {
383: too_dangerous ("delete");
384: return (1);
385: }
386:
387: /* Print out help for ARG, or for all of the commands if ARG is
388: not present. */
389: com_help (arg)
390: char *arg;
391: {
392: register int i;
393: int printed = 0;
394:
395: for (i = 0; commands[i].name; i++)
396: {
397: if (!*arg || (strcmp (arg, commands[i].name) == 0))
398: {
399: printf ("%s\t\t%s.\n", commands[i].name, commands[i].doc);
400: printed++;
401: }
402: }
403:
404: if (!printed)
405: {
406: printf ("No commands match `%s'. Possibilties are:\n", arg);
407:
408: for (i = 0; commands[i].name; i++)
409: {
410: /* Print in six columns. */
411: if (printed == 6)
412: {
413: printed = 0;
414: printf ("\n");
415: }
416:
417: printf ("%s\t", commands[i].name);
418: printed++;
419: }
420:
421: if (printed)
422: printf ("\n");
423: }
424: return (0);
425: }
426:
427: /* Change to the directory ARG. */
428: com_cd (arg)
429: char *arg;
430: {
431: if (chdir (arg) == -1)
432: {
433: perror (arg);
434: return 1;
435: }
436:
437: com_pwd ("");
438: return (0);
439: }
440:
441: /* Print out the current working directory. */
442: com_pwd (ignore)
443: char *ignore;
444: {
445: char dir[1024], *s;
446:
447: s = getcwd (dir, sizeof(dir) - 1);
448: if (s == 0)
449: {
450: printf ("Error getting pwd: %s\n", dir);
451: return 1;
452: }
453:
454: printf ("Current directory is %s\n", dir);
455: return 0;
456: }
457:
458: /* The user wishes to quit using this program. Just set DONE non-zero. */
459: com_quit (arg)
460: char *arg;
461: {
462: done = 1;
463: return (0);
464: }
465:
466: /* Function which tells you that you can't do this. */
467: too_dangerous (caller)
468: char *caller;
469: {
470: fprintf (stderr,
471: "%s: Too dangerous for me to distribute. Write it yourself.\n",
472: caller);
473: }
474:
475: /* Return non-zero if ARG is a valid argument for CALLER, else print
476: an error message and return zero. */
477: int
478: valid_argument (caller, arg)
479: char *caller, *arg;
480: {
481: if (!arg || !*arg)
482: {
483: fprintf (stderr, "%s: Argument required.\n", caller);
484: return (0);
485: }
486:
487: return (1);
488: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to fileman.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / readline / examples