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
confirm(token)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
get_text_cmd(table,tokens)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
cmd_intcmp(a,b)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
condition_list(tokens,sentinal)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
cmd_parse(table,line,tokens)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
cmd_search(table,command)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
is_in_digit_table(table,token)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
fill_in(tokens,table,start,end)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
get_string_cmd(line,help)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
cmd_status()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
get_yes_no(str)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
get_next_digit(ptr)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 }
440