Return to input.c CVS log

Up to [CSRG BSD Unix] / 43BSDTahoe / games / atc

Annotation of 43BSDTahoe/games/atc/input.c, revision 1.1

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

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.