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