Return to fnkey.c CVS log

Up to [MW Coherent from dump] / coherent / d / bin

Annotation of coherent/d/bin/fnkey.c, revision 1.1

1.1     ! root        1: /*
        !             2:  *     fnkey.c
        !             3:  *     9/30/91
        !             4:  *     Usage:  fnkey [ n [ string ] ]
        !             5:  *     Sets/prints IBM AT console function keys.
        !             6:  *     Revised for COHERENT 3.2
        !             7:  */
        !             8: #include <stdio.h>
        !             9: #include <sgtty.h>
        !            10: #include <ctype.h>
        !            11: #include <sys/kb.h>
        !            12: #include <errno.h>
        !            13: 
        !            14: #define        VERSION "3.0"                   /* version number */
        !            15: /*
        !            16:  * The following constants were hard coded into the original kb.c driver
        !            17:  * and have to be duplicated here to support both drivers on demand.
        !            18:  */
        !            19: #define        NFKEY   20                      /* kb: number of function keys */
        !            20: #define        NFCHAR  150                     /* kb: function key storage */
        !            21: #define        NFBUF   (2*NFKEY+NFCHAR+1)      /* kb: total buffer size */
        !            22: 
        !            23: FNKEY  *okeys;                         /* old key bindings */
        !            24: FNKEY  *nkeys;                         /* new key bindings */
        !            25: int    old;                            /* true: kb driver, false: nkb */
        !            26: KBTBL  kbt[MAX_KEYS];                  /* key mapping table for TIOCGETKBT */
        !            27: 
        !            28: main(argc, argv)
        !            29: int argc;
        !            30: char **argv;
        !            31: {
        !            32:        unsigned c;
        !            33:        register int i;
        !            34:        register unsigned char *cp, *ncp;
        !            35:        int n, fd, max_fchar, max_fkeys;
        !            36: 
        !            37:        fd = open("/dev/console", 2);
        !            38:        if (fd == -1)
        !            39:                fatal("cannot open /dev/console");
        !            40:        okeys = (FNKEY *) malloc(sizeof(FNKEY) + MAX_FCHAR);
        !            41:        nkeys = (FNKEY *) malloc(sizeof(FNKEY) + MAX_FCHAR);
        !            42:        if (okeys == (FNKEY *)0 || nkeys == (FNKEY *)0)
        !            43:                fatal("out of memory");
        !            44:        cp =  &okeys->k_fnval[0];
        !            45:        ncp = &nkeys->k_fnval[0];
        !            46: 
        !            47:        /* Print version number if -V. */
        !            48:        if (*++argv != NULL && strcmp(*argv, "-V") == 0) {
        !            49:                --argc;
        !            50:                ++argv;
        !            51:                fprintf(stderr, "fnkey:  V%s\n", VERSION);
        !            52:        }
        !            53:        if (argc > 3)
        !            54:                usage();
        !            55: 
        !            56:        ioctl(fd, TIOCGETKBT, kbt);             /* See if nkb driver present */
        !            57:        if (errno)
        !            58:                ++old;                          /* No, kb assumed */
        !            59: 
        !            60:        errno = 0;
        !            61:        if (old) {                              /* get current key bindings */
        !            62:                ioctl(fd, TIOCGETF, okeys->k_fnval);    /* kb */
        !            63:                max_fchar = NFBUF;
        !            64:                max_fkeys = NFKEY;
        !            65:        } else {
        !            66:                ioctl(fd, TIOCGETF, okeys);             /* nkb */
        !            67:                max_fchar = MAX_FCHAR;
        !            68:                max_fkeys = MAX_FKEYS;
        !            69:        }
        !            70:        if (errno)
        !            71:                fatal("couldn't read current function key settings");
        !            72: 
        !            73:        /* Print current values if no args, then exit */
        !            74:        if (*argv == NULL ) {
        !            75:                if (old)
        !            76:                        kb_print();
        !            77:                else
        !            78:                        nkb_print();
        !            79:                exit(0);
        !            80:        }
        !            81: 
        !            82:        /* First arg must be digit. */
        !            83:        if (!isdigit(**argv))
        !            84:                usage();
        !            85:        n = atoi(*argv++);
        !            86:        if ((old && n > NFKEY) || (!old && n >= MAX_FKEYS))
        !            87:                usage();
        !            88:        if (old)
        !            89:                --n;
        !            90:        /* Set Fn to given value. */
        !            91:        for (i = 0; i < max_fkeys; i++) {
        !            92:                if (i == n) {
        !            93:                        if (*argv != NULL)
        !            94:                                while (c = *(*argv)++)
        !            95:                                        if (ncp < &nkeys->k_fnval[max_fchar]-1)
        !            96:                                                *ncp++ = c;
        !            97:                        while ((c = *cp++)!=DELIM && cp < &okeys->k_fnval[max_fchar])
        !            98:                                ;
        !            99:                } else {
        !           100:                        while ((c = *cp++)!=DELIM && cp < &okeys->k_fnval[max_fchar])
        !           101:                                if (ncp < &nkeys->k_fnval[max_fchar]-1)
        !           102:                                        *ncp++ = c;
        !           103:                }
        !           104:                *ncp++ = DELIM;
        !           105:                if (ncp >= &nkeys->k_fnval[max_fchar])
        !           106:                        break;
        !           107:        }
        !           108:        if (old) {
        !           109:                ioctl(fd, TIOCSETF, nkeys->k_fnval);    /* kb */
        !           110:        } else {
        !           111:                nkeys->k_nfkeys = i;
        !           112:                ioctl(fd, TIOCSETF, nkeys);             /* nkb */
        !           113:        }
        !           114:        if (errno)
        !           115:                fatal("couldn't set function keys");
        !           116: 
        !           117:        exit(0);
        !           118: }
        !           119: 
        !           120: printchar(c)
        !           121: register unsigned c;
        !           122: {
        !           123:        if (c == '\\')
        !           124:                printf("\\\\");
        !           125:        else if ((c >= ' ' && c <= '~') || c >= 0200)
        !           126:                putchar(c);
        !           127:        else switch (c) {
        !           128:        case '\n':      printf("\\n");
        !           129:                        break;
        !           130:        case '\t':      printf("\\t");
        !           131:                        break;
        !           132:        case '\b':      printf("\\b");
        !           133:                        break;
        !           134:        case '\r':      printf("\\r");
        !           135:                        break;
        !           136:        default:        printf("\\%03o", c);
        !           137:                        break;
        !           138:        }
        !           139: }
        !           140: 
        !           141: usage()
        !           142: {
        !           143:        fprintf(stderr, "Usage: fnkey [ n [ string ] ]\n");
        !           144:        exit(1);
        !           145: }
        !           146: 
        !           147: fatal(arg)
        !           148: char   *arg;
        !           149: {
        !           150:        fprintf(stderr, "fnkey:\t%r\n", &arg);
        !           151:        exit(1);
        !           152: }
        !           153: 
        !           154: /*
        !           155:  * Print out current settings of function key bindings.
        !           156:  * We do this two ways to support kb and nkb.
        !           157:  */
        !           158: kb_print()
        !           159: {
        !           160:        int i;
        !           161:        unsigned c;
        !           162:        unsigned char *cp;
        !           163: 
        !           164:        cp = &okeys->k_fnval[0];
        !           165:        for (i = 1; i <= NFKEY && cp < &okeys->k_fnval[NFBUF]; i++)  {
        !           166:                if ((c = *cp) == DELIM) {
        !           167:                        cp++;
        !           168:                        continue;
        !           169:                }
        !           170:                printf ("F%d:  ", i);
        !           171:                while ((c = *cp++) != DELIM && cp < &okeys->k_fnval[NFBUF]) 
        !           172:                        printchar(c);
        !           173:                putchar('\n');
        !           174:        }
        !           175: }
        !           176: 
        !           177: nkb_print()
        !           178: {
        !           179:        int i;
        !           180:        unsigned c;
        !           181:        unsigned char *cp;
        !           182: 
        !           183:        cp = &okeys->k_fnval[0];
        !           184:        for (i = 0; i<okeys->k_nfkeys && cp<&okeys->k_fnval[MAX_FCHAR]; i++)  {
        !           185:                if ((c = *cp) == DELIM) {
        !           186:                        cp++;
        !           187:                        continue;
        !           188:                }
        !           189:                printf ("F%d:  ", i);
        !           190:                while ((c = *cp++)!=DELIM && cp<&okeys->k_fnval[MAX_FCHAR]) 
        !           191:                        printchar(c);
        !           192:                putchar('\n');
        !           193:        }
        !           194: }
        !           195: /* end of fnkey.c */

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