games/atc/input.c

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