Return to subr.c CVS log

Up to [Research Unix] / researchv10no / sys / mkconf

Annotation of researchv10no/sys/mkconf/subr.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * miscellaneous common routines for config
                      3:  */
                      4: 
                      5: #include <libc.h>
                      6: #include <ctype.h>
                      7: #include "mkconf.h"
                      8: 
                      9: /*
                     10:  * little routines for input
                     11:  */
                     12: 
                     13: int
                     14: crack(p, a, n)
                     15: char *p;
                     16: char **a;
                     17: int n;
                     18: {
                     19:        register char *rp;
                     20: 
                     21:        if ((rp = strchr(p, '#')) != NULL)
                     22:                *rp = 0;
                     23:        return (getmfields(p, a, n));
                     24: }
                     25: 
                     26: /*
                     27:  * common parsing hack for device addresses
                     28:  */
                     29: 
                     30: char *
                     31: keyread(lp, ap, n, kp)
                     32: register long *lp;
                     33: register char **ap;
                     34: int n;
                     35: register char **kp;
                     36: {
                     37:        register int i;
                     38: 
                     39:        for (; n > 1; n-=2, ap+=2) {
                     40:                for (i = 0; kp[i]; i++)
                     41:                        if (strcmp(ap[0], kp[i]) == 0) {
                     42:                                lp[i] = nconv(ap[1]);
                     43:                                break;
                     44:                        }
                     45:                if (kp[i] == 0)
                     46:                        return (*ap);   /* unknown keyword */
                     47:        }
                     48:        return (NULL);
                     49: }
                     50: 
                     51: /*
                     52:  * 0nnn -> octal
                     53:  * 0xnnn -> hex
                     54:  * nnn -> decimal
                     55:  */
                     56: long
                     57: nconv(a)
                     58: register char *a;
                     59: {
                     60:        register long n;
                     61:        register int base, d;
                     62:        register int sign;
                     63: 
                     64:        base = 10;
                     65:        sign = 1;
                     66:        n = 0;
                     67:        if (*a == '-') {
                     68:                sign = -1;
                     69:                a++;
                     70:        }
                     71:        if (*a == '0') {
                     72:                base = 8;
                     73:                a++;
                     74:                if (*a == 'x' || *a == 'X') {
                     75:                        base = 16;
                     76:                        a++;
                     77:                }
                     78:        }
                     79:        for (; isxdigit(*a); a++) {
                     80:                d = *a - '0';
                     81:                if (*a >= 'a')
                     82:                        d -= 'a' - '0' - 10;
                     83:                else if (*a >= 'A')
                     84:                        d -= 'A' - '0' - 10;
                     85:                if (d >= base)
                     86:                        break;
                     87:                n = n * base + d;
                     88:        }
                     89:        return (n * sign);
                     90: }
                     91: 
                     92: Mdev *
                     93: mdlook(name)
                     94: char *name;
                     95: {
                     96:        register Mdev *mp;
                     97: 
                     98:        for (mp = mlist; mp; mp = mp->next)
                     99:                if (strcmp(mp->name, name) == 0)
                    100:                        return (mp);
                    101:        return (NULL);
                    102: }
                    103: 
                    104: /*
                    105:  * skip to next type of device in dlist
                    106:  */
                    107: 
                    108: Dev *
                    109: advtype(dp)
                    110: register Dev *dp;
                    111: {
                    112:        register Dev *ep;
                    113: 
                    114:        for (ep = dp; ep && ep->mdev == dp->mdev; ep = ep->next)
                    115:                ;
                    116:        return (ep);
                    117: }
                    118: 
                    119: /*
                    120:  * look up a driver in a table
                    121:  */
                    122: 
                    123: int
                    124: tablook(mp, tab, lim)
                    125: register Mdev *mp;
                    126: register Devtab *tab;
                    127: register int lim;
                    128: {
                    129:        register int i;
                    130: 
                    131:        for (i = 0; i <= lim; i++, tab++)
                    132:                if (tab->dev == mp)
                    133:                        return (i);
                    134:        return (-1);
                    135: }
                    136: 
                    137: /*
                    138:  * miscellany
                    139:  */
                    140: 
                    141: char *
                    142: ealloc(size)
                    143: int size;
                    144: {
                    145:        char *p;
                    146: 
                    147:        if ((p = malloc(size)) != NULL)
                    148:                return (p);
                    149:        fprint(STDERR, "out of memory\n");
                    150:        exit(1);
                    151: }
                    152: 
                    153: char *
                    154: estrdup(s)
                    155: char *s;
                    156: {
                    157:        char *t;
                    158: 
                    159:        t = ealloc(strlen(s)+1);
                    160:        strcpy(t, s);
                    161:        return (t);
                    162: }

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