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