1 /*- 2 * Copyright (c) 1990, 1993 3 * The Regents of the University of California. All rights reserved. 4 * 5 * This code is derived from software contributed to Berkeley by 6 * Ed James. 7 * 8 * %sccs.include.redist.c% 9 */ 10 11 /* 12 * Copyright (c) 1987 by Ed James, UC Berkeley. All rights reserved. 13 * 14 * Copy permission is hereby granted provided that this notice is 15 * retained on all partial or complete copies. 16 * 17 * For more info on this and all of my stuff, mail edjames@berkeley.edu. 18 */ 19 20 #ifndef lint 21 static char sccsid[] = "@(#)input.c 8.1 (Berkeley) 05/31/93"; 22 #endif not lint 23 24 #include "include.h" 25 #include "pathnames.h" 26 27 #define MAXRULES 6 28 #define MAXDEPTH 15 29 30 #define RETTOKEN '\n' 31 #ifdef SYSV 32 #define CRTOKEN '\r' 33 #endif 34 #define REDRAWTOKEN '\014' /* CTRL(L) */ 35 #define SHELLTOKEN '!' 36 #define HELPTOKEN '?' 37 #define ALPHATOKEN 256 38 #define NUMTOKEN 257 39 40 typedef struct { 41 int token; 42 int to_state; 43 char *str; 44 char *(*func)(); 45 } RULE; 46 47 typedef struct { 48 int num_rules; 49 RULE *rule; 50 } STATE; 51 52 typedef struct { 53 char str[20]; 54 int state; 55 int rule; 56 int ch; 57 int pos; 58 } STACK; 59 60 #define T_RULE stack[level].rule 61 #define T_STATE stack[level].state 62 #define T_STR stack[level].str 63 #define T_POS stack[level].pos 64 #define T_CH stack[level].ch 65 66 #define NUMELS(a) (sizeof (a) / sizeof (*(a))) 67 68 #define NUMSTATES NUMELS(st) 69 70 char *setplane(), *circle(), *left(), *right(), *Left(), *Right(), 71 *beacon(), *ex_it(), *climb(), *descend(), *setalt(), *setrelalt(), 72 *benum(), *to_dir(), *rel_dir(), *delayb(), *mark(), *unmark(), 73 *airport(), *turn(), *ignore(); 74 75 RULE state0[] = { { ALPHATOKEN, 1, "%c:", setplane}, 76 { RETTOKEN, -1, "", NULL }, 77 #ifdef SYSV 78 { CRTOKEN, -1, "", NULL }, 79 #endif 80 { HELPTOKEN, 12, " [a-z]<ret>", NULL }}, 81 state1[] = { { 't', 2, " turn", turn }, 82 { 'a', 3, " altitude:", NULL }, 83 { 'c', 4, " circle", circle }, 84 { 'm', 7, " mark", mark }, 85 { 'u', 7, " unmark", unmark }, 86 { 'i', 7, " ignore", ignore }, 87 { HELPTOKEN, 12, " tacmui", NULL }}, 88 state2[] = { { 'l', 6, " left", left }, 89 { 'r', 6, " right", right }, 90 { 'L', 4, " left 90", Left }, 91 { 'R', 4, " right 90", Right }, 92 { 't', 11, " towards", NULL }, 93 { 'w', 4, " to 0", to_dir }, 94 { 'e', 4, " to 45", to_dir }, 95 { 'd', 4, " to 90", to_dir }, 96 { 'c', 4, " to 135", to_dir }, 97 { 'x', 4, " to 180", to_dir }, 98 { 'z', 4, " to 225", to_dir }, 99 { 'a', 4, " to 270", to_dir }, 100 { 'q', 4, " to 315", to_dir }, 101 { HELPTOKEN, 12, " lrLRt<dir>", NULL }}, 102 state3[] = { { '+', 10, " climb", climb }, 103 { 'c', 10, " climb", climb }, 104 { '-', 10, " descend", descend }, 105 { 'd', 10, " descend", descend }, 106 { NUMTOKEN, 7, " %c000 feet", setalt }, 107 { HELPTOKEN, 12, " +-cd[0-9]", NULL }}, 108 state4[] = { { '@', 9, " at", NULL }, 109 { 'a', 9, " at", NULL }, 110 { RETTOKEN, -1, "", NULL }, 111 #ifdef SYSV 112 { CRTOKEN, -1, "", NULL }, 113 #endif 114 { HELPTOKEN, 12, " @a<ret>", NULL }}, 115 state5[] = { { NUMTOKEN, 7, "%c", delayb }, 116 { HELPTOKEN, 12, " [0-9]", NULL }}, 117 state6[] = { { '@', 9, " at", NULL }, 118 { 'a', 9, " at", NULL }, 119 { 'w', 4, " 0", rel_dir }, 120 { 'e', 4, " 45", rel_dir }, 121 { 'd', 4, " 90", rel_dir }, 122 { 'c', 4, " 135", rel_dir }, 123 { 'x', 4, " 180", rel_dir }, 124 { 'z', 4, " 225", rel_dir }, 125 { 'a', 4, " 270", rel_dir }, 126 { 'q', 4, " 315", rel_dir }, 127 { RETTOKEN, -1, "", NULL }, 128 #ifdef SYSV 129 { CRTOKEN, -1, "", NULL }, 130 #endif 131 { HELPTOKEN, 12, " @a<dir><ret>",NULL }}, 132 state7[] = { { RETTOKEN, -1, "", NULL }, 133 #ifdef SYSV 134 { CRTOKEN, -1, "", NULL }, 135 #endif 136 { HELPTOKEN, 12, " <ret>", NULL }}, 137 state8[] = { { NUMTOKEN, 4, "%c", benum }, 138 { HELPTOKEN, 12, " [0-9]", NULL }}, 139 state9[] = { { 'b', 5, " beacon #", NULL }, 140 { '*', 5, " beacon #", NULL }, 141 { HELPTOKEN, 12, " b*", NULL }}, 142 state10[] = { { NUMTOKEN, 7, " %c000 ft", setrelalt}, 143 { HELPTOKEN, 12, " [0-9]", NULL }}, 144 state11[] = { { 'b', 8, " beacon #", beacon }, 145 { '*', 8, " beacon #", beacon }, 146 { 'e', 8, " exit #", ex_it }, 147 { 'a', 8, " airport #", airport }, 148 { HELPTOKEN, 12, " b*ea", NULL }}, 149 state12[] = { { -1, -1, "", NULL }}; 150 151 #define DEF_STATE(s) { NUMELS(s), (s) } 152 153 STATE st[] = { 154 DEF_STATE(state0), DEF_STATE(state1), DEF_STATE(state2), 155 DEF_STATE(state3), DEF_STATE(state4), DEF_STATE(state5), 156 DEF_STATE(state6), DEF_STATE(state7), DEF_STATE(state8), 157 DEF_STATE(state9), DEF_STATE(state10), DEF_STATE(state11), 158 DEF_STATE(state12) 159 }; 160 161 PLANE p; 162 STACK stack[MAXDEPTH]; 163 int level; 164 int tval; 165 int dest_type, dest_no, dir; 166 167 pop() 168 { 169 if (level == 0) 170 return (-1); 171 level--; 172 173 ioclrtoeol(T_POS); 174 175 strcpy(T_STR, ""); 176 T_RULE = -1; 177 T_CH = -1; 178 return (0); 179 } 180 181 rezero() 182 { 183 iomove(0); 184 185 level = 0; 186 T_STATE = 0; 187 T_RULE = -1; 188 T_CH = -1; 189 T_POS = 0; 190 strcpy(T_STR, ""); 191 } 192 193 push(ruleno, ch) 194 { 195 int newstate, newpos; 196 197 (void)sprintf(T_STR, st[T_STATE].rule[ruleno].str, tval); 198 T_RULE = ruleno; 199 T_CH = ch; 200 newstate = st[T_STATE].rule[ruleno].to_state; 201 newpos = T_POS + strlen(T_STR); 202 203 ioaddstr(T_POS, T_STR); 204 205 if (level == 0) 206 ioclrtobot(); 207 level++; 208 T_STATE = newstate; 209 T_POS = newpos; 210 T_RULE = -1; 211 strcpy(T_STR, ""); 212 } 213 214 getcommand() 215 { 216 int c, i, done; 217 char *s, *(*func)(); 218 PLANE *pp; 219 220 rezero(); 221 222 do { 223 c = gettoken(); 224 if (c == tty_new.sg_erase) { 225 if (pop() < 0) 226 noise(); 227 } else if (c == tty_new.sg_kill) { 228 while (pop() >= 0) 229 ; 230 } else { 231 done = 0; 232 for (i = 0; i < st[T_STATE].num_rules; i++) { 233 if (st[T_STATE].rule[i].token == c || 234 st[T_STATE].rule[i].token == tval) { 235 push(i, (c >= ALPHATOKEN) ? tval : c); 236 done = 1; 237 break; 238 } 239 } 240 if (!done) 241 noise(); 242 } 243 } while (T_STATE != -1); 244 245 if (level == 1) 246 return (1); /* forced update */ 247 248 dest_type = T_NODEST; 249 250 for (i = 0; i < level; i++) { 251 func = st[stack[i].state].rule[stack[i].rule].func; 252 if (func != NULL) 253 if ((s = (*func)(stack[i].ch)) != NULL) { 254 ioerror(stack[i].pos, strlen(stack[i].str), s); 255 return (-1); 256 } 257 } 258 259 pp = findplane(p.plane_no); 260 if (pp->new_altitude != p.new_altitude) 261 pp->new_altitude = p.new_altitude; 262 else if (pp->status != p.status) 263 pp->status = p.status; 264 else { 265 pp->new_dir = p.new_dir; 266 pp->delayd = p.delayd; 267 pp->delayd_no = p.delayd_no; 268 } 269 return (0); 270 } 271 272 noise() 273 { 274 putchar('\07'); 275 fflush(stdout); 276 } 277 278 gettoken() 279 { 280 while ((tval = getAChar()) == REDRAWTOKEN || tval == SHELLTOKEN) 281 { 282 if (tval == SHELLTOKEN) 283 { 284 #ifdef BSD 285 struct itimerval itv; 286 itv.it_value.tv_sec = 0; 287 itv.it_value.tv_usec = 0; 288 setitimer(ITIMER_REAL, &itv, NULL); 289 #endif 290 #ifdef SYSV 291 int aval; 292 aval = alarm(0); 293 #endif 294 if (fork() == 0) /* child */ 295 { 296 char *shell, *base, *getenv(), *strrchr(); 297 298 setuid(getuid()); /* turn off setuid bit */ 299 done_screen(); 300 301 /* run user's favorite shell */ 302 if ((shell = getenv("SHELL")) != NULL) 303 { 304 base = strrchr(shell, '/'); 305 if (base == NULL) 306 base = shell; 307 else 308 base++; 309 execl(shell, base, 0); 310 } 311 else 312 execl(_PATH_BSHELL, "sh", 0); 313 314 exit(0); /* oops */ 315 } 316 317 wait(0); 318 #ifdef BSD 319 ioctl(fileno(stdin), TIOCSETP, &tty_new); 320 itv.it_value.tv_sec = 0; 321 itv.it_value.tv_usec = 1; 322 itv.it_interval.tv_sec = sp->update_secs; 323 itv.it_interval.tv_usec = 0; 324 setitimer(ITIMER_REAL, &itv, NULL); 325 #endif 326 #ifdef SYSV 327 ioctl(fileno(stdin), TCSETAW, &tty_new); 328 alarm(aval); 329 #endif 330 } 331 redraw(); 332 } 333 334 if (isdigit(tval)) 335 return (NUMTOKEN); 336 else if (isalpha(tval)) 337 return (ALPHATOKEN); 338 else 339 return (tval); 340 } 341 342 char * 343 setplane(c) 344 { 345 PLANE *pp; 346 347 pp = findplane(number(c)); 348 if (pp == NULL) 349 return ("Unknown Plane"); 350 bcopy(pp, &p, sizeof (p)); 351 p.delayd = 0; 352 return (NULL); 353 } 354 355 char * 356 turn(c) 357 { 358 if (p.altitude == 0) 359 return ("Planes at airports may not change direction"); 360 return (NULL); 361 } 362 363 char * 364 circle(c) 365 { 366 if (p.altitude == 0) 367 return ("Planes cannot circle on the ground"); 368 p.new_dir = MAXDIR; 369 return (NULL); 370 } 371 372 char * 373 left(c) 374 { 375 dir = D_LEFT; 376 p.new_dir = p.dir - 1; 377 if (p.new_dir < 0) 378 p.new_dir += MAXDIR; 379 return (NULL); 380 } 381 382 char * 383 right(c) 384 { 385 dir = D_RIGHT; 386 p.new_dir = p.dir + 1; 387 if (p.new_dir > MAXDIR) 388 p.new_dir -= MAXDIR; 389 return (NULL); 390 } 391 392 char * 393 Left(c) 394 { 395 p.new_dir = p.dir - 2; 396 if (p.new_dir < 0) 397 p.new_dir += MAXDIR; 398 return (NULL); 399 } 400 401 char * 402 Right(c) 403 { 404 p.new_dir = p.dir + 2; 405 if (p.new_dir > MAXDIR) 406 p.new_dir -= MAXDIR; 407 return (NULL); 408 } 409 410 char * 411 delayb(c) 412 { 413 int xdiff, ydiff; 414 415 c -= '0'; 416 417 if (c >= sp->num_beacons) 418 return ("Unknown beacon"); 419 xdiff = sp->beacon[c].x - p.xpos; 420 xdiff = SGN(xdiff); 421 ydiff = sp->beacon[c].y - p.ypos; 422 ydiff = SGN(ydiff); 423 if (xdiff != displacement[p.dir].dx || ydiff != displacement[p.dir].dy) 424 return ("Beacon is not in flight path"); 425 p.delayd = 1; 426 p.delayd_no = c; 427 428 if (dest_type != T_NODEST) { 429 switch (dest_type) { 430 case T_BEACON: 431 xdiff = sp->beacon[dest_no].x - sp->beacon[c].x; 432 ydiff = sp->beacon[dest_no].y - sp->beacon[c].y; 433 break; 434 case T_EXIT: 435 xdiff = sp->exit[dest_no].x - sp->beacon[c].x; 436 ydiff = sp->exit[dest_no].y - sp->beacon[c].y; 437 break; 438 case T_AIRPORT: 439 xdiff = sp->airport[dest_no].x - sp->beacon[c].x; 440 ydiff = sp->airport[dest_no].y - sp->beacon[c].y; 441 break; 442 default: 443 return ("Bad case in delayb! Get help!"); 444 break; 445 } 446 if (xdiff == 0 && ydiff == 0) 447 return ("Would already be there"); 448 p.new_dir = DIR_FROM_DXDY(xdiff, ydiff); 449 if (p.new_dir == p.dir) 450 return ("Already going in that direction"); 451 } 452 return (NULL); 453 } 454 455 char * 456 beacon(c) 457 { 458 dest_type = T_BEACON; 459 return (NULL); 460 } 461 462 char * 463 ex_it(c) 464 { 465 dest_type = T_EXIT; 466 return (NULL); 467 } 468 469 char * 470 airport(c) 471 { 472 dest_type = T_AIRPORT; 473 return (NULL); 474 } 475 476 char * 477 climb(c) 478 { 479 dir = D_UP; 480 return (NULL); 481 } 482 483 char * 484 descend(c) 485 { 486 dir = D_DOWN; 487 return (NULL); 488 } 489 490 char * 491 setalt(c) 492 { 493 if ((p.altitude == c - '0') && (p.new_altitude == p.altitude)) 494 return ("Already at that altitude"); 495 p.new_altitude = c - '0'; 496 return (NULL); 497 } 498 499 char * 500 setrelalt(c) 501 { 502 if (c == 0) 503 return ("altitude not changed"); 504 505 switch (dir) { 506 case D_UP: 507 p.new_altitude = p.altitude + c - '0'; 508 break; 509 case D_DOWN: 510 p.new_altitude = p.altitude - (c - '0'); 511 break; 512 default: 513 return ("Unknown case in setrelalt! Get help!"); 514 break; 515 } 516 if (p.new_altitude < 0) 517 return ("Altitude would be too low"); 518 else if (p.new_altitude > 9) 519 return ("Altitude would be too high"); 520 return (NULL); 521 } 522 523 char * 524 benum(c) 525 { 526 dest_no = c -= '0'; 527 528 switch (dest_type) { 529 case T_BEACON: 530 if (c >= sp->num_beacons) 531 return ("Unknown beacon"); 532 p.new_dir = DIR_FROM_DXDY(sp->beacon[c].x - p.xpos, 533 sp->beacon[c].y - p.ypos); 534 break; 535 case T_EXIT: 536 if (c >= sp->num_exits) 537 return ("Unknown exit"); 538 p.new_dir = DIR_FROM_DXDY(sp->exit[c].x - p.xpos, 539 sp->exit[c].y - p.ypos); 540 break; 541 case T_AIRPORT: 542 if (c >= sp->num_airports) 543 return ("Unknown airport"); 544 p.new_dir = DIR_FROM_DXDY(sp->airport[c].x - p.xpos, 545 sp->airport[c].y - p.ypos); 546 break; 547 default: 548 return ("Unknown case in benum! Get help!"); 549 break; 550 } 551 return (NULL); 552 } 553 554 char * 555 to_dir(c) 556 { 557 p.new_dir = dir_no(c); 558 return (NULL); 559 } 560 561 char * 562 rel_dir(c) 563 { 564 int angle; 565 566 angle = dir_no(c); 567 switch (dir) { 568 case D_LEFT: 569 p.new_dir = p.dir - angle; 570 if (p.new_dir < 0) 571 p.new_dir += MAXDIR; 572 break; 573 case D_RIGHT: 574 p.new_dir = p.dir + angle; 575 if (p.new_dir >= MAXDIR) 576 p.new_dir -= MAXDIR; 577 break; 578 default: 579 return ("Bizarre direction in rel_dir! Get help!"); 580 break; 581 } 582 return (NULL); 583 } 584 585 char * 586 mark(c) 587 { 588 if (p.altitude == 0) 589 return ("Cannot mark planes on the ground"); 590 if (p.status == S_MARKED) 591 return ("Already marked"); 592 p.status = S_MARKED; 593 return (NULL); 594 } 595 596 char * 597 unmark(c) 598 { 599 if (p.altitude == 0) 600 return ("Cannot unmark planes on the ground"); 601 if (p.status == S_UNMARKED) 602 return ("Already unmarked"); 603 p.status = S_UNMARKED; 604 return (NULL); 605 } 606 607 char * 608 ignore(c) 609 { 610 if (p.altitude == 0) 611 return ("Cannot ignore planes on the ground"); 612 if (p.status == S_IGNORED) 613 return ("Already ignored"); 614 p.status = S_IGNORED; 615 return (NULL); 616 } 617 618 dir_no(ch) 619 char ch; 620 { 621 int dir; 622 623 switch (ch) { 624 case 'w': dir = 0; break; 625 case 'e': dir = 1; break; 626 case 'd': dir = 2; break; 627 case 'c': dir = 3; break; 628 case 'x': dir = 4; break; 629 case 'z': dir = 5; break; 630 case 'a': dir = 6; break; 631 case 'q': dir = 7; break; 632 default: 633 fprintf(stderr, "bad character in dir_no\n"); 634 break; 635 } 636 return (dir); 637 } 638