Return to tget.c CVS log

Up to [MW Coherent from dump] / coherent / g / usr / lib / ncurses

Annotation of coherent/g/usr/lib/ncurses/tget.c, revision 1.1

1.1     ! root        1: #include <stdio.h>
        !             2: #include <ctype.h>
        !             3: #include <string.h>
        !             4: 
        !             5: #define        bool    char
        !             6: #define        TRUE    1
        !             7: #define        FALSE   0
        !             8: 
        !             9: static char    buffer[1024];   /* 1024 = pulled from a hat */
        !            10: 
        !            11: /*
        !            12:  * scan:
        !            13:  *     scan for character in string, return position of character.
        !            14:  *     similar to index/strchr, except that if char not found, returns
        !            15:  *     pointer to null at end of string, instead of a null pointer.
        !            16:  */
        !            17: 
        !            18: char *
        !            19: scan (s, c)
        !            20: register char  *s;
        !            21: register char  c;
        !            22: {
        !            23:     while ((*s) && (*s != c))
        !            24:        s++;
        !            25:     return (s);
        !            26: }
        !            27: 
        !            28: 
        !            29: /* findcap:
        !            30:  *     returns pointer to just after capname (trailing ':' for flags,
        !            31:  *     '#' for nums, '=' for strs, '@' for disabled stuff) or to null
        !            32:  *      after termcap if not found.
        !            33:  */
        !            34: 
        !            35: char *
        !            36: findcap (capname)
        !            37: char   *capname;
        !            38: {
        !            39:     register char      *bptr = buffer;
        !            40:     register bool      found = FALSE;
        !            41:     char               cap[3];
        !            42: 
        !            43:     cap[2] = '\0';
        !            44:     while ((!found) && (*bptr)) {
        !            45:        bptr = scan (bptr, ':');
        !            46:        if (*bptr) {
        !            47:            cap[0] = *(bptr + 1);
        !            48:            cap[1] = *(bptr + 2);
        !            49:            if (strcmp (cap,capname) == 0) {
        !            50:                found = TRUE;
        !            51:                bptr += 3;      /* skip colon and capname */
        !            52:            }
        !            53:            else
        !            54:                bptr++;         /* skip colon */
        !            55:        }
        !            56:     }
        !            57:     return (bptr);
        !            58: }
        !            59: 
        !            60: 
        !            61: /*
        !            62:  * tgetname:
        !            63:  *     store name of termcap entry in name
        !            64:  */
        !            65: 
        !            66: tgetname (name)
        !            67: char   *name;
        !            68: {
        !            69:     char       *bptr;
        !            70: 
        !            71:     bptr = buffer;
        !            72: 
        !            73:     while ((*bptr) && (*bptr != ':'))
        !            74:        *(name++) = *(bptr++);
        !            75:     *(name) = '\0';
        !            76: }
        !            77: 
        !            78: 
        !            79: /*
        !            80:  * tgetflag:
        !            81:  *     return 1 if capname present, 0 otherwise, -1 if '@'ed.
        !            82:  */
        !            83: 
        !            84: int
        !            85: tgetflag (capname)
        !            86: char   *capname;
        !            87: {
        !            88:     char       *c;
        !            89: 
        !            90:     c = findcap (capname);
        !            91:     if (*c == '\0')
        !            92:        return (0);
        !            93:     else if (*c == '@')
        !            94:        return (-1);
        !            95:     else
        !            96:        return (1);
        !            97: }
        !            98: 
        !            99: 
        !           100: /*
        !           101:  * tgetnum:
        !           102:  *     return value of capname, -1 if not present, -2 if '@'ed.
        !           103:  */
        !           104: 
        !           105: int
        !           106: tgetnum (capname)
        !           107: char   *capname;
        !           108: {
        !           109:     char       *c;
        !           110:     int                val;
        !           111: 
        !           112:     c = findcap (capname);
        !           113:     if (*c == '@')
        !           114:        return (-2);
        !           115:     else if (*c != '\0') {
        !           116:        c++;    /* skip '#' */
        !           117:        val = 0;
        !           118:        while (isdigit (*c)) {
        !           119:            val = (val * 10) + (*c - '0');
        !           120:            c++;
        !           121:        }
        !           122:        return (val);
        !           123:     }
        !           124:     else
        !           125:        return (-1);
        !           126: }
        !           127: 
        !           128: 
        !           129: /*
        !           130:  * tgetstr:
        !           131:  *     store binary value of capname into value, store null if
        !           132:  *     not present, store "@" if '@'ed.
        !           133:  */
        !           134: 
        !           135: tgetstr (capname, value)
        !           136: char           *capname;
        !           137: register char  *value;
        !           138: {
        !           139:     register char      *c;
        !           140: 
        !           141:     c = findcap (capname);
        !           142:     if (*c == '@')
        !           143:        strcpy (value, "@");
        !           144:     else if (*c != '\0') {
        !           145:        c++;    /* skip '=' */
        !           146:        while ((*c) && (*c != ':')) {
        !           147:            if (*c == '^') {
        !           148:                c++;
        !           149:                if (islower (*c)) 
        !           150:                    *(value++) = toupper(*(c++)) - '@'; /* ascii dependent */
        !           151:                else
        !           152:                    *(value++) = *(c++) - '@';  /* ascii dependent */
        !           153:            }
        !           154:            else if (*c == '\\') {
        !           155:                c++;
        !           156:                switch (*c) {
        !           157:                    case 'E':
        !           158:                        *(value++) = '\033';
        !           159:                        c++;
        !           160:                        break;
        !           161:                    case 'n':
        !           162:                        *(value++) = '\n';
        !           163:                        c++;
        !           164:                        break;
        !           165:                    case 'r':
        !           166:                        *(value++) = '\r';
        !           167:                        c++;
        !           168:                        break;
        !           169:                    case 't':
        !           170:                        *(value++) = '\t';
        !           171:                        c++;
        !           172:                        break;
        !           173:                    case 'b':
        !           174:                        *(value++) = '\b';
        !           175:                        c++;
        !           176:                        break;
        !           177:                    case 'f':
        !           178:                        *(value++) = '\f';
        !           179:                        c++;
        !           180:                        break;
        !           181:                    default:
        !           182:                        if (isdigit (*c)) {     /* octal value */
        !           183:                            *value = '\0';
        !           184:                            while (isdigit (*c)) {
        !           185:                                *value = ((*value) * 8) + ((*c) - '0');
        !           186:                                c++;
        !           187:                            }
        !           188:                            value++;
        !           189:                        }
        !           190:                        else
        !           191:                            *(value++) = *(c++);
        !           192:                        break;
        !           193:                }
        !           194:            }
        !           195:            else
        !           196:                *(value++) = *(c++);
        !           197:        }
        !           198:        *value = '\0';
        !           199:     }
        !           200:     else
        !           201:        *value = '\0';
        !           202: }

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