![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to commands.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / bird / client|
Return to commands.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / bird / client |
1.1 misho 1: /*
2: * BIRD Client -- Command Handling
3: *
4: * (c) 1999--2000 Martin Mares <mj@ucw.cz>
5: *
6: * Can be freely distributed and used under the terms of the GNU GPL.
7: */
8:
9: #include <stdio.h>
10: #include <ctype.h>
11: #include <stdlib.h>
12:
13: #include "nest/bird.h"
14: #include "lib/resource.h"
15: #include "lib/string.h"
16: #include "client/client.h"
17:
18: struct cmd_info {
19: char *command;
20: char *args;
21: char *help;
22: int is_real_cmd;
23: };
24:
25: static struct cmd_info command_table[] = {
26: #include "conf/commands.h"
27: };
28:
29: struct cmd_node {
30: struct cmd_node *sibling, *son, **plastson;
31: struct cmd_info *cmd, *help;
32: int len;
33: signed char prio;
34: char token[1];
35: };
36:
37: static struct cmd_node cmd_root;
38:
39: void
40: cmd_build_tree(void)
41: {
42: uint i;
43:
44: cmd_root.plastson = &cmd_root.son;
45:
46: for(i=0; i<ARRAY_SIZE(command_table); i++)
47: {
48: struct cmd_info *cmd = &command_table[i];
49: struct cmd_node *old, *new;
50: char *c = cmd->command;
51:
52: old = &cmd_root;
53: while (*c)
54: {
55: char *d = c;
56: while (*c && !isspace(*c))
57: c++;
58: for(new=old->son; new; new=new->sibling)
59: if (new->len == c-d && !memcmp(new->token, d, c-d))
60: break;
61: if (!new)
62: {
63: int size = sizeof(struct cmd_node) + c-d;
64: new = malloc(size);
65: bzero(new, size);
66: *old->plastson = new;
67: old->plastson = &new->sibling;
68: new->plastson = &new->son;
69: new->len = c-d;
70: memcpy(new->token, d, c-d);
71: new->prio = (new->len == 3 && (!memcmp(new->token, "roa", 3) || !memcmp(new->token, "rip", 3))) ? 0 : 1; /* Hack */
72: }
73: old = new;
74: while (isspace(*c))
75: c++;
76: }
77: if (cmd->is_real_cmd)
78: old->cmd = cmd;
79: else
80: old->help = cmd;
81: }
82: }
83:
84: static void
85: cmd_do_display_help(struct cmd_info *c)
86: {
87: char buf[strlen(c->command) + strlen(c->args) + 4];
88:
89: sprintf(buf, "%s %s", c->command, c->args);
90: printf("%-45s %s\n", buf, c->help);
91: }
92:
93: static void
94: cmd_display_help(struct cmd_info *c1, struct cmd_info *c2)
95: {
96: if (c1)
97: cmd_do_display_help(c1);
98: else if (c2)
99: cmd_do_display_help(c2);
100: }
101:
102: static struct cmd_node *
103: cmd_find_abbrev(struct cmd_node *root, char *cmd, int len, int *pambiguous)
104: {
105: struct cmd_node *m, *best = NULL, *best2 = NULL;
106:
107: *pambiguous = 0;
108: for(m=root->son; m; m=m->sibling)
109: {
110: if (m->len == len && !memcmp(m->token, cmd, len))
111: return m;
112: if (m->len > len && !memcmp(m->token, cmd, len))
113: {
114: if (best && best->prio > m->prio)
115: continue;
116: if (best && best->prio == m->prio)
117: best2 = best;
118: best = m;
119: }
120: }
121: if (best2)
122: {
123: *pambiguous = 1;
124: return NULL;
125: }
126: return best;
127: }
128:
129: static void
130: cmd_list_ambiguous(struct cmd_node *root, char *cmd, int len)
131: {
132: struct cmd_node *m;
133:
134: for(m=root->son; m; m=m->sibling)
135: if (m->len > len && !memcmp(m->token, cmd, len))
136: cmd_display_help(m->help, m->cmd);
137: }
138:
139: void
140: cmd_help(char *cmd, int len)
141: {
142: char *end = cmd + len;
143: struct cmd_node *n, *m;
144: char *z;
145: int ambig;
146:
147: n = &cmd_root;
148: while (cmd < end)
149: {
150: if (isspace(*cmd))
151: {
152: cmd++;
153: continue;
154: }
155: z = cmd;
156: while (cmd < end && !isspace(*cmd))
157: cmd++;
158: m = cmd_find_abbrev(n, z, cmd-z, &ambig);
159: if (ambig)
160: {
161: cmd_list_ambiguous(n, z, cmd-z);
162: return;
163: }
164: if (!m)
165: break;
166: n = m;
167: }
168: cmd_display_help(n->cmd, NULL);
169: for (m=n->son; m; m=m->sibling)
170: cmd_display_help(m->help, m->cmd);
171: }
172:
173: static int
174: cmd_find_common_match(struct cmd_node *root, char *cmd, int len, int *pcount, char *buf)
175: {
176: struct cmd_node *m;
177: int best, best_prio, i;
178:
179: *pcount = 0;
180: best = -1;
181: best_prio = -1;
182: for(m=root->son; m; m=m->sibling)
183: {
184: if (m->len < len || memcmp(m->token, cmd, len))
185: continue;
186:
187: if (best_prio > m->prio)
188: continue;
189:
190: if (best_prio < m->prio)
191: {
192: *pcount = 0;
193: best = -1;
194: }
195:
196: (*pcount)++;
197: if (best < 0)
198: {
199: strcpy(buf, m->token + len);
200: best = m->len - len;
201: best_prio = m->prio;
202: }
203: else
204: {
205: i = 0;
206: while (i < best && i < m->len - len && buf[i] == m->token[len+i])
207: i++;
208: best = i;
209: }
210: }
211: return best;
212: }
213:
214: int
215: cmd_complete(char *cmd, int len, char *buf, int again)
216: {
217: char *start = cmd;
218: char *end = cmd + len;
219: char *fin;
220: struct cmd_node *n, *m;
221: char *z;
222: int ambig, cnt = 0, common;
223:
224: /* Find the last word we want to complete */
225: for(fin=end; fin > start && !isspace(fin[-1]); fin--)
226: ;
227:
228: /* Find the context */
229: n = &cmd_root;
230: while (cmd < fin && n->son)
231: {
232: if (isspace(*cmd))
233: {
234: cmd++;
235: continue;
236: }
237: z = cmd;
238: while (cmd < fin && !isspace(*cmd))
239: cmd++;
240: m = cmd_find_abbrev(n, z, cmd-z, &ambig);
241: if (ambig)
242: {
243: if (!again)
244: return -1;
245: input_start_list();
246: cmd_list_ambiguous(n, z, cmd-z);
247: input_stop_list();
248: return 0;
249: }
250: if (!m)
251: return -1;
252: n = m;
253: }
254:
255: /* Completion of parameters is not yet supported */
256: if (!n->son)
257: return -1;
258:
259: /* We know the context, let's try to complete */
260: common = cmd_find_common_match(n, fin, end-fin, &cnt, buf);
261: if (!cnt)
262: return -1;
263: if (cnt == 1)
264: {
265: buf[common++] = ' ';
266: buf[common] = 0;
267: return 1;
268: }
269: if (common > 0)
270: {
271: buf[common] = 0;
272: return 1;
273: }
274: if (!again)
275: return -1;
276: input_start_list();
277: cmd_list_ambiguous(n, fin, end-fin);
278: input_stop_list();
279: return 0;
280: }
281:
282: char *
283: cmd_expand(char *cmd)
284: {
285: struct cmd_node *n, *m;
286: char *c, *b, *args;
287: int ambig;
288:
289: args = c = cmd;
290: n = &cmd_root;
291: while (*c)
292: {
293: if (isspace(*c))
294: {
295: c++;
296: continue;
297: }
298: b = c;
299: while (*c && !isspace(*c))
300: c++;
301: m = cmd_find_abbrev(n, b, c-b, &ambig);
302: if (!m)
303: {
304: if (!ambig)
305: break;
306: puts("Ambiguous command, possible expansions are:");
307: cmd_list_ambiguous(n, b, c-b);
308: return NULL;
309: }
310: args = c;
311: n = m;
312: }
313: if (!n->cmd)
314: {
315: puts("No such command. Press `?' for help.");
316: return NULL;
317: }
318: b = malloc(strlen(n->cmd->command) + strlen(args) + 1);
319: sprintf(b, "%s%s", n->cmd->command, args);
320: return b;
321: }