1 %{
2 /*
3 * CDDL HEADER START
4 *
5 * The contents of this file are subject to the terms of the
6 * Common Development and Distribution License, Version 1.0 only
7 * (the "License"). You may not use this file except in compliance
8 * with the License.
9 *
10 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
11 * or http://www.opensolaris.org/os/licensing.
12 * See the License for the specific language governing permissions
13 * and limitations under the License.
14 *
15 * When distributing Covered Code, include this CDDL HEADER in each
16 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
17 * If applicable, add the following below this CDDL HEADER, with the
18 * fields enclosed by brackets "[]" replaced with your own identifying
19 * information: Portions Copyright [yyyy] [name of copyright owner]
20 *
21 * CDDL HEADER END
22 */
23
24 /*
25 * Copyright (c) 1999 by Sun Microsystems, Inc.
26 * All rights reserved.
27 */
28
29 #include <sys/param.h>
30 #include <ctype.h>
31 #include <stdio.h>
32 #include <search.h>
33 #include <string.h>
34 #include <malloc.h>
35 #include <fcntl.h>
36 #include <stdlib.h>
37 #include <errno.h>
38 #include <unistd.h>
39 #include <sys/kbd.h>
40 #include <sys/kbio.h>
41
42 #define ALL -1 /* special symbol for all tables */
43
44 static char keytable_dir[] = "/usr/share/lib/keytables/type_%d/";
45 static char layout_prefix[] = "layout_";
46
47 struct keyentry {
48 struct keyentry *ke_next;
49 struct kiockeymap ke_entry;
50 };
51
52 typedef struct keyentry keyentry;
53
54 static keyentry *firstentry;
55 static keyentry *lastentry;
56
57 struct dupentry {
58 struct dupentry *de_next;
59 int de_station;
60 int de_otherstation;
61 };
62
63 typedef struct dupentry dupentry;
64
65 static dupentry *firstduplicate;
66 static dupentry *lastduplicate;
67
68 static dupentry *firstswap;
69 static dupentry *lastswap;
70
71 static char *infilename;
72 static FILE *infile;
73 static int lineno;
74 static int begline;
75
76 static char *strings[16] = {
77 "\033[H", /* HOMEARROW */
78 "\033[A", /* UPARROW */
79 "\033[B", /* DOWNARROW */
80 "\033[D", /* LEFTARROW */
81 "\033[C", /* RIGHTARROW */
82 };
83
84 static int nstrings = 5; /* start out with 5 strings */
85
86 typedef enum {
87 SM_INVALID, /* this shift mask is invalid for this keyboard */
88 SM_NORMAL, /* "normal", valid shift mask */
89 SM_NUMLOCK, /* "Num Lock" shift mask */
90 SM_UP /* "Up" shift mask */
91 } smtype_t;
92
93 typedef struct {
94 int sm_mask;
95 smtype_t sm_type;
96 } smentry_t;
97
98 static smentry_t shiftmasks[] = {
99 { 0, SM_NORMAL },
100 { SHIFTMASK, SM_NORMAL },
101 { CAPSMASK, SM_NORMAL },
102 { CTRLMASK, SM_NORMAL },
103 { ALTGRAPHMASK, SM_NORMAL },
104 { NUMLOCKMASK, SM_NUMLOCK },
105 { UPMASK, SM_UP },
106 };
107
108
109 #define NSHIFTS (sizeof (shiftmasks) / sizeof (shiftmasks[0]))
110
111 static void enter_mapentry(int station, keyentry *entrylistp);
112 static keyentry *makeentry(int tablemask, int entry);
113 static int loadkey(int kbdfd, keyentry *kep);
114 static int dupkey(int kbdfd, dupentry *dep, int shiftmask);
115 static int swapkey(int kbdfd, dupentry *dep, int shiftmask);
116 static int yylex();
117 extern int yyparse(void);
118 static int readesc(FILE *stream, int delim, int single_char);
119 static int wordcmp(const void *w1, const void *w2);
120 static int yyerror(char *msg);
121 static void usage(void);
122 static void set_layout(char *arg);
123 static FILE *open_mapping_file(char *pathbuf, char *name,
124 boolean_t explicit_name, int type);
125
126 int
127 main(int argc, char **argv)
128 {
129 int kbdfd;
130 int type;
131 int layout;
132 /* maxint is 8 hex digits. */
133 char layout_filename[sizeof(layout_prefix)+8];
134 char pathbuf[MAXPATHLEN];
135 int shift;
136 struct kiockeymap mapentry;
137 keyentry *kep;
138 dupentry *dep;
139 boolean_t explicit_name;
140
141 while(++argv, --argc) {
142 if(argv[0][0] != '-') break;
143 switch(argv[0][1]) {
144 case 'e':
145 /* -e obsolete, silently ignore */
146 break;
147 case 's':
148 if (argc != 2) {
149 usage();
150 /* NOTREACHED */
151 }
152 set_layout(argv[1]);
153 exit(0);
154 default:
155 usage();
156 /* NOTREACHED */
157 }
158 }
159
160 if (argc > 1) usage();
161
162 if ((kbdfd = open("/dev/kbd", O_WRONLY)) < 0) {
163 /* perror("loadkeys: /dev/kbd"); */
164 return (1);
165 }
166
167 if (ioctl(kbdfd, KIOCTYPE, &type) < 0) {
168 /*
169 * There may not be a keyboard connected,
170 * return silently
171 */
172 return (1);
173 }
174
175 if (argc == 0) {
176 /* If no keyboard detected, exit silently. */
177 if (type == -1)
178 return (0);
179
180 if (ioctl(kbdfd, KIOCLAYOUT, &layout) < 0) {
181 perror("loadkeys: ioctl(KIOCLAYOUT)");
182 return (1);
183 }
184
185 (void) sprintf(layout_filename,
186 "%s%.2x", layout_prefix, layout);
187 infilename = layout_filename;
188 explicit_name = B_FALSE;
189 } else {
190 infilename = argv[0];
191 explicit_name = B_TRUE;
192 }
193
194 infile = open_mapping_file(pathbuf, infilename, explicit_name, type);
195 if (infile == NULL) return (1);
196
197 infilename = pathbuf;
198
199 lineno = 0;
200 begline = 1;
201 yyparse();
202 fclose(infile);
203
204 /*
205 * See which shift masks are valid for this keyboard.
206 * We do that by trying to get the entry for keystation 0 and that
207 * shift mask; if the "ioctl" fails, we assume it's because the shift
208 * mask is invalid.
209 */
210 for (shift = 0; shift < NSHIFTS; shift++) {
211 mapentry.kio_tablemask =
212 shiftmasks[shift].sm_mask;
213 mapentry.kio_station = 0;
214 if (ioctl(kbdfd, KIOCGKEY, &mapentry) < 0)
215 shiftmasks[shift].sm_type = SM_INVALID;
216 }
217
218 for (kep = firstentry; kep != NULL; kep = kep->ke_next) {
219 if (kep->ke_entry.kio_tablemask == ALL) {
220 for (shift = 0; shift < NSHIFTS; shift++) {
221 switch (shiftmasks[shift].sm_type) {
222
223 case SM_INVALID:
224 continue;
225
226 case SM_NUMLOCK:
227 /*
228 * Defaults to NONL, not to a copy of
229 * the base entry.
230 */
231 if (kep->ke_entry.kio_entry != HOLE)
232 kep->ke_entry.kio_entry = NONL;
233 break;
234
235 case SM_UP:
236 /*
237 * Defaults to NOP, not to a copy of
238 * the base entry.
239 */
240 if (kep->ke_entry.kio_entry != HOLE)
241 kep->ke_entry.kio_entry = NOP;
242 break;
243 }
244 kep->ke_entry.kio_tablemask =
245 shiftmasks[shift].sm_mask;
246 if (!loadkey(kbdfd, kep))
247 return (1);
248 }
249 } else {
250 if (!loadkey(kbdfd, kep))
251 return (1);
252 }
253 }
254
255 for (dep = firstswap; dep != NULL; dep = dep->de_next) {
256 for (shift = 0; shift < NSHIFTS; shift++) {
257 if (shiftmasks[shift].sm_type != SM_INVALID) {
258 if (!swapkey(kbdfd, dep,
259 shiftmasks[shift].sm_mask))
260 return (0);
261 }
262 }
263 }
264
265 for (dep = firstduplicate; dep != NULL; dep = dep->de_next) {
266 for (shift = 0; shift < NSHIFTS; shift++) {
267 if (shiftmasks[shift].sm_type != SM_INVALID) {
268 if (!dupkey(kbdfd, dep,
269 shiftmasks[shift].sm_mask))
270 return (0);
271 }
272 }
273 }
274
275 close(kbdfd);
276 return (0);
277 }
278
279 static void
280 usage()
281 {
282 (void) fprintf(stderr, "usage: loadkeys [ file ]\n");
283 exit(1);
284 }
285
286 static void
287 set_layout(char *arg)
288 {
289 int layout;
290 int ret;
291 int kbdfd;
292
293 layout = (int) strtol(arg, &arg, 0);
294 if (*arg != '\0') {
295 fprintf(stderr, "usage: loadkeys -s layoutnumber\n");
296 exit(1);
297 }
298
299 if ((kbdfd = open("/dev/kbd", O_WRONLY)) < 0) {
300 perror("/dev/kbd");
301 exit(1);
302 }
303
304 ret = ioctl(kbdfd, KIOCSLAYOUT, layout);
305 if (ret == -1) {
306 perror("KIOCSLAYOUT");
307 }
308
309 close(kbdfd);
310 }
311
312 /*
313 * Attempt to find the specified mapping file. Return a FILE * if found,
314 * else print a message on stderr and return NULL.
315 */
316 FILE *
317 open_mapping_file(char *pathbuf, char *name, boolean_t explicit_name, int type)
318 {
319 /* If the user specified the name, try it "raw". */
320 if (explicit_name) {
321 strcpy(pathbuf, name);
322 infile = fopen(pathbuf, "r");
323 if (infile) return (infile);
324 if (errno != ENOENT) goto fopen_fail;
325 }
326
327 /* Everything after this point applies only to relative names. */
328 if (*name == '/') goto fopen_fail;
329
330 /* Try the type-qualified directory name. */
331 sprintf(pathbuf, keytable_dir, type);
332 if ((int)(strlen(pathbuf) + strlen(name) + 1) >= MAXPATHLEN) {
333 (void) fprintf(stderr, "loadkeys: Name %s is too long\n",
334 name);
335 return (NULL);
336 }
337 (void) strcat(pathbuf, name);
338 if ((infile = fopen(pathbuf, "r")) != NULL)
339 return (infile);
340
341 fopen_fail:
342 (void) fprintf(stderr, "loadkeys: ");
343 perror(name);
344 return (NULL);
345 }
346
347 /*
348 * We have a list of entries for a given keystation, and the keystation number
349 * for that keystation; put that keystation number into all the entries in that
350 * list, and chain that list to the end of the main list of entries.
351 */
352 static void
353 enter_mapentry(station, entrylistp)
354 int station;
355 keyentry *entrylistp;
356 {
357 register keyentry *kep;
358
359 if (lastentry == NULL)
360 firstentry = entrylistp;
361 else
362 lastentry->ke_next = entrylistp;
363 kep = entrylistp;
364 for (;;) {
365 kep->ke_entry.kio_station = (u_char)station;
366 if (kep->ke_next == NULL) {
367 lastentry = kep;
368 break;
369 }
370 kep = kep->ke_next;
371 }
372 }
373
374 /*
375 * Allocate and fill in a new entry.
376 */
377 static keyentry *
378 makeentry(tablemask, entry)
379 int tablemask;
380 int entry;
381 {
382 register keyentry *kep;
383 register int index;
384
385 if ((kep = (keyentry *) malloc((unsigned)sizeof (keyentry))) == NULL)
386 yyerror("out of memory for entries");
387 kep->ke_next = NULL;
388 kep->ke_entry.kio_tablemask = tablemask;
389 kep->ke_entry.kio_station = 0;
390 kep->ke_entry.kio_entry = entry;
391 index = entry - STRING;
392 if (index >= 0 && index <= 15)
393 (void) strncpy(kep->ke_entry.kio_string, strings[index],
394 KTAB_STRLEN);
395 return (kep);
396 }
397
398 /*
399 * Make a set of entries for a keystation that indicate that that keystation's
400 * settings should be copied from another keystation's settings.
401 */
402 static void
403 duplicate_mapentry(station, otherstation)
404 int station;
405 int otherstation;
406 {
407 register dupentry *dep;
408
409 if ((dep = (dupentry *) malloc((unsigned)sizeof (dupentry))) == NULL)
410 yyerror("out of memory for entries");
411
412 if (lastduplicate == NULL)
413 firstduplicate = dep;
414 else
415 lastduplicate->de_next = dep;
416 lastduplicate = dep;
417 dep->de_next = NULL;
418 dep->de_station = station;
419 dep->de_otherstation = otherstation;
420 }
421
422 /*
423 * Make a set of entries for a keystation that indicate that that keystation's
424 * settings should be swapped with another keystation's settings.
425 */
426 static void
427 swap_mapentry(station, otherstation)
428 int station;
429 int otherstation;
430 {
431 register dupentry *dep;
432
433 if ((dep = (dupentry *) malloc((unsigned)sizeof (dupentry))) == NULL)
434 yyerror("out of memory for entries");
435
436 if (lastswap == NULL)
437 firstswap = dep;
438 else
439 lastswap->de_next = dep;
440 lastswap = dep;
441 dep->de_next = NULL;
442 dep->de_station = station;
443 dep->de_otherstation = otherstation;
444 }
445
446 static int
447 loadkey(kbdfd, kep)
448 int kbdfd;
449 register keyentry *kep;
450 {
451 if (ioctl(kbdfd, KIOCSKEY, &kep->ke_entry) < 0) {
452 perror("loadkeys: ioctl(KIOCSKEY)");
453 return (0);
454 }
455 return (1);
456 }
457
458 static int
459 dupkey(kbdfd, dep, shiftmask)
460 int kbdfd;
461 register dupentry *dep;
462 int shiftmask;
463 {
464 struct kiockeymap entry;
465
466 entry.kio_tablemask = shiftmask;
467 entry.kio_station = dep->de_otherstation;
468 if (ioctl(kbdfd, KIOCGKEY, &entry) < 0) {
469 perror("loadkeys: ioctl(KIOCGKEY)");
470 return (0);
471 }
472 entry.kio_station = dep->de_station;
473 if (ioctl(kbdfd, KIOCSKEY, &entry) < 0) {
474 perror("loadkeys: ioctl(KIOCSKEY)");
475 return (0);
476 }
477 return (1);
478 }
479
480
481
482 static int
483 swapkey(kbdfd, dep, shiftmask)
484 int kbdfd;
485 register dupentry *dep;
486 int shiftmask;
487 {
488 struct kiockeymap entry1, entry2;
489
490 entry1.kio_tablemask = shiftmask;
491 entry1.kio_station = dep->de_station;
492 if (ioctl(kbdfd, KIOCGKEY, &entry1) < 0) {
493 perror("loadkeys: ioctl(KIOCGKEY)");
494 return (0);
495 }
496 entry2.kio_tablemask = shiftmask;
497 entry2.kio_station = dep->de_otherstation;
498 if (ioctl(kbdfd, KIOCGKEY, &entry2) < 0) {
499 perror("loadkeys: ioctl(KIOCGKEY)");
500 return (0);
501 }
502 entry1.kio_station = dep->de_otherstation;
503 if (ioctl(kbdfd, KIOCSKEY, &entry1) < 0) {
504 perror("loadkeys: ioctl(KIOCSKEY)");
505 return (0);
506 }
507 entry2.kio_station = dep->de_station;
508 if (ioctl(kbdfd, KIOCSKEY, &entry2) < 0) {
509 perror("loadkeys: ioctl(KIOCSKEY)");
510 return (0);
511 }
512 return (1);
513 }
514 %}
515
516 %term TABLENAME INT CHAR CHARSTRING CONSTANT FKEY KEY SAME AS SWAP WITH
517
518 %union {
519 keyentry *keyentry;
520 int number;
521 };
522
523 %type <keyentry> entrylist entry
524 %type <number> CHARSTRING CHAR INT CONSTANT FKEY TABLENAME
525 %type <number> code expr term number
526
527 %%
528
529 table:
530 table line
531 | /* null */
532 ;
533
534 line:
535 KEY number entrylist '\n'
536 {
537 enter_mapentry($2, $3);
538 }
539 | KEY number SAME AS number '\n'
540 {
541 duplicate_mapentry($2, $5);
542 }
543 | SWAP number WITH number '\n'
544 {
545 swap_mapentry($2, $4);
546 }
547 | '\n'
548 ;
549
550 entrylist:
551 entrylist entry
552 {
553 /*
554 * Append this entry to the end of the entry list.
555 */
556 register keyentry *kep;
557 kep = $1;
558 for (;;) {
559 if (kep->ke_next == NULL) {
560 kep->ke_next = $2;
561 break;
562 }
563 kep = kep->ke_next;
564 }
565 $$ = $1;
566 }
567 | entry
568 {
569 $$ = $1;
570 }
571 ;
572
573 entry:
574 TABLENAME code
575 {
576 $$ = makeentry($1, $2);
577 }
578 ;
579
580 code:
581 CHARSTRING
582 {
583 $$ = $1;
584 }
585 | CHAR
586 {
587 $$ = $1;
588 }
589 | INT
590 {
591 $$ = $1;
592 }
593 | '('
594 {
595 $$ = '(';
596 }
597 | ')'
598 {
599 $$ = ')';
600 }
601 | '+'
602 {
603 $$ = '+';
604 }
605 | expr
606 {
607 $$ = $1;
608 }
609 ;
610
611 expr:
612 term
613 {
614 $$ = $1;
615 }
616 | expr '+' term
617 {
618 $$ = $1 + $3;
619 }
620 ;
621
622 term:
623 CONSTANT
624 {
625 $$ = $1;
626 }
627 | FKEY '(' number ')'
628 {
629 if ($3 < 1 || $3 > 16)
630 yyerror("invalid function key number");
631 $$ = $1 + $3 - 1;
632 }
633 ;
634
635 number:
636 INT
637 {
638 $$ = $1;
639 }
640 | CHAR
641 {
642 if (isdigit($1))
643 $$ = $1 - '0';
644 else
645 yyerror("syntax error");
646 }
647 ;
648
649 %%
650
651 typedef struct {
652 char *w_string;
653 int w_type; /* token type */
654 int w_lval; /* yylval for this token */
655 } word_t;
656
657 /*
658 * Table must be in alphabetical order.
659 */
660 word_t wordtab[] = {
661 { "all", TABLENAME, ALL },
662 { "alt", CONSTANT, ALT },
663 { "altg", TABLENAME, ALTGRAPHMASK },
664 { "altgraph", CONSTANT, ALTGRAPH },
665 { "as", AS, 0 },
666 { "base", TABLENAME, 0 },
667 { "bf", FKEY, BOTTOMFUNC },
668 { "buckybits", CONSTANT, BUCKYBITS },
669 { "caps", TABLENAME, CAPSMASK },
670 { "capslock", CONSTANT, CAPSLOCK },
671 { "compose", CONSTANT, COMPOSE },
672 { "ctrl", TABLENAME, CTRLMASK },
673 { "downarrow", CONSTANT, DOWNARROW },
674 { "error", CONSTANT, ERROR },
675 { "fa_acute", CONSTANT, FA_ACUTE },
676 { "fa_apostrophe", CONSTANT, FA_APOSTROPHE },
677 { "fa_breve", CONSTANT, FA_BREVE },
678 { "fa_caron", CONSTANT, FA_CARON },
679 { "fa_cedilla", CONSTANT, FA_CEDILLA },
680 { "fa_cflex", CONSTANT, FA_CFLEX },
681 { "fa_dacute", CONSTANT, FA_DACUTE },
682 { "fa_dot", CONSTANT, FA_DOT },
683 { "fa_grave", CONSTANT, FA_GRAVE },
684 { "fa_macron", CONSTANT, FA_MACRON },
685 { "fa_ogonek", CONSTANT, FA_OGONEK },
686 { "fa_ring", CONSTANT, FA_RING },
687 { "fa_slash", CONSTANT, FA_SLASH },
688 { "fa_tilde", CONSTANT, FA_TILDE },
689 { "fa_umlaut", CONSTANT, FA_UMLAUT },
690 { "hole", CONSTANT, HOLE },
691 { "homearrow", CONSTANT, HOMEARROW },
692 { "idle", CONSTANT, IDLE },
693 { "key", KEY, 0 },
694 { "leftarrow", CONSTANT, LEFTARROW },
695 { "leftctrl", CONSTANT, LEFTCTRL },
696 { "leftshift", CONSTANT, LEFTSHIFT },
697 { "lf", FKEY, LEFTFUNC },
698 { "metabit", CONSTANT, METABIT },
699 { "nonl", CONSTANT, NONL },
700 { "nop", CONSTANT, NOP },
701 { "numl", TABLENAME, NUMLOCKMASK },
702 { "numlock", CONSTANT, NUMLOCK },
703 { "oops", CONSTANT, OOPS },
704 { "pad0", CONSTANT, PAD0 },
705 { "pad1", CONSTANT, PAD1 },
706 { "pad2", CONSTANT, PAD2 },
707 { "pad3", CONSTANT, PAD3 },
708 { "pad4", CONSTANT, PAD4 },
709 { "pad5", CONSTANT, PAD5 },
710 { "pad6", CONSTANT, PAD6 },
711 { "pad7", CONSTANT, PAD7 },
712 { "pad8", CONSTANT, PAD8 },
713 { "pad9", CONSTANT, PAD9 },
714 { "paddot", CONSTANT, PADDOT },
715 { "padenter", CONSTANT, PADENTER },
716 { "padequal", CONSTANT, PADEQUAL },
717 { "padminus", CONSTANT, PADMINUS },
718 { "padplus", CONSTANT, PADPLUS },
719 { "padsep", CONSTANT, PADSEP },
720 { "padslash", CONSTANT, PADSLASH },
721 { "padstar", CONSTANT, PADSTAR },
722 { "reset", CONSTANT, RESET },
723 { "rf", FKEY, RIGHTFUNC },
724 { "rightarrow", CONSTANT, RIGHTARROW },
725 { "rightctrl", CONSTANT, RIGHTCTRL },
726 { "rightshift", CONSTANT, RIGHTSHIFT },
727 { "same", SAME, 0 },
728 { "shift", TABLENAME, SHIFTMASK },
729 { "shiftkeys", CONSTANT, SHIFTKEYS },
730 { "shiftlock", CONSTANT, SHIFTLOCK },
731 { "string", CONSTANT, STRING },
732 { "swap", SWAP, 0 },
733 { "systembit", CONSTANT, SYSTEMBIT },
734 { "tf", FKEY, TOPFUNC },
735 { "up", TABLENAME, UPMASK },
736 { "uparrow", CONSTANT, UPARROW },
737 { "with", WITH, 0 },
738 };
739
740 #define NWORDS (sizeof (wordtab) / sizeof (wordtab[0]))
741
742 static int
743 yylex()
744 {
745 register int c;
746 char tokbuf[256+1];
747 register char *cp;
748 register int tokentype;
749
750 while ((c = getc(infile)) == ' ' || c == '\t')
751 ;
752 if (begline) {
753 lineno++;
754 begline = 0;
755 if (c == '#') {
756 while ((c = getc(infile)) != EOF && c != '\n')
757 ;
758 }
759 }
760 if (c == EOF)
761 return (0); /* end marker */
762 if (c == '\n') {
763 begline = 1;
764 return (c);
765 }
766
767 switch (c) {
768
769 case '\'':
770 tokentype = CHAR;
771 if ((c = getc(infile)) == EOF)
772 yyerror("unterminated character constant");
773 if (c == '\n') {
774 (void) ungetc(c, infile);
775 yylval.number = '\'';
776 } else {
777 switch (c) {
778
779 case '\'':
780 yyerror("null character constant");
781 break;
782
783 case '\\':
784 yylval.number = readesc(infile, '\'', 1);
785 break;
786
787 default:
788 yylval.number = c;
789 break;
790 }
791 if ((c = getc(infile)) == EOF || c == '\n')
792 yyerror("unterminated character constant");
793 else if (c != '\'')
794 yyerror("only one character allowed in character constant");
795 }
796 break;
797
798 case '"':
799 if ((c = getc(infile)) == EOF)
800 yyerror("unterminated string constant");
801 if (c == '\n') {
802 (void) ungetc(c, infile);
803 tokentype = CHAR;
804 yylval.number = '"';
805 } else {
806 tokentype = CHARSTRING;
807 cp = &tokbuf[0];
808 do {
809 if (cp > &tokbuf[256])
810 yyerror("line too long");
811 if (c == '\\')
812 c = readesc(infile, '"', 0);
813 *cp++ = (char)c;
814 } while ((c = getc(infile)) != EOF && c != '\n' &&
815 c != '"');
816 if (c != '"')
817 yyerror("unterminated string constant");
818 *cp = '\0';
819 if (nstrings == 16)
820 yyerror("too many strings");
821 if ((int) strlen(tokbuf) > KTAB_STRLEN)
822 yyerror("string too long");
823 strings[nstrings] = strdup(tokbuf);
824 yylval.number = STRING+nstrings;
825 nstrings++;
826 }
827 break;
828
829 case '(':
830 case ')':
831 case '+':
832 tokentype = c;
833 break;
834
835 case '^':
836 if ((c = getc(infile)) == EOF)
837 yyerror("missing newline at end of line");
838 tokentype = CHAR;
839 if (c == ' ' || c == '\t' || c == '\n') {
840 /*
841 * '^' by itself.
842 */
843 yylval.number = '^';
844 } else {
845 yylval.number = c & 037;
846 if ((c = getc(infile)) == EOF)
847 yyerror("missing newline at end of line");
848 if (c != ' ' && c != '\t' && c != '\n')
849 yyerror("invalid control character");
850 }
851 (void) ungetc(c, infile);
852 break;
853
854 default:
855 cp = &tokbuf[0];
856 do {
857 if (cp > &tokbuf[256])
858 yyerror("line too long");
859 *cp++ = (char)c;
860 } while ((c = getc(infile)) != EOF && (isalnum(c) || c == '_'));
861 if (c == EOF)
862 yyerror("newline missing");
863 (void) ungetc(c, infile);
864 *cp = '\0';
865 if (strlen(tokbuf) == 1) {
866 tokentype = CHAR;
867 yylval.number = (unsigned char)tokbuf[0];
868 } else if (strlen(tokbuf) == 2 && tokbuf[0] == '^') {
869 tokentype = CHAR;
870 yylval.number = (unsigned char)(tokbuf[1] & 037);
871 } else {
872 word_t word;
873 register word_t *wptr;
874 char *ptr;
875
876 for (cp = &tokbuf[0]; (c = *cp) != '\0'; cp++) {
877 if (isupper(c))
878 *cp = tolower(c);
879 }
880 word.w_string = tokbuf;
881 wptr = (word_t *)bsearch((char *)&word,
882 (char *)wordtab, NWORDS, sizeof (word_t),
883 wordcmp);
884 if (wptr != NULL) {
885 yylval.number = wptr->w_lval;
886 tokentype = wptr->w_type;
887 } else {
888 yylval.number = strtol(tokbuf, &ptr, 0);
889 if (ptr == tokbuf)
890 yyerror("syntax error");
891 else
892 tokentype = INT;
893 }
894 break;
895 }
896 }
897
898 return (tokentype);
899 }
900
901 static int
902 readesc(stream, delim, single_char)
903 FILE *stream;
904 int delim;
905 int single_char;
906 {
907 register int c;
908 register int val;
909 register int i;
910
911 if ((c = getc(stream)) == EOF || c == '\n')
912 yyerror("unterminated character constant");
913
914 if (c >= '0' && c <= '7') {
915 val = 0;
916 i = 1;
917 for (;;) {
918 val = val*8 + c - '0';
919 if ((c = getc(stream)) == EOF || c == '\n')
920 yyerror("unterminated character constant");
921 if (c == delim)
922 break;
923 i++;
924 if (i > 3) {
925 if (single_char)
926 yyerror("escape sequence too long");
927 else
928 break;
929 }
930 if (c < '0' || c > '7') {
931 if (single_char)
932 yyerror("illegal character in escape sequence");
933 else
934 break;
935 }
936 }
937 (void) ungetc(c, stream);
938 } else {
939 switch (c) {
940
941 case 'n':
942 val = '\n';
943 break;
944
945 case 't':
946 val = '\t';
947 break;
948
949 case 'b':
950 val = '\b';
951 break;
952
953 case 'r':
954 val = '\r';
955 break;
956
957 case 'v':
958 val = '\v';
959 break;
960
961 case '\\':
962 val = '\\';
963 break;
964
965 default:
966 if (c == delim)
967 val = delim;
968 else
969 yyerror("illegal character in escape sequence");
970 }
971 }
972 return (val);
973 }
974
975 static int
976 wordcmp(const void *w1, const void *w2)
977 {
978 return (strcmp(
979 ((const word_t *)w1)->w_string,
980 ((const word_t *)w2)->w_string));
981 }
982
983 static int
984 yyerror(msg)
985 char *msg;
986 {
987 (void) fprintf(stderr, "%s, line %d: %s\n", infilename, lineno, msg);
988 exit(1);
989 }