Return to getpar.c CVS log

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

Annotation of researchv10no/games/trek/getpar.c, revision 1.1.1.1

1.1       root        1: # include      "trek.h"
                      2: # define       ECHO 010
                      3: 
                      4: /**
                      5:  **    get integer parameter
                      6:  **/
                      7: 
                      8: char           eof;
                      9: 
                     10: getintpar(s, n)
                     11: char   *s;
                     12: int    *n;
                     13: {
                     14:        register int            i;
                     15: 
                     16:        for ever {
                     17:                while ((eof|mkfault)==0 && lineended() && s) {
                     18:                        printf("%s: %n", s);
                     19:                        newline();
                     20:                }
                     21:                if((i=readint(n)) < 0)
                     22:                        return(0);
                     23:                if(i>0)
                     24:                        return(1);
                     25:                printf("? ");
                     26:                flushin();
                     27:        }
                     28: }
                     29: 
                     30: /**
                     31:  **    get floating parameter
                     32:  **/
                     33: 
                     34: getfltpar(s, f)
                     35: char   *s;
                     36: float  *f;
                     37: {
                     38:        register int            i;
                     39: 
                     40:        for ever {
                     41:                while ((eof|mkfault)==0 && lineended() && s) {
                     42:                        printf("%s: %n", s);
                     43:                        newline();
                     44:                }
                     45:                if((i=readreal(f)) < 0)
                     46:                        return(0);
                     47:                if(i>0)
                     48:                        return(1);
                     49:                printf("? ");
                     50:                flushin();
                     51:        }
                     52: }
                     53: 
                     54: /**
                     55:  **    get yes/no parameter
                     56:  **/
                     57: 
                     58: CVNTAB Yntab[]
                     59: {
                     60:        "n",    "o",
                     61:        "y",    "es",
                     62:        0
                     63: };
                     64: 
                     65: getynpar(s)
                     66: char   *s;
                     67: {
                     68:        return(getcodpar(s, Yntab));
                     69: }
                     70: 
                     71: 
                     72: /**
                     73:  **    get coded parameter
                     74:  **/
                     75: 
                     76: getcodpar(s, tab)
                     77: char   *s;
                     78: CVNTAB tab[];
                     79: {
                     80:        char                    input[100];
                     81:        register CVNTAB         *r;
                     82:        register char           *p, *q;
                     83:        int                     c;
                     84: 
                     85:        for ever {
                     86:                while ((eof|mkfault)==0 && lineended() && s) {
                     87:                        printf("%s: %n", s);
                     88:                        newline();
                     89:                }
                     90:                if((c=reads(" \t\n0123456789-./;", input)) < 0)
                     91:                        return(-1);
                     92:                if (c) {
                     93:                        if (*input == '?') {
                     94:                                for(r=tab; r->abrev; r++)
                     95:                                        printf("\t%s-%s\n", r->abrev, r->full);
                     96:                                continue;
                     97:                        }
                     98:                        for (r = tab; r->abrev; r++)
                     99:                        {
                    100:                                p = input;
                    101:                                for (q = r->abrev; *q; q++)
                    102:                                        if (*p++ != *q)
                    103:                                                break;
                    104:                                if (!*q)
                    105:                                {
                    106:                                        for (q = r->full; *p && *q; q++, p++)
                    107:                                                if (*p != *q)
                    108:                                                        break;
                    109:                                        if (!*p || !*q)
                    110:                                                break;
                    111:                                }
                    112:                        }
                    113:                }
                    114:                if (c==0 || r->abrev==0)
                    115:                {
                    116:                        printf("? ");
                    117:                        flushin();
                    118:                        continue;
                    119:                }
                    120:                return(r-tab);
                    121:        }
                    122: }
                    123: 
                    124: 
                    125: /**
                    126:  **    get password
                    127:  **/
                    128: 
                    129: getpasswd(buf)
                    130: char buf[];
                    131: {
                    132:        int s, m;
                    133:        register char c; register int ptr;
                    134:        struct{ int junk[2];
                    135:                int mode;
                    136:        } b;
                    137: 
                    138:        s=signal(SIGINT,1);
                    139:        gtty(0,&b); m=b.mode; b.mode =& ~ECHO; stty(0,&b);
                    140:        flushin();
                    141:        printf("Enter password: %n");
                    142:        
                    143:        ptr=0;
                    144:        while((c=readchar())!='\n') {
                    145:                if(ptr<PWDLEN) buf[ptr++]=c;
                    146:        }
                    147:        while(ptr<PWDLEN) buf[ptr++]=0;
                    148:        b.mode = m; stty(0,&b);
                    149:        printf("\n");
                    150:        signal(SIGINT,s);
                    151:        flushin();
                    152: }
                    153: 
                    154: readsep(s)
                    155: char *s;
                    156: {
                    157:        register char rc;
                    158: 
                    159:        if(!(rc=any(nextchar(),s)))
                    160:                backspace();
                    161:        return(mkfault?(-1):rc);
                    162: }

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