Return to input.c CVS log

Up to [Research Unix] / researchv10no / games / trek

Annotation of researchv10no/games/trek/input.c, revision 1.1

1.1     ! root        1: #include "/usr/lib/a68defs"
        !             2: 
        !             3: 
        !             4: int    mkfault;
        !             5: int    stdin;
        !             6: char readbuf[255]; char *readptr;
        !             7: char eof, lastchar;
        !             8: 
        !             9: readchar()
        !            10: {
        !            11:        REG CHAR c;
        !            12: 
        !            13:        IF readptr==0
        !            14:        THEN    newline();
        !            15:        FI
        !            16:        IF eof ORF mkfault
        !            17:        THEN    c=EOF;
        !            18:        ELIF c = *readptr THEN readptr++; FI
        !            19:        return(lastchar=c);
        !            20: }
        !            21: 
        !            22: newline()
        !            23: {
        !            24:        readptr=readbuf;
        !            25:        WHILE eof==0 ANDF mkfault==0
        !            26:             ANDF ( eof = read(stdin,readptr,1)==0,
        !            27:                  *readptr++!=NL
        !            28:                )
        !            29:        DONE
        !            30:        *readptr++=0; readptr=readbuf;
        !            31: }
        !            32: 
        !            33: error(s1,s2)
        !            34: char *s1, *s2;
        !            35: {
        !            36:        prints(s1); prints(s2);
        !            37:        flushin();
        !            38: }
        !            39: 
        !            40: flushin()
        !            41: {
        !            42:        readptr=0;
        !            43: }
        !            44: 
        !            45: peekchar()
        !            46: {
        !            47:        REG CHAR c;
        !            48:        c=nextchar();
        !            49:        backspace();
        !            50:        return(c);
        !            51: }
        !            52: 
        !            53: nextchar()
        !            54: {
        !            55:        REG CHAR c;
        !            56: 
        !            57:        WHILE (c=readchar())==SP ORF c==TB DONE
        !            58:        return(c);
        !            59: }
        !            60: 
        !            61: readint(i)
        !            62: int *i;
        !            63: {
        !            64:        REG INT r;
        !            65:        REG CHAR c;
        !            66:        REG INT minus;
        !            67:        INT rc;
        !            68: 
        !            69:        IF (c=nextchar())=='-'
        !            70:        THEN    minus=TRUE; c=readchar();
        !            71:        ELSE    minus=FALSE;
        !            72:        FI
        !            73:        IF digit(c)
        !            74:        THEN    r = 0;
        !            75:                REP r =* 10; r =+ c-'0'; PER digit(c=readchar()) DONE
        !            76:                IF minus THEN r=(-r); FI
        !            77:                *i = r; backspace();
        !            78:                rc = 1;
        !            79:        ELSE    rc = 0;
        !            80:        FI
        !            81:        IF eof ORF mkfault
        !            82:        THEN    return(-1);
        !            83:        ELSE    return(rc);
        !            84:        FI
        !            85: }
        !            86: 
        !            87: readreal(a)
        !            88: float *a;
        !            89: {
        !            90:        REAL r;
        !            91:        INT rc;
        !            92:        REG INT fr;
        !            93:        REG CHAR c;
        !            94:        REG INT minus;
        !            95: 
        !            96:        IF (c=nextchar())=='-'
        !            97:        THEN    minus=TRUE; c=readchar();
        !            98:        ELSE    minus=FALSE;
        !            99:        FI
        !           100:        r = 0; rc = 0;
        !           101:        IF digit(c)
        !           102:        THEN    rc = 1;
        !           103:                REP r =* 10; r =+ c-'0'; PER digit(c=readchar()) DONE
        !           104:        FI
        !           105:        fr = 0;
        !           106:        IF c=='.'
        !           107:        THEN    WHILE digit(c=readchar())
        !           108:                DO r =* 10; r =+ c-'0'; fr++; OD
        !           109:                IF fr THEN rc = 1; FI
        !           110:        FI
        !           111:        WHILE fr-- DO r =/ 10; OD
        !           112:        IF minus THEN r = (-r); FI
        !           113:        IF rc THEN backspace(); FI
        !           114:        *a = r;
        !           115:        IF eof ORF mkfault
        !           116:        THEN    return(-1);
        !           117:        ELSE    return(rc);
        !           118:        FI
        !           119: }
        !           120: 
        !           121: reads(term, buffer)
        !           122: char *term; char buffer[];
        !           123: {
        !           124:        register char   c;
        !           125:        REG CHAR        *ptr;
        !           126: 
        !           127:        ptr=buffer;
        !           128:        WHILE !any(c=readchar(),term) ANDF c
        !           129:        DO *ptr++ = c; OD
        !           130:        IF mkfault ORF eof
        !           131:        THEN    return(-1);
        !           132:        ELIF ptr>buffer
        !           133:        THEN    *ptr++=0; backspace();
        !           134:                return(1);
        !           135:        ELSE    return(0);
        !           136:        FI
        !           137: }
        !           138: 
        !           139: backspace()
        !           140: {
        !           141:        IF readptr>readbuf
        !           142:        THEN    readptr--;
        !           143:        FI
        !           144: }
        !           145: 
        !           146: any(c,s)
        !           147: char c;
        !           148: char *s;
        !           149: {
        !           150:        register char a, b;
        !           151:        register char *p;
        !           152: 
        !           153:        p=s; a=c;
        !           154:        WHILE b = *p++
        !           155:        DO IF b==c THEN return(1); FI OD
        !           156:        return(0);
        !           157: }
        !           158: 
        !           159: digit(c)
        !           160: char c;
        !           161: {
        !           162:        return(c>='0' ANDF c<='9');
        !           163: }
        !           164: 
        !           165: lineended()
        !           166: {
        !           167:        return(readptr==0 ORF *readptr==0 ORF peekchar()==NL);
        !           168: }
        !           169: 
        !           170: sign(a)
        !           171: {
        !           172:        return(a<0?-1:(a!=0));
        !           173: }
        !           174: 
        !           175: cf(as1, as2)
        !           176: char *as1, *as2;
        !           177: {
        !           178:        REG char *s1, *s2;
        !           179: 
        !           180:        s1 = as1;
        !           181:        s2 = as2;
        !           182:        WHILE *s1++ == *s2
        !           183:        DO      IF *s2++==0
        !           184:                THEN    return(0);
        !           185:                FI
        !           186:        OD
        !           187:        return(*--s1 - *s2);
        !           188: }

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