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