Return to util.c CVS log

Up to [CSRG BSD Unix] / 43BSD / contrib / jove

Annotation of 43BSD/contrib/jove/util.c, revision 1.1

1.1     ! root        1: /*************************************************************************
        !             2:  * This program is copyright (C) 1985, 1986 by Jonathan Payne.  It is    *
        !             3:  * provided to you without charge for use only on a licensed Unix        *
        !             4:  * system.  You may copy JOVE provided that this notice is included with *
        !             5:  * the copy.  You may not sell copies of this program or versions        *
        !             6:  * modified for use on microcomputer systems, unless the copies are      *
        !             7:  * included with a Unix system distribution and the source is provided.  *
        !             8:  *************************************************************************/
        !             9: 
        !            10: #include "jove.h"
        !            11: #include "ctype.h"
        !            12: #include <signal.h>
        !            13: 
        !            14: struct cmd *
        !            15: FindCmd(proc)
        !            16: register int   (*proc)();
        !            17: {
        !            18:        register struct cmd     *cp;
        !            19: 
        !            20:        for (cp = commands; cp->Name; cp++)
        !            21:                if (cp->c_proc == proc)
        !            22:                        return cp;
        !            23:        return 0;
        !            24: }
        !            25: 
        !            26: int    Interactive;    /* True when we invoke with the command handler? */
        !            27: char   *ProcFmt = ": %f ";
        !            28: 
        !            29: ExecCmd(cp)
        !            30: data_obj       *cp;
        !            31: {
        !            32:        LastCmd = cp;
        !            33:        if (cp->Type & MAJOR_MODE)
        !            34:                SetMajor((cp->Type >> 8));
        !            35:        else if (cp->Type & MINOR_MODE)
        !            36:                TogMinor((cp->Type >> 8));
        !            37:        else    switch (cp->Type&TYPEMASK) {
        !            38:                case MACRO:
        !            39:                        do_macro((struct macro *) cp);
        !            40:                        break;
        !            41: 
        !            42:                case FUNCTION:
        !            43:                    {
        !            44:                        struct cmd      *cmd = (struct cmd *) cp;
        !            45: 
        !            46:                        if (cmd->c_proc)
        !            47:                                (*cmd->c_proc)();
        !            48:                    }
        !            49:        }
        !            50: }
        !            51: 
        !            52: Line *
        !            53: lastline(lp)
        !            54: register Line  *lp;
        !            55: {
        !            56:        while (lp->l_next)
        !            57:                lp = lp->l_next;
        !            58:        return lp;
        !            59: }
        !            60: 
        !            61: Upper(c)
        !            62: register int   c;
        !            63: {
        !            64:        return (islower(c) ? toupper(c) : c);
        !            65: }
        !            66: 
        !            67: int    alarmed = 0;
        !            68: 
        !            69: char   key_strokes[100];
        !            70: static char    *key_p = key_strokes;
        !            71: 
        !            72: init_strokes()
        !            73: {
        !            74:        key_strokes[0] = 0;
        !            75:        key_p = key_strokes;
        !            76: }
        !            77: 
        !            78: add_stroke(c)
        !            79: {
        !            80:        if (key_p + 5 > &key_strokes[(sizeof key_strokes) - 1])
        !            81:                key_p = key_strokes;
        !            82:        sprintf(key_p, "%p ", c);
        !            83:        key_p += strlen(key_p);
        !            84: }
        !            85: 
        !            86: slowpoke()
        !            87: {
        !            88:        alarmed++;
        !            89:        f_mess(key_strokes);
        !            90: }
        !            91: 
        !            92: #ifdef BSD4_2
        !            93: #      define N_SEC    1       /* will be precisely 1 second on 4.2 */
        !            94: #else
        !            95: #      define N_SEC    2       /* but from 0 to 2 seconds otherwise */
        !            96: #endif
        !            97: 
        !            98: waitchar()
        !            99: {
        !           100: #ifdef EUNICE
        !           101:        return getch();
        !           102: #endif
        !           103:        unsigned int    old_time;
        !           104:        int     c;
        !           105:        int     (*oldproc)();
        !           106: 
        !           107:        alarmed = 0;
        !           108:        oldproc = signal(SIGALRM, slowpoke);
        !           109: 
        !           110:        if ((old_time = alarm((unsigned) N_SEC)) == 0)
        !           111:                old_time = UpdFreq;
        !           112:        c = getch();
        !           113:        (void) alarm(old_time);
        !           114:        (void) signal(SIGALRM, oldproc);
        !           115: 
        !           116:        return c;
        !           117: }
        !           118: 
        !           119: /* dir > 0 means forward; else means backward. */
        !           120: 
        !           121: char *
        !           122: StrIndex(dir, buf, charpos, what)
        !           123: char   *buf,
        !           124:        what;
        !           125: {
        !           126:        char    *cp = &buf[charpos],
        !           127:                c;
        !           128: 
        !           129:        if (dir > 0) {
        !           130:                while (c = *cp++)
        !           131:                        if (c == what)
        !           132:                                return (cp - 1);
        !           133:        } else {
        !           134:                while (cp >= buf && (c = *cp--))
        !           135:                        if (c == what)
        !           136:                                return (cp + 1);
        !           137:        }
        !           138:        return 0;
        !           139: }
        !           140: 
        !           141: blnkp(buf)
        !           142: register char  *buf;
        !           143: {
        !           144:        register char   c;
        !           145: 
        !           146:        while ((c = *buf++) && (c == ' ' || c == '\t'))
        !           147:                ;
        !           148:        return c == 0;  /* It's zero if we got to the end of the Line */
        !           149: }
        !           150: 
        !           151: Line *
        !           152: next_line(line, num)
        !           153: register Line  *line;
        !           154: register int   num;
        !           155: {
        !           156:        if (num < 0)
        !           157:                return prev_line(line, -num);
        !           158:        if (line)
        !           159:                while (--num >= 0 && line->l_next != 0)
        !           160:                        line = line->l_next;
        !           161:        return line;
        !           162: }
        !           163: 
        !           164: Line *
        !           165: prev_line(line, num)
        !           166: register Line  *line;
        !           167: register int   num;
        !           168: {
        !           169:        if (num < 0)
        !           170:                return next_line(line, -num);
        !           171:        if (line)
        !           172:                while (--num >= 0 && line->l_prev != 0)
        !           173:                        line = line->l_prev;
        !           174:        return line;
        !           175: }
        !           176: 
        !           177: DotTo(line, col)
        !           178: Line   *line;
        !           179: {
        !           180:        Bufpos  bp;
        !           181: 
        !           182:        bp.p_line = line;
        !           183:        bp.p_char = col;
        !           184:        SetDot(&bp);
        !           185: }
        !           186: 
        !           187: /* If bp->p_line is != current line, then save current line.  Then set dot
        !           188:    to bp->p_line, and if they weren't equal get that line into linebuf.  */
        !           189: 
        !           190: SetDot(bp)
        !           191: register Bufpos        *bp;
        !           192: {
        !           193:        register int    notequal;
        !           194: 
        !           195:        if (bp == 0)
        !           196:                return;
        !           197: 
        !           198:        notequal = bp->p_line != curline;
        !           199:        if (notequal)
        !           200:                lsave();
        !           201:        if (bp->p_line)
        !           202:                curline = bp->p_line;
        !           203:        curchar = bp->p_char;
        !           204:        if (notequal)
        !           205:                getDOT();
        !           206: }
        !           207: 
        !           208: ToLast()
        !           209: {
        !           210:        SetLine(curbuf->b_last);
        !           211:        Eol();
        !           212: }
        !           213: 
        !           214: int    MarkThresh = 22;        /* Average screen size ... */
        !           215: static int     line_diff;
        !           216: 
        !           217: LineDist(nextp, endp)
        !           218: register Line  *nextp,
        !           219:                *endp;
        !           220: {
        !           221:        (void) inorder(nextp, 0, endp, 0);
        !           222:        return line_diff;
        !           223: }
        !           224: 
        !           225: inorder(nextp, char1, endp, char2)
        !           226: register Line  *nextp,
        !           227:                *endp;
        !           228: {
        !           229:        int     count = 0;
        !           230:        register Line   *prevp = nextp;
        !           231: 
        !           232:        line_diff = 0;
        !           233:        if (nextp == endp)
        !           234:                return char1 < char2;
        !           235: 
        !           236:        while (nextp || prevp) {
        !           237:                if (nextp == endp || prevp == endp)
        !           238:                        break;
        !           239:                if (nextp)
        !           240:                        nextp = nextp->l_next;
        !           241:                if (prevp)
        !           242:                        prevp = prevp->l_prev;
        !           243:                count++;
        !           244:        }
        !           245:        if (nextp == 0 && prevp == 0)
        !           246:                return -1;
        !           247:        line_diff = count;
        !           248: 
        !           249:        return nextp == endp;
        !           250: }
        !           251: 
        !           252: PushPntp(line)
        !           253: register Line  *line;
        !           254: {
        !           255:        exp_p = 0;
        !           256:        if (LineDist(curline, line) >= MarkThresh)
        !           257:                SetMark();
        !           258: }
        !           259: 
        !           260: ToFirst()
        !           261: {
        !           262:        SetLine(curbuf->b_first);
        !           263: }
        !           264: 
        !           265: length(line)
        !           266: Line   *line;
        !           267: {
        !           268:        return strlen(lcontents(line));
        !           269: };
        !           270: 
        !           271: to_word(dir)
        !           272: register int   dir;
        !           273: {
        !           274:        register char   c;
        !           275: 
        !           276:        if (dir > 0) {
        !           277:                while ((c = linebuf[curchar]) != 0 && !isword(c))
        !           278:                        curchar++;
        !           279:                if (eolp()) {
        !           280:                        if (curline->l_next == 0)
        !           281:                                return;
        !           282:                        SetLine(curline->l_next);
        !           283:                        to_word(dir);
        !           284:                        return;
        !           285:                }
        !           286:        } else {
        !           287:                while (!bolp() && (c = linebuf[curchar - 1], !isword(c)))
        !           288:                        --curchar;
        !           289:                if (bolp()) {
        !           290:                        if (curline->l_prev == 0)
        !           291:                                return;
        !           292:                        SetLine(curline->l_prev);
        !           293:                        Eol();
        !           294:                        to_word(dir);
        !           295:                }
        !           296:        }
        !           297: }
        !           298: 
        !           299: /* Are there any modified buffers?  Allp means include B_PROCESS and
        !           300:    B_IPROCESS buffers in the check, but never scratch buffers. */
        !           301: 
        !           302: ModBufs(allp)
        !           303: {
        !           304:        register Buffer *b;
        !           305: 
        !           306:        for (b = world; b != 0; b = b->b_next) {
        !           307:                if (b->b_type == B_SCRATCH)
        !           308:                        continue;
        !           309:                if ((b->b_type == B_FILE || allp) && IsModified(b))
        !           310:                        return 1;
        !           311:        }
        !           312:        return 0;
        !           313: }
        !           314: 
        !           315: char *
        !           316: filename(b)
        !           317: register Buffer        *b;
        !           318: {
        !           319:        return b->b_fname ? pr_name(b->b_fname) : "[No file]";
        !           320: }
        !           321: 
        !           322: char *
        !           323: itoa(num)
        !           324: register int   num;
        !           325: {
        !           326:        static char     line[15];
        !           327: 
        !           328:        sprintf(line, "%d", num);
        !           329:        return line;
        !           330: }
        !           331: 
        !           332: min(a, b)
        !           333: register int   a,
        !           334:                b;
        !           335: {
        !           336:        return (a < b) ? a : b;
        !           337: }
        !           338: 
        !           339: max(a, b)
        !           340: register int   a,
        !           341:                b;
        !           342: {
        !           343:        return (a > b) ? a : b;
        !           344: }
        !           345: 
        !           346: tiewind(wp, bp)
        !           347: register Window        *wp;
        !           348: register Buffer        *bp;
        !           349: {
        !           350:        UpdModLine++;   /* Kludge ... but speeds things up considerably */
        !           351:        wp->w_line = bp->b_dot;
        !           352:        wp->w_char = bp->b_char;
        !           353:        wp->w_bufp = bp;
        !           354: }
        !           355: 
        !           356: extern int     Jr_Len;
        !           357: 
        !           358: char *
        !           359: lcontents(line)
        !           360: register Line  *line;
        !           361: {
        !           362:        if (line == curline)
        !           363:                return linebuf;
        !           364:        else
        !           365:                return lbptr(line);
        !           366: }
        !           367: 
        !           368: char *
        !           369: ltobuf(line, buf)
        !           370: Line   *line;
        !           371: char   *buf;
        !           372: {
        !           373:        if (line == curline) {
        !           374:                if (buf != linebuf)
        !           375:                        strcpy(buf, linebuf);
        !           376:                Jr_Len = strlen(linebuf);
        !           377:        } else
        !           378:                (void) getline(line->l_dline, buf);
        !           379:        return buf;
        !           380: }
        !           381: 
        !           382: /* Return none-zero if we had to rearrange the order. */
        !           383: 
        !           384: fixorder(line1, char1, line2, char2)
        !           385: register Line  **line1,
        !           386:                **line2;
        !           387: register int   *char1,
        !           388:                *char2;
        !           389: {
        !           390:        Line    *tline;
        !           391:        int     tchar;
        !           392: 
        !           393:        if (inorder(*line1, *char1, *line2, *char2))
        !           394:                return 0;
        !           395: 
        !           396:        tline = *line1;
        !           397:        tchar = *char1;
        !           398:        *line1 = *line2;
        !           399:        *char1 = *char2;
        !           400:        *line2 = tline;
        !           401:        *char2 = tchar;
        !           402: 
        !           403:        return 1;
        !           404: }
        !           405: 
        !           406: inlist(first, what)
        !           407: register Line  *first,
        !           408:                *what;
        !           409: {
        !           410:        while (first) {
        !           411:                if (first == what)
        !           412:                        return 1;
        !           413:                first = first->l_next;
        !           414:        }
        !           415:        return 0;
        !           416: }
        !           417: 
        !           418: /* Make `buf' modified and tell the redisplay code to update the modeline
        !           419:    if it will need to be changed. */
        !           420: 
        !           421: int    ModCount = 0;
        !           422: 
        !           423: modify()
        !           424: {
        !           425:        extern int      DOLsave;
        !           426: 
        !           427:        if (!curbuf->b_modified)
        !           428:                UpdModLine++;
        !           429:        curbuf->b_modified++;
        !           430:        DOLsave++;
        !           431:        if (!Asking)
        !           432:                ModCount++;
        !           433: }
        !           434: 
        !           435: unmodify()
        !           436: {
        !           437:        if (curbuf->b_modified)
        !           438:                UpdModLine++;
        !           439:        curbuf->b_modified = 0;
        !           440: }
        !           441: 
        !           442: numcomp(s1, s2)
        !           443: register char  *s1,
        !           444:                *s2;
        !           445: {
        !           446:        register int    count = 0;
        !           447: 
        !           448:        while (*s1 != 0 && *s1++ == *s2++)
        !           449:                count++;
        !           450:        return count;
        !           451: }
        !           452: 
        !           453: char *
        !           454: copystr(str)
        !           455: char   *str;
        !           456: {
        !           457:        char    *val = emalloc(strlen(str) + 1);
        !           458: 
        !           459:        strcpy(val, str);
        !           460:        return val;
        !           461: }
        !           462: 
        !           463: #ifndef byte_copy
        !           464: byte_copy(from, to, count)
        !           465: register char  *from,
        !           466:                *to;
        !           467: register int   count;
        !           468: {
        !           469:        while (--count >= 0)
        !           470:                *to++ = *from++;
        !           471: }
        !           472: #endif
        !           473: 
        !           474: len_error(flag)
        !           475: {
        !           476:        char    *mesg = "[line too long]";
        !           477: 
        !           478:        (flag == COMPLAIN) ? complain(mesg) : error(mesg);
        !           479: }
        !           480: 
        !           481: /* Insert num number of c's at offset atchar in a linebuf of LBSIZE */
        !           482: 
        !           483: ins_c(c, buf, atchar, num, max)
        !           484: char   c, *buf;
        !           485: {
        !           486:        register char   *pp, *pp1;
        !           487:        register int    len;
        !           488:        int     numchars;       /* Number of characters to copy forward */
        !           489: 
        !           490:        if (num <= 0)
        !           491:                return;
        !           492:        len = atchar + strlen(&buf[atchar]);
        !           493:        if (len + num >= max)
        !           494:                len_error(COMPLAIN);
        !           495:        pp = &buf[len + 1];             /* + 1 so we can --pp (not pp--) */
        !           496:        pp1 = &buf[len + num + 1];
        !           497:        numchars = len - atchar;
        !           498:        while (numchars-- >= 0)
        !           499:                *--pp1 = *--pp;
        !           500:        pp = &buf[atchar];
        !           501:        while (--num >= 0)
        !           502:                *pp++ = c;
        !           503: }
        !           504: 
        !           505: TwoBlank()
        !           506: {
        !           507:        register Line   *next = curline->l_next;
        !           508: 
        !           509:        return ((next != 0) &&
        !           510:                (*(lcontents(next)) == '\0') &&
        !           511:                (next->l_next != 0) &&
        !           512:                (*(lcontents(next->l_next)) == '\0'));
        !           513: }
        !           514: 
        !           515: linecopy(onto, atchar, from)
        !           516: register char  *onto,
        !           517:                *from;
        !           518: {
        !           519:        register char   *endp = &onto[LBSIZE - 2];
        !           520: 
        !           521:        onto += atchar;
        !           522: 
        !           523:        while (*onto = *from++)
        !           524:                if (onto++ >= endp)
        !           525:                        len_error(ERROR);
        !           526: }
        !           527: 
        !           528: char *
        !           529: IOerr(err, file)
        !           530: char   *err, *file;
        !           531: {
        !           532:        return sprint("Couldn't %s \"%s\".", err, file);
        !           533: }
        !           534: 
        !           535: pclose(p)
        !           536: int    *p;
        !           537: {
        !           538:        (void) close(p[0]);
        !           539:        (void) close(p[1]);
        !           540: }
        !           541: 
        !           542: dopipe(p)
        !           543: int    p[];
        !           544: {
        !           545:        if (pipe(p) == -1)
        !           546:                complain("[Pipe failed]");
        !           547: }
        !           548: 
        !           549: /* NOSTRICT */
        !           550: 
        !           551: char *
        !           552: emalloc(size)
        !           553: {
        !           554:        char    *ptr;
        !           555: 
        !           556:        if (ptr = malloc((unsigned) size))
        !           557:                return ptr;
        !           558:        /* Try garbage collecting lines */
        !           559:        GCchunks();
        !           560:        if (ptr = malloc((unsigned) size))
        !           561:                return ptr;
        !           562:        /* Uh ... Oh screw it! */
        !           563:        error("[Out of memory] ");
        !           564:        /* NOTREACHED */
        !           565: }
        !           566: 
        !           567: /* Return the basename of file F. */
        !           568: 
        !           569: char *
        !           570: basename(f)
        !           571: register char  *f;
        !           572: {
        !           573:        register char   *cp;
        !           574: 
        !           575:        if (cp = rindex(f, '/'))
        !           576:                return cp + 1;
        !           577:        else
        !           578:                return f;
        !           579: }
        !           580: 
        !           581: push_env(savejmp)
        !           582: jmp_buf        savejmp;
        !           583: {
        !           584:        byte_copy((char *) mainjmp, (char *) savejmp, sizeof (jmp_buf));
        !           585: }
        !           586: 
        !           587: pop_env(savejmp)
        !           588: jmp_buf        savejmp;
        !           589: {
        !           590:        byte_copy((char *) savejmp, (char *) mainjmp, sizeof (jmp_buf));
        !           591: }
        !           592: 
        !           593: #ifdef LOAD_AV
        !           594: #  ifdef BSD4_2
        !           595: #    ifdef PURDUE_EE
        !           596: 
        !           597: get_la(dp)
        !           598: double *dp;
        !           599: {
        !           600:        *dp = (double) loadav(0) / 100.0;
        !           601: }
        !           602: 
        !           603: #    else PURDUE_EE
        !           604: 
        !           605: #include <nlist.h>
        !           606: 
        !           607: static struct  nlist nl[] = {
        !           608:        { "_avenrun" },
        !           609: #define        X_AVENRUN       0
        !           610:        { "" }
        !           611: };
        !           612: 
        !           613: get_la(dp)
        !           614: double *dp;
        !           615: {
        !           616:        double  avenrun[3];
        !           617:        static int      kmem = 0;
        !           618: 
        !           619:        if (kmem == -1) {
        !           620:                *dp = 4.0;      /* So shell commands will say "Chugging" */
        !           621:                return;
        !           622:        } else if (kmem == 0) {
        !           623:                if ((kmem = open("/dev/kmem", 0)) == -1) {
        !           624:                        f_mess("Can't open kmem for load average.");
        !           625:                        *dp = 4.0;
        !           626:                        return;
        !           627:                }
        !           628:                nlist("/vmunix", nl);
        !           629:        }
        !           630:        lseek(kmem, (long) nl[X_AVENRUN].n_value, 0);
        !           631:        read(kmem, (char *) avenrun, sizeof(avenrun));
        !           632:        *dp = avenrun[0];
        !           633: }
        !           634: 
        !           635: #    endif PURDUE_EE
        !           636: #  else BSD4_2
        !           637: 
        !           638: get_la(dp)
        !           639: double *dp;
        !           640: {
        !           641:        short   avg[3];
        !           642: 
        !           643:        gldav(avg);
        !           644:        *dp = (double) avg[0] / 256;
        !           645: }
        !           646: 
        !           647: #  endif BSD4_2
        !           648: #endif LOAD_AV
        !           649: 
        !           650: /* get the time buf, designated by *timep, from FROM to TO. */
        !           651: char *
        !           652: get_time(timep, buf, from, to)
        !           653: char   *buf;
        !           654: time_t *timep;
        !           655: {
        !           656:        time_t  now;
        !           657:        char    *cp;
        !           658:        extern char     *ctime();
        !           659: 
        !           660:        if (timep != 0)
        !           661:                now = *timep;
        !           662:        else
        !           663:                (void) time(&now);
        !           664:        cp = ctime(&now) + from;
        !           665:        if (to == -1)
        !           666:                cp[strlen(cp) - 1] = '\0';              /* Get rid of \n */
        !           667:        else
        !           668:                cp[to - from] = '\0';
        !           669:        if (buf) {
        !           670:                strcpy(buf, cp);
        !           671:                return buf;
        !           672:        } else
        !           673:                return cp;
        !           674: }
        !           675: 
        !           676: /* Return length of null terminated string. */
        !           677: 
        !           678: strlen(s)
        !           679: register char  *s;
        !           680: {
        !           681:        register char   *base = s + 1;  /* Can you say kludge? */
        !           682: 
        !           683:        while (*s++)
        !           684:                ;
        !           685:        return (s - base);
        !           686: }
        !           687: 
        !           688: char *
        !           689: index(s, c)
        !           690: register char  *s;
        !           691: register int   c;
        !           692: {
        !           693:        register int    c1;
        !           694: 
        !           695:        if (c != 0)
        !           696:                while (c1 = *s++)
        !           697:                        if (c == c1)
        !           698:                                return s - 1;
        !           699:        return 0;
        !           700: }
        !           701: 
        !           702: strcmp(s1, s2)
        !           703: register char  *s1,
        !           704:                *s2;
        !           705: {
        !           706:        if (!s1 || !s2)
        !           707:                return 1;       /* Which is not zero ... */
        !           708:        while (*s1 == *s2++)
        !           709:                if (*s1++ == '\0')
        !           710:                        return 0;
        !           711:        return (*s1 - *--s2);
        !           712: }
        !           713: 
        !           714: casecmp(s1, s2)
        !           715: register char  *s1,
        !           716:                *s2;
        !           717: {
        !           718:        if (!s1 || !s2)
        !           719:                return 1;       /* Which is not zero ... */
        !           720:        while (*s1 == *s2++ || Upper(*s1) == Upper(s2[-1]))
        !           721:                if (*s1++ == '\0')
        !           722:                        return 0;
        !           723:        return (*s1 - *--s2);
        !           724: }
        !           725: 
        !           726: casencmp(s1, s2, n)
        !           727: register char  *s1,
        !           728:                *s2;
        !           729: register int   n;
        !           730: {
        !           731:        if (!s1 || !s2)
        !           732:                return 1;       /* Which is not zero ... */
        !           733:        while (--n >= 0  && (*s1 == *s2++ || Upper(*s1) == Upper(s2[-1])))
        !           734:                if (*s1++ == '\0')
        !           735:                        return 0;
        !           736:        return ((n < 0) ? 0 : *s1 - *--s2);
        !           737: }
        !           738: 
        !           739: null_ncpy(to, from, n)
        !           740: char   *to,
        !           741:        *from;
        !           742: {
        !           743:        (void) strncpy(to, from, n);
        !           744:        to[n] = '\0';
        !           745: }
        !           746: 
        !           747: strcpy(t, f)
        !           748: register char  *t,
        !           749:                *f;
        !           750: {
        !           751:        while (*t++ = *f++)
        !           752:                ;
        !           753: }
        !           754: 
        !           755: /* Tries to pause for delay/10 seconds OR until a character is typed
        !           756:    at the keyboard.  This works well on BSD4_2 and not so well on the
        !           757:    rest.  Returns 1 if it returned because of keyboard input, or 0
        !           758:    otherwise. */
        !           759: 
        !           760: SitFor(delay)
        !           761: int    delay;
        !           762: {
        !           763: #ifdef BSD4_2
        !           764: #include <sys/time.h>
        !           765: 
        !           766:        struct timeval  timer;
        !           767:        int     readfds = 1,
        !           768:                writefds = 0,
        !           769:                exceptfds = 0;
        !           770: 
        !           771:        timer.tv_sec = (delay / 10);
        !           772:        timer.tv_usec = (delay % 10) * 100000;
        !           773: 
        !           774:        if (charp())
        !           775:                return 1;
        !           776:        /* gross that I had to snarf this from getch() */
        !           777:        if (!UpdMesg && !Asking) {      /* Don't erase if we are asking */
        !           778:                if (mesgbuf[0] && !errormsg)
        !           779:                        message(NullStr);
        !           780:        }
        !           781:        redisplay();
        !           782:        return select(1, &readfds, &writefds, &exceptfds, &timer);
        !           783: #else
        !           784:        static float cps[] = {
        !           785:                0.0,
        !           786:                5.0,
        !           787:                7.5,
        !           788:                11.0,
        !           789:                13.4,
        !           790:                15.0,
        !           791:                20.0,
        !           792:                30.0,
        !           793:                60.0,
        !           794:                120.0,
        !           795:                180.0,
        !           796:                240.0,
        !           797:                480.0,
        !           798:                960.0,
        !           799:                1920.0,
        !           800:                1920.0,
        !           801:        };
        !           802:        float   nsecs;
        !           803:        register int    nchars;
        !           804: 
        !           805:        if (charp())
        !           806:                return 1;
        !           807:        nsecs = (float) delay / 10;
        !           808:        nchars = (int) (nsecs * cps[ospeed]);
        !           809:        redisplay();
        !           810:        while ((--nchars > 0) && !InputPending) {
        !           811:                putchar(0);
        !           812:                if (OkayAbort) {
        !           813:                        OkayAbort = 0;
        !           814:                        InputPending = charp();
        !           815:                }
        !           816:        }
        !           817:        return InputPending;
        !           818: #endif
        !           819: }
        !           820: 
        !           821: sindex(pattern, string)
        !           822: register char  *pattern,
        !           823:                *string;
        !           824: {
        !           825:        register int    len = strlen(pattern);
        !           826: 
        !           827:        while (*string != '\0') {
        !           828:                if (*pattern == *string && strncmp(pattern, string, len) == 0)
        !           829:                        return TRUE;
        !           830:                string++;
        !           831:        }
        !           832:        return FALSE;
        !           833: }

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