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     ! 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.