![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cmd.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sys / tahoestand / vdformat|
Return to cmd.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / tahoestand / vdformat |
1.1 root 1: /* cmd.c 1.2 86/11/04 */
2:
3: #include "vdfmt.h"
4: #include "cmd.h"
5:
6: #define TRUE 1
7: #define FALSE 0
8:
9: #define HELP 1
10: #define STATUS 2
11: #define KILL 3
12: #define KQUIT 4
13:
14: static cmd_text_element primary[] = {
15: { STATUS, "!", "" },
16: { HELP, "HElp", "" },
17: { KILL, "KILL", "" },
18: { KQUIT, "QUIT", "" },
19: { STATUS, "STATus", "" },
20: { HELP, "?", "" },
21: { 0, "", "" }
22: };
23:
24:
25: /*
26: */
27:
28: boolean confirm(token)
29: int token;
30: {
31: char *action;
32: char query[50];
33:
34: if(token == KILL)
35: action = "kill";
36: else
37: action = "quit";
38: sprintf(query, "Confirm %s operations", action);
39: return get_yes_no(query);
40: }
41:
42:
43: /*
44: **
45: */
46:
47: get_text_cmd(table, tokens)
48: cmd_text_element *table;
49: int *tokens;
50: {
51: extern boolean get_yes_no();
52: int *t_ptr;
53: char line[133];
54:
55: agets(line);
56: /* Check for help, status, or kill */
57: cmd_parse(primary, line, tokens);
58: t_ptr = tokens;
59: while(*t_ptr) {
60: switch (*t_ptr) {
61: case STATUS :
62: cmd_status();
63: break;
64: case KQUIT :
65: case KILL :
66: if(confirm(*t_ptr) == true) {
67: kill_processes = true;
68: return 0;
69: }
70: break;
71: default:
72: help_text(table);
73: break;
74: }
75: t_ptr++;
76: }
77: /* Now parse all the operator's commands */
78: cmd_parse(table, line, tokens);
79: return strlen(line);
80: }
81:
82:
83: /*
84: **
85: */
86:
87: cmd_intcmp(a, b)
88: int *a, *b;
89: {
90: if(*a==*b)
91: return 0;
92: if(*a<*b)
93: return -1;
94: return 1;
95: }
96:
97:
98: /*
99: **
100: */
101:
102: condition_list(tokens, sentinal)
103: int *tokens, sentinal;
104: {
105: register int *t_ptr = tokens;
106: register int num_tok;
107:
108: for(num_tok=0; *t_ptr++ != sentinal; num_tok++)
109: ;
110: qsort(tokens, num_tok, sizeof(int), cmd_intcmp);
111: /* compress out dups */
112: while(*tokens != sentinal) {
113: if(*tokens == *(tokens+1)) {
114: for(t_ptr=tokens+1; *t_ptr != sentinal; t_ptr++) {
115: *t_ptr = *(t_ptr+1);
116: }
117: continue;
118: }
119: tokens++;
120: }
121: }
122:
123:
124: /*
125: **
126: */
127:
128: cmd_parse(table, line, tokens)
129: cmd_text_element *table;
130: char *line;
131: int *tokens;
132: {
133: char *seperators = "\t ,.;:-~+/\\";
134: register char *tok_start;
135: register int *tok = tokens;
136: char save_buf[133];
137:
138: strcpy(save_buf, line);
139: tok_start = (char *)strtok((char *)save_buf, seperators);
140: while(tok_start != NULL) {
141: if(strlen(tok_start)) {
142: if(*tok = cmd_search(table, tok_start)) {
143: tok++;
144: }
145: }
146: tok_start = (char *)strtok((char *)NULL, seperators);
147: }
148: *tok = 0;
149: condition_list(tokens, 0);
150: }
151:
152:
153: /*
154: **
155: */
156:
157: cmd_search(table, command)
158: cmd_text_element *table;
159: char *command;
160: {
161: register char *tbl_ptr;
162: register char *cmd_ptr;
163:
164: while(table->cmd_token != 0) {
165: cmd_ptr = command;
166: tbl_ptr = table->cmd_text;
167: while(ismustmatch(*tbl_ptr)) {
168: if(toupper(*cmd_ptr) != *tbl_ptr)
169: break;
170: cmd_ptr++;
171: tbl_ptr++;
172: }
173: if((*tbl_ptr == 0) || !ismustmatch(*tbl_ptr))
174: return table->cmd_token;
175: table++;
176: }
177: return 0;
178: }
179:
180:
181: /*
182: **
183: */
184:
185: is_in_digit_table(table, token)
186: int *table, token;
187: {
188: while(*table != -1) {
189: if(token == *table)
190: return TRUE;
191: table++;
192: }
193: return FALSE;
194: }
195:
196:
197: /*
198: **
199: */
200:
201: int *fill_in(tokens, table, start, end)
202: int *tokens, *table, start, end;
203: {
204:
205: if(start > end) {
206: register int temp = end;
207:
208: end = start;
209: start = temp;
210: }
211: while((*table != -1) && (*table < start))
212: table++;
213: while((*table != -1) && (*table <= end)) {
214: *tokens++ = *table++;
215: }
216: return tokens;
217: }
218:
219: /*
220: **
221: */
222:
223: get_digit_list(tokens, table, help)
224: int *tokens, *table, (*help)();
225: {
226: int *tok_ptr;
227: char *ptr, line[133];
228:
229: condition_list(table, -1);
230: agets(line);
231: if(!line[0]) {
232: *tokens = -1;
233: return;
234: }
235: /* Check for help, status, or kill */
236: cmd_parse(primary, line, tokens);
237: tok_ptr = tokens;
238: while(*tok_ptr) {
239: switch (*tok_ptr) {
240: case STATUS :
241: cmd_status();
242: break;
243: case KQUIT :
244: case KILL :
245: if(confirm(*tok_ptr)) {
246: kill_processes = true;
247: return;
248: }
249: break;
250: default:
251: (help)();
252: break;
253: }
254: tok_ptr++;
255: }
256: tok_ptr = tokens;
257: ptr = line;
258: while(*ptr) {
259: finddigit(ptr);
260: if(sscanf(ptr, "%d", tok_ptr) > 0) {
261: skipdigits(ptr);
262: skip_junk(ptr);
263: if((*ptr == '~') || (*ptr == '-')) {
264: register int start = *tok_ptr;
265:
266: finddigit(ptr);
267: if(sscanf(ptr, "%d", tok_ptr) > 0) {
268: skipdigits(ptr);
269: tok_ptr = fill_in(tok_ptr,
270: table, start, *tok_ptr);
271: continue;
272: }
273: else
274: *tok_ptr = start;
275: }
276: if(is_in_digit_table(table, *tok_ptr))
277: tok_ptr++;
278: }
279: }
280: *tok_ptr = -1;
281: condition_list(tokens, -1);
282: }
283:
284:
285:
286: /*
287: **
288: */
289:
290: get_digit_cmd(help)
291: int (*help)();
292: {
293: int tokens[20], *t_ptr;
294: char line[80];
295: int results;
296:
297: agets(line);
298: if(!*line)
299: return -1;
300: /* Check for help, status, or kill */
301: cmd_parse(primary, line, tokens);
302: t_ptr = tokens;
303: while(*t_ptr) {
304: switch (*t_ptr) {
305: case STATUS :
306: cmd_status();
307: break;
308: case KQUIT :
309: case KILL :
310: if(confirm(*t_ptr)) {
311: kill_processes = true;
312: return -1;
313: }
314: break;
315: default:
316: (*help)();
317: break;
318: }
319: t_ptr++;
320: }
321: if(sscanf(line, "%d", &results) > 0)
322: return results;
323: return -1;
324: }
325:
326:
327: /*
328: **
329: */
330:
331: get_string_cmd(line, help)
332: char *line;
333: int (*help)();
334: {
335: int tokens[20], *t_ptr;
336:
337: agets(line);
338: if(!*line)
339: return;
340: /* Check for help, status, or kill */
341: cmd_parse(primary, line, tokens);
342: t_ptr = tokens;
343: while(*t_ptr) {
344: switch (*t_ptr) {
345: case STATUS :
346: cmd_status();
347: break;
348: case KQUIT :
349: case KILL :
350: if(confirm(*t_ptr)) {
351: kill_processes = true;
352: return;
353: }
354: break;
355: default:
356: (*help)();
357: break;
358: }
359: t_ptr++;
360: }
361: while(*line) {
362: *line = tolower(*line);
363: line++;
364: }
365: return;
366: }
367:
368:
369: /*
370: **
371: */
372:
373: cmd_status()
374: {
375: indent();
376: switch (cur.state) {
377: case cmd :
378: print("Waiting for operator input.\n\n");
379: break;
380: default :
381: status();
382: break;
383: }
384: exdent(1);
385: }
386:
387:
388: /*
389: ** Vdget_yes_no is used to ask simple yes or no questions. The question
390: ** prompt is supplied by the caller, The question mark, possible responses,
391: ** and the default response is printed at the end of the prompt. The routine
392: ** then reads the answer and returns a 1 if a 'y' is typed or no response was
393: ** given, otherwise, a zero is returned.
394: */
395:
396: boolean get_yes_no(str)
397: register char *str;
398: {
399: extern int wait_for_char;
400: char answer[80];
401: boolean retval;
402: int old_wait_status = wait_for_char;
403:
404: wait_for_char = 1;
405: for(;;) {
406: if(*str)
407: print("%s", str);
408: printf("? [Yes/No] ");
409: agets(answer);
410: if((answer[0] == 'Y') || (answer[0] == 'y')) {
411: retval = true;
412: break;
413: }
414: if((answer[0] == 'N') || (answer[0] == 'n')) {
415: retval = false;
416: break;
417: }
418: print("\n");
419: print("A 'Yes' or 'No' must be entered!\n\n");
420: }
421: wait_for_char = old_wait_status;
422: return retval;
423: }
424:
425:
426: /*
427: **
428: */
429:
430: get_next_digit(ptr)
431: char *ptr;
432: {
433: int results;
434:
435: finddigit(ptr);
436: if(sscanf(ptr, "%d", &results) <= 0)
437: return -1;
438: return results;
439: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.