Annotation of MiNT/doc/xkey.c, revision 1.1.1.1

1.1       root        1: #include <stdio.h>
                      2: 
                      3: #include <ioctl.h>
                      4: 
                      5: #include <string.h>
                      6: 
                      7: 
                      8: 
                      9: #define MAXKEY 32
                     10: 
                     11: #ifndef TIOCGXKEY
                     12: 
                     13: #define TIOCGXKEY      (('T'<< 8) | 13)
                     14: 
                     15: #define TIOCSXKEY      (('T'<< 8) | 14)
                     16: 
                     17: #endif
                     18: 
                     19: 
                     20: 
                     21: struct xkey {
                     22: 
                     23:        short xk_num;
                     24: 
                     25:        char xk_def[8];
                     26: 
                     27: } xk;
                     28: 
                     29: 
                     30: 
                     31: char *kname[MAXKEY] = {
                     32: 
                     33: "f1", "f2", "f3", "f4", "f5", "f6", "f7", "f8", "f9", "f10",
                     34: 
                     35: "F1", "F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9", "F10",
                     36: 
                     37: "up", "down", "right", "left", "help", "undo", "insert", "home",
                     38: 
                     39: "UP", "DOWN", "RIGHT", "LEFT"
                     40: 
                     41: };
                     42: 
                     43: 
                     44: 
                     45: char buf[80];
                     46: 
                     47: 
                     48: 
                     49: char *unescape(char *string)
                     50: 
                     51: {
                     52: 
                     53:        char *u = buf;
                     54: 
                     55:        char c;
                     56: 
                     57: 
                     58: 
                     59:        while (c = *string++) {
                     60: 
                     61:                if (c == '\\') {
                     62: 
                     63:                        c = *string++;
                     64: 
                     65:                        if (!c) break;
                     66: 
                     67:                }
                     68: 
                     69:                else if (c == '^') {
                     70: 
                     71:                        c = *string++;
                     72: 
                     73:                        if (!c) break;
                     74: 
                     75:                        else if (c == '?') c = 127;
                     76: 
                     77:                        else c &= 0x1f;
                     78: 
                     79:                }
                     80: 
                     81:                *u++ = c;
                     82: 
                     83:        }
                     84: 
                     85:        *u++ = 0;
                     86: 
                     87:        return buf;
                     88: 
                     89: }
                     90: 
                     91: 
                     92: 
                     93: char *escape(char *string)
                     94: 
                     95: {
                     96: 
                     97:        char *e, c;
                     98: 
                     99: 
                    100: 
                    101:        e = buf;
                    102: 
                    103:        while ( c = *string++ ) {
                    104: 
                    105:                if (c < ' ' && c > 0) {
                    106: 
                    107:                        *e++ = '^';
                    108: 
                    109:                        c += '@';
                    110: 
                    111:                }
                    112: 
                    113:                else if (c == 127) {
                    114: 
                    115:                        *e++ = '^';
                    116: 
                    117:                        c = '?';
                    118: 
                    119:                }
                    120: 
                    121:                else if (c == '\\' || c == '^')
                    122: 
                    123:                        *e++ = '\\';
                    124: 
                    125:                *e++ = c;
                    126: 
                    127:        }
                    128: 
                    129:        *e++ = 0;
                    130: 
                    131:        return buf;
                    132: 
                    133: }
                    134: 
                    135: 
                    136: 
                    137: void
                    138: 
                    139: displaykeys()
                    140: 
                    141: {
                    142: 
                    143:        int i, r;
                    144: 
                    145:        int col = 0, maxcol;
                    146: 
                    147:        char *e;
                    148: 
                    149: 
                    150: 
                    151:        maxcol = 80;            /* really should do ioctl to get this */
                    152: 
                    153:        for (i = 0; i < MAXKEY; i++) {
                    154: 
                    155:                xk.xk_num = i;
                    156: 
                    157:                r = ioctl(0, TIOCGXKEY, &xk);
                    158: 
                    159:                if (r) {
                    160: 
                    161:                        perror("ioctl");
                    162: 
                    163:                        exit(1);
                    164: 
                    165:                }
                    166: 
                    167:                e = escape(xk.xk_def);
                    168: 
                    169:                col += (r = strlen(kname[i]) + strlen(e) + 2);
                    170: 
                    171:                if (col >= maxcol) {
                    172: 
                    173:                        printf("\n");
                    174: 
                    175:                        col = r;
                    176: 
                    177:                }
                    178: 
                    179:                printf("%s %s ", kname[i], e);
                    180: 
                    181:        }
                    182: 
                    183:        printf("\n");
                    184: 
                    185: }
                    186: 
                    187: 
                    188: 
                    189: void
                    190: 
                    191: definekey(char *key, char *def)
                    192: 
                    193: {
                    194: 
                    195:        int i;
                    196: 
                    197: 
                    198: 
                    199:        for (i = 0; i < MAXKEY; i++)
                    200: 
                    201:                if (!strcmp(kname[i], key)) break;
                    202: 
                    203:        if (i >= MAXKEY) {
                    204: 
                    205:                fprintf(stderr, "Unknown key: %s\n", key);
                    206: 
                    207:                return;
                    208: 
                    209:        }
                    210: 
                    211:        strncpy(xk.xk_def, unescape(def), 7);
                    212: 
                    213:        xk.xk_num = i;
                    214: 
                    215:        xk.xk_def[7] = 0;
                    216: 
                    217:        i = ioctl(0, TIOCSXKEY, &xk);
                    218: 
                    219:        if (i) {
                    220: 
                    221:                perror("ioctl");
                    222: 
                    223:        }
                    224: 
                    225: }
                    226: 
                    227: 
                    228: 
                    229: int
                    230: 
                    231: main(int argc, char **argv)
                    232: 
                    233: {
                    234: 
                    235:        char *progname;
                    236: 
                    237:        char *key, *def;
                    238: 
                    239: 
                    240: 
                    241:        progname = *argv++;
                    242: 
                    243: 
                    244: 
                    245:        if (!isatty(0)) {
                    246: 
                    247:                fprintf(stderr, "%s must be run on a terminal\n", progname);
                    248: 
                    249:                return 1;
                    250: 
                    251:        }
                    252: 
                    253:        if (!*argv) {
                    254: 
                    255:                displaykeys();
                    256: 
                    257:                return 0;
                    258: 
                    259:        }
                    260: 
                    261:        while (*argv) {
                    262: 
                    263:                key = *argv++;
                    264: 
                    265:                def = *argv++;
                    266: 
                    267:                if (!def) {
                    268: 
                    269:                        fprintf(stderr, "Usage: %s [key def]...\n", progname);
                    270: 
                    271:                        return 2;
                    272: 
                    273:                }
                    274: 
                    275:                definekey(key, def);
                    276: 
                    277:        }
                    278: 
                    279:        return 0;
                    280: 
                    281: }
                    282: 

unix.superglobalmegacorp.com

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