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 } 990