Return to mgetstr.c CVS log

Up to [MW Coherent from dump] / coherent / a / usr / bob / uusrc / modemcap

Annotation of coherent/a/usr/bob/uusrc/modemcap/mgetstr.c, revision 1.1.1.1

1.1       root        1: extern char    *__modemcap;
                      2: 
                      3: char   *mgetstr (id, area)
                      4: register char  *id;
                      5: register char  **area;
                      6: {
                      7:        register char   *cp = __modemcap;
                      8:        register char   *str = *area;           /* start of current string       */
                      9: 
                     10:        if (__modemcap == (char *) 0)           /* has mgetent() been called? ... */
                     11:                return ((char *) 0);                    /* ... no, can't find string */
                     12: 
                     13:        while (*cp != ':' && *cp != 0)          /* find first entry in cap       */
                     14:                cp++;
                     15: 
                     16:        if (*cp == 0)                           /* empty entry???                */
                     17:                return ((char *) 0);                    /* ... yes, bad modemcap entry   */
                     18:        else
                     19:                cp++;                           /* point to first character in next */
                     20: 
                     21:        while (*cp != 0) {                      /* until entry found or end of entry */
                     22:                if (cp[0] == id[0] && cp[1] == id[1]) { /* found entry!!!        */
                     23:                        if (cp[2] != '=')       /* is it a string value???       */
                     24:                                return ((char *) 0);    /* no, something else            */
                     25:                        else
                     26:                            break;              /* yes, entry was found          */
                     27:                } 
                     28:                else {                  /* not entry, skip this entire entry */
                     29:                        while (*cp != ':' && *cp != 0)
                     30:                                cp++;           /* search for end of current entry */
                     31: 
                     32:                        if (*cp != 0)
                     33:                                cp++;           /* skip terminating character    */
                     34:                }
                     35:        }
                     36:        if (*cp == 0)                           /* end of modem cap entry        */
                     37:                return ((char *) 0);
                     38: 
                     39:        cp += 3;                                /* point to actual string        */
                     40:        while (*cp != ':' && *cp != 0) {        /* for every character in string ... */
                     41:                if (*cp == '\\') {              /* translate escaped character   */
                     42:                        cp++;
                     43:                        switch (*cp) {
                     44:                        case 'n':       /* newline               */
                     45:                                **area = '\n';
                     46:                                (*area)++;
                     47:                                cp++;
                     48:                                break;
                     49:                        case 'r':       /* carriage return       */
                     50:                                **area = '\r';
                     51:                                (*area)++;
                     52:                                cp++;
                     53:                                break;
                     54:                        case 'b':       /* backspace             */
                     55:                                **area = '\b';
                     56:                                (*area)++;
                     57:                                cp++;
                     58:                                break;
                     59:                        case 'f':       /* form feed             */
                     60:                                **area = '\f';
                     61:                                (*area)++;
                     62:                                cp++;
                     63:                                break;
                     64:                        case 't':       /* tab                   */
                     65:                                **area = '\t';
                     66:                                (*area)++;
                     67:                                cp++;
                     68:                                break;
                     69:                        case 'E':       /* Escape character      */
                     70:                                **area = 033;
                     71:                                (*area)++;
                     72:                                cp++;
                     73:                                break;
                     74:                        case '0':
                     75:                        case '1':
                     76:                        case '2':
                     77:                        case '3':
                     78:                        case '4':
                     79:                        case '5':
                     80:                        case '6':
                     81:                        case '7':
                     82:                                **area = ((cp[0] - '0') << 6) +
                     83:                                    ((cp[1] - '0') << 3) +
                     84:                                    (cp[2] - '0');
                     85:                                (*area)++;
                     86:                                cp += 3;
                     87:                                break;
                     88:                        default:
                     89:                                **area = *cp++;
                     90:                                (*area)++;
                     91:                                break;
                     92:                        }
                     93:                } 
                     94:                else if (*cp == '^') {  /* some control character        */
                     95:                        cp++;
                     96:                        if (*cp >= '@' && *cp <= '_') {
                     97:                                **area = *cp - '@';
                     98:                                (*area)++;
                     99:                        }
                    100:                        cp++;
                    101:                } 
                    102:                else {                  /* some normal character         */
                    103:                        **area = *cp++;         /* put character in area         */
                    104:                        (*area)++;
                    105:                }
                    106:        }
                    107:        *((*area)++) = 0;                       /* null terminate area and string */
                    108:        return (str);                           /* return pointer to start of string */
                    109: }

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