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

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.