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

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.