![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to kbmain.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / kernel / tools|
Return to kbmain.c CVS log | Up to [MW Coherent from dump] / coherent / b / kernel / tools |
1.1 root 1: /*
2: * driver routine for loadable keyboard tables.
3: *
4: * prior to firing off the ioctl() which loads the new keyboard tables,
5: * permform some simple validity checks on the table.
6: * if errors are found, bail out without setting the new table.
7: *
8: * this version removes all references to stdio since we need to put over
9: * a dozen cooked keyboard tables on the boot disk - space is at a premium.
10: *
11: * Version 1.1, 6/25/91
12: */
13:
14: #include <sgtty.h>
15: #include <sys/kb.h>
16: #include <sys/kbscan.h>
17: #include <errno.h>
18: #include <sys/mdata.h>
19:
20: #define VERSION "1.1"
21: #define FALSE (0 != 0)
22: #define TRUE (0 == 0)
23: #define NULL ((char *)0)
24: #define putchar(c) { char b = c; write(1, &b, 1); }
25:
26: /*
27: * globals
28: */
29: char *argv0; /* name of this executable */
30: int errors; /* for exit status */
31: char verbose; /* step-by-step details */
32: char debug; /* print out cooked table & exit */
33: KBTBL table[MAX_KEYS]; /* cooked table for ioctl() */
34: FNKEY *arena; /* function key arena */
35: unsigned char fnbuffer[(sizeof(FNKEY) + MAX_FCHAR)]; /* function key area */
36:
37: /*
38: * The following table maps the specified key number to
39: * a scan code set 3 value.
40: * Note that K_14, K_65 through K_74 and K_107
41: * are provided for compatibility with
42: * the old XT layout AT keyboards.
43: */
44: unsigned char keyval[] = { /* code set 3 mapped value */
45: none, K_1, K_2, K_3, K_4, K_5, K_6, K_7,
46: K_8, K_9, K_10, K_11, K_12, K_13, K_14, K_15,
47: K_16, K_17, K_18, K_19, K_20, K_21, K_22, K_23,
48: K_24, K_25, K_26, K_27, K_28, K_29, K_30, K_31,
49: K_32, K_33, K_34, K_35, K_36, K_37, K_38, K_39,
50: K_40, K_41, K_42, K_43, K_44, K_45, K_46, K_47,
51: K_48, K_49, K_50, K_51, K_52, K_53, K_54, K_55,
52: none, K_57, K_58, none, K_60, K_61, K_62, none,
53: K_64, K_65, K_66, K_67, K_68, K_69, K_70, K_71,
54: K_72, K_73, K_74, K_75, K_76, none, none, K_79,
55: K_80, K_81, none, K_83, K_84, K_85, K_86, none,
56: none, K_89, K_90, K_91, K_92, K_93, none, K_95,
57: K_96, K_97, K_98, K_99, K_100, K_101, K_102, K_103,
58: K_104, K_105, K_106, K_107, K_108, none, K_110, none,
59: K_112, K_113, K_114, K_115, K_116, K_117, K_118, K_119,
60: K_120, K_121, K_122, K_123, K_124, K_125, K_126, none
61: };
62:
63: /*
64: * externs from user-defined keyboard table
65: */
66: extern KBTBL kbtbl[]; /* actual table */
67: extern char tbl_name[]; /* name of table as text */
68: extern unsigned char *funkey[]; /* function key definitions */
69: extern int numfun; /* # of function keys in tbl */
70: extern int numkey; /* number of keys in kbtbl[] */
71:
72: main(argc, argv)
73: char *argv[];
74: {
75: unsigned char *cp, *ncp;
76: int i, j;
77: int fd; /* console file descriptor */
78:
79: argv0 = argv[0];
80: arena = (FNKEY *) fnbuffer;
81:
82: if (argc > 1) {
83: if (strcmp(argv[1], "-V") == 0)
84: printf("Version %s\n", VERSION);
85: else if (strcmp(argv[1], "-D") == 0)
86: ++debug;
87: else
88: usage();
89: }
90:
91: if ((fd = open("/dev/console", 2)) < 0) {
92: err("unable to access console");
93: exit(errors);
94: }
95:
96: /*
97: * loop through the user's keyboard table validating each entry.
98: * if the entry is good, copy it to the destination table.
99: */
100: for (i = 0; i < numkey; ++i) { /* loop thru user's keys */
101: if (ok_entry(i)) {
102: j = kbtbl[i].k_key; /* map key */
103: table[j] = kbtbl[i]; /* copy entry */
104: } else
105: ++errors;
106: }
107:
108: if (errors)
109: exit(errors);
110: /*
111: * build a function key arena consisting of the user defined
112: * special and function keys.
113: */
114: ncp = arena->k_fnval;
115: for (i = 0; i < numfun; ++i) {
116: cp = funkey[i];
117: do {
118: if (ncp >= &arena->k_fnval[MAX_FCHAR]) {
119: err("function key table overflow");
120: exit(errors);
121: }
122: *ncp++ = *cp;
123: } while (*cp++ != DELIM);
124: }
125: arena->k_nfkeys = numfun;
126:
127: if (debug) {
128: dump(); /* print out cooked table */
129: exit(0);
130: }
131:
132: /*
133: * load the cooked keyboard table into the driver via a
134: * special ioctl() call.
135: */
136: ioctl(fd, TIOCSETKBT, table);
137: if (errno) {
138: err("keyboard table ioctl() failed, errno=%d", errno);
139: exit(errors);
140: }
141:
142: /*
143: * load the cooked function key table into the driver via a
144: * special ioctl() call.
145: */
146: ioctl(fd, TIOCSETF, arena);
147: if (errno) {
148: err("function key ioctl() failed, errno=%d", errno);
149: exit(errors);
150: }
151:
152: printf("Loaded %s\n", tbl_name);
153: close(fd);
154: exit(errors);
155: }
156:
157: /*
158: * validate a table entry
159: */
160: ok_entry(n)
161: register int n;
162: {
163: int i;
164: int key = lookup(kbtbl[n].k_key);
165: unsigned char kval;
166:
167: if (!key) {
168: err("invalid key #0x%x in kbtbl[%d]", kbtbl[n].k_key, n);
169: return FALSE;
170: }
171: if ((kbtbl[n].k_flags & (S|F)) == (S|F)) {
172: err("invalid flag field for key K_%d", key);
173: return FALSE;
174: }
175: if (kbtbl[n].k_flags & S) {
176: for (i = BASE; i <= ALT_GR; ++i) {
177: kval = kbtbl[n].k_val[i];
178: if (kval != kbtbl[n].k_val[BASE]) {
179: err("inconsistent shift key entry for K_%d",
180: key);
181: return FALSE;
182: }
183: if (kval < scroll || kval > altgr) {
184: err("bad shift key entry for K_%d",
185: key);
186: return FALSE;
187: }
188: } /* for */
189: } else if (kbtbl[n].k_flags & F) {
190: for (i = BASE; i <= ALT_GR; ++i) {
191: kval = kbtbl[n].k_val[i];
192: if (kval != none)
193: if (kval >= numfun
194: && !VTKEY(kval) /* && kval != fgk*/) {
195: printf("val=%d\n", kval);
196: err("bad function key entry K_%d",
197: key);
198: return FALSE;
199: }
200: } /* for */
201: } /* flag key */
202:
203: if (table[kbtbl[n].k_key].k_key != 0) {
204: err("multiple entries for K_%d", key);
205: return FALSE;
206: }
207: return TRUE;
208: }
209:
210: /*
211: * lookup the physical key number associated with a given
212: * code set 3 scan code.
213: *
214: * return 0 if not found.
215: */
216: lookup(sc)
217: unsigned sc;
218: {
219: register int i;
220:
221: if (sc == none)
222: return 0;
223: for (i = 0; i < sizeof(keyval)/sizeof(keyval[0]); ++i)
224: if (keyval[i] == (unsigned char)sc)
225: return (i);
226: return 0;
227: }
228:
229: usage()
230: {
231: printf("usage:\t%s [-V]\n", argv0);
232: exit(1);
233: }
234:
235: err(msg)
236: char *msg;
237: {
238: printf("%s: ERROR: %r\n", argv0, &msg);
239: ++errors;
240: }
241:
242: /*
243: * dump the cooked keyboard table to stdout
244: */
245: dump()
246: {
247: int i, j;
248:
249: for (i = 0; i < MAX_KEYS; ++i) {
250: printf("%02x: %02x ", i, table[i].k_key);
251: for (j = 0; j < 9; ++j)
252: printf("%02x ", table[i].k_val[j]);
253: printf("(%02x)\n", table[i].k_flags);
254: }
255: }
256:
257:
258: /*
259: * Simple standard output printf() using single character writes to stdout.
260: *
261: * Non-portable things:
262: * 1) alignment of arguments is assumed to be completely contiguous.
263: * 2) the smallest number is assumed to negate to itself.
264: * be held in an exact number of ints.
265: */
266: union alltypes {
267: char c;
268: int i;
269: unsigned u;
270: char *s;
271: };
272:
273: #define bump(p,s) (p+=sizeof(s)/sizeof(int))
274:
275: char *printi();
276:
277: static char null[] = "{NULL}";
278:
279: printf(args)
280: union alltypes args;
281: {
282: xprintf(&args);
283: }
284: xprintf(argp)
285: union alltypes *argp;
286: {
287: register char *cbp;
288: int *iap;
289: register c;
290: char *s;
291: char *cbs;
292: char adj, pad;
293: int prec;
294: int fwidth;
295: int pwidth;
296: register char *fmt;
297: union alltypes elem;
298: char cbuf[64];
299:
300: iap = (int *)argp;
301: fmt = *(char **)iap;
302: bump(iap, char*);
303: for (;;) {
304: while((c = *fmt++) != '%') {
305: if(c == '\0') {
306: return;
307: }
308: putchar(c);
309: }
310: pad = ' ';
311: fwidth = -1;
312: prec = -1;
313: c = *fmt++;
314: if (c == '-') {
315: adj = 1;
316: c = *fmt++;
317: } else
318: adj = 0;
319: if (c == '0') {
320: pad = '0';
321: c = *fmt++;
322: }
323: if (c == '*') {
324: fwidth = *iap++;
325: c = *fmt++;
326: } else
327: for (fwidth = 0; c>='0' && c<='9'; c = *fmt++)
328: fwidth = fwidth*10 + c-'0';
329: if (c == '.') {
330: c = *fmt++;
331: if (c == '*') {
332: prec = *iap++;
333: c = *fmt++;
334: } else
335: for (prec=0; c >= '0' && c <= '9'; c = *fmt++)
336: prec = prec*10 + c-'0';
337: }
338: cbp = cbs = cbuf;
339: switch (c) {
340:
341: case 'd':
342: elem.i = *iap++;
343: if (elem.i < 0) {
344: elem.i = -elem.i;
345: *cbp++ = '-';
346: }
347: cbp = printi(cbp, elem.i, 10);
348: break;
349:
350: case 'u':
351: cbp = printi(cbp, *iap++, 10);
352: break;
353:
354: case 'o':
355: cbp = printi(cbp, *iap++, 8);
356: break;
357:
358: case 'x':
359: cbp = printi(cbp, *iap++, 16);
360: break;
361:
362: case 's':
363: if ((s = *(char **)iap) == NULL)
364: s = null;
365: bump(iap, char*);
366: /*
367: * Do %s specially so it can be longer.
368: */
369: cbp = cbs = s;
370: while (*cbp++ != '\0')
371: if (prec>=0 && cbp-s>prec)
372: break;
373: cbp--;
374: break;
375:
376: case 'c':
377: elem.c = *iap++;
378: *cbp++ = elem.c;
379: break;
380:
381: case 'r':
382: xprintf(*(char ***)iap);
383: bump(iap, char**);
384: break;
385:
386: default:
387: putchar(c);
388: continue;
389: }
390: if ((pwidth = fwidth + cbs-cbp) < 0)
391: pwidth = 0;
392: if (!adj)
393: while (pwidth-- != 0)
394: putchar(pad);
395: while (cbs < cbp)
396: putchar(*cbs++);
397: if (adj)
398: while (pwidth-- != 0)
399: putchar(pad);
400: }
401: }
402:
403: static char digits[] = {
404: '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
405: 'A', 'B', 'C', 'D', 'E', 'F'
406: };
407:
408: /*
409: * Print an unsigned integer in base b.
410: */
411: static
412: char *
413: printi(cp, n, b)
414: char *cp;
415: register unsigned n;
416: {
417: register a;
418: register char *ep;
419: char pbuf[10];
420:
421: ep = &pbuf[10];
422: *--ep = 0;
423: for ( ; a = n/b; n=a)
424: *--ep = digits[n%b];
425: *--ep = digits[n];
426: while (*ep)
427: *cp++ = *ep++;
428: return (cp);
429: }
430:
431: /* end of kbmain.c */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.