usr.bin/tn3270/ascii/map3270.c

   1 /*      $NetBSD: map3270.c,v 1.14 2006/04/30 23:42:06 christos Exp $    */
   2
   3 /*-
   4  * Copyright (c) 1988 The Regents of the University of California.
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. Neither the name of the University nor the names of its contributors
  16  *    may be used to endorse or promote products derived from this software
  17  *    without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  29  * SUCH DAMAGE.
  30  */
  31
  32 #include <sys/cdefs.h>
  33 #ifndef lint
  34 #if 0
  35 static char sccsid[] = "@(#)map3270.c   4.2 (Berkeley) 4/26/91";
  36 #else
  37 __RCSID("$NetBSD: map3270.c,v 1.14 2006/04/30 23:42:06 christos Exp $");
  38 #endif
  39 #endif /* not lint */
  40
  41 /*      This program reads a description file, somewhat like /etc/termcap,
  42     that describes the mapping between the current terminal's keyboard and
  43     a 3270 keyboard.
  44  */
  45 #ifdef DOCUMENTATION_ONLY
  46 /* here is a sample (very small) entry...
  47
  48         # this table is sensitive to position on a line.  In particular,
  49         # a terminal definition for a terminal is terminated whenever a
  50         # (non-comment) line beginning in column one is found.
  51         #
  52         # this is an entry to map tvi924 to 3270 keys...
  53         v8|tvi924|924|televideo model 924 {
  54                 pfk1 =  '\E1';
  55                 pfk2 =  '\E2';
  56                 clear = '^z';           # clear the screen
  57         }
  58  */
  59 #endif /* DOCUMENTATION_ONLY */
  60 \f
  61 #include <ctype.h>
  62 #include <stdio.h>
  63 #include <stdlib.h>
  64 #include <string.h>
  65
  66 #define IsPrint(c)      ((isprint((unsigned char)c) && !isspace((unsigned char)c)) || ((c) == ' '))
  67
  68 #include "state.h"
  69 #include "map3270.h"
  70
  71 #include "../general/globals.h"
  72 \f
  73 /* this is the list of types returned by the lex processor */
  74 #define LEX_CHAR        400                     /* plain unadorned character */
  75 #define LEX_ESCAPED     LEX_CHAR+1              /* escaped with \ */
  76 #define LEX_CARETED     LEX_ESCAPED+1           /* escaped with ^ */
  77 #define LEX_END_OF_FILE LEX_CARETED+1           /* end of file encountered */
  78 #define LEX_ILLEGAL     LEX_END_OF_FILE+1       /* trailing escape character */
  79
  80 /* the following is part of our character set dependency... */
  81 #define ESCAPE          0x1b
  82 #define TAB             0x09
  83 #define NEWLINE         0x0a
  84 #define CARRIAGE_RETURN 0x0d
  85
  86 typedef struct {
  87     int type;           /* LEX_* - type of character */
  88     int value;          /* character this was */
  89 } lexicon;
  90
  91 typedef struct {
  92     int         length;         /* length of character string */
  93     char        array[500];     /* character string */
  94 } stringWithLength;
  95
  96 #define panic(s)        { fprintf(stderr, "%s", s); exit(1); }
  97
  98 static state firstentry = { 0, STATE_NULL, 0, 0 };
  99 static state *headOfQueue = &firstentry;
 100 \f
 101 /* the following is a primitive adm3a table, to be used when nothing
 102  * else seems to be available.
 103  */
 104
 105 #ifdef  DEBUG
 106 static int debug = 0;           /* debug flag (for debuggin tables) */
 107 #endif  /* DEBUG */
 108
 109 static int (*GetTc)(char *);
 110 static int doPaste = 1;         /* should we have side effects */
 111 static int picky = 0;           /* do we complain of unknown functions? */
 112 static char usePointer = 0;     /* use pointer, or file */
 113 static FILE *ourFile= 0;
 114 static char *environPointer = 0;/* if non-zero, point to input
 115                                  * string in core.
 116                                  */
 117 static char **whichkey = 0;
 118 static char *keysgeneric[] = {
 119 #include "default.map"          /* Define the default default */
 120
 121         0,                      /* Terminate list of entries */
 122 };
 123                         ;
 124 \f
 125 static  int     Empty = 1,              /* is the unget lifo empty? */
 126                 Full = 0;               /* is the unget lifo full? */
 127 static  lexicon lifo[200];              /* character stack for parser */
 128 static  int     rp = 0,                 /* read pointer into lifo */
 129                 wp = 0;                 /* write pointer into lifo */
 130
 131 static int GetC(void);
 132 static lexicon Get(void);
 133 static void UnGet(lexicon);
 134 static stringWithLength *GetQuotedString(void);
 135 #ifdef NOTUSED
 136 static stringWithLength *GetCharString(void);
 137 #endif
 138 static int GetCharacter(int);
 139 #ifdef NOTUSED
 140 static int GetString(char *);
 141 #endif
 142 static stringWithLength *GetAlphaMericString(void);
 143 static lexicon EatToNL(void);
 144 static void GetWS(void);
 145 static void FreeState(state *);
 146 static state *GetState(void);
 147 static state *FindMatchAtThisLevel(state *, int);
 148 static state *PasteEntry(state *, char *, int, char *);
 149 static int GetInput(int, char *);
 150 static int GetDefinition(void);
 151 static int GetDefinitions(void);
 152 static int GetBegin(void);
 153 static int GetEnd(void);
 154 static int GetName(void);
 155 static int GetNames(void);
 156 static int GetEntry0(void);
 157 static int GetEntry(void);
 158
 159 static int
 160 GetC()
 161 {
 162     int character;
 163
 164     if (usePointer) {
 165         if ((*environPointer) == 0) {
 166             /*
 167              * If we have reached the end of this string, go on to
 168              * the next (if there is a next).
 169              */
 170             if (whichkey == 0) {
 171                 static char suffix = 'A';       /* From environment */
 172                 char envname[9];
 173
 174                 (void) sprintf(envname, "MAP3270%c", suffix++);
 175                 environPointer = getenv(envname);
 176             } else {
 177                 whichkey++;                     /* default map */
 178                 environPointer = *whichkey;
 179             }
 180         }
 181         if (*environPointer) {
 182            character = 0xff&*environPointer++;
 183         } else {
 184            character = EOF;
 185         }
 186     } else {
 187         character = getc(ourFile);
 188     }
 189     return(character);
 190 }
 191
 192 static lexicon
 193 Get()
 194 {
 195     lexicon c;
 196     lexicon *pC = &c;
 197     int character;
 198
 199     if (!Empty) {
 200         *pC = lifo[rp];
 201         rp++;
 202         if (rp == sizeof lifo/sizeof (lexicon)) {
 203             rp = 0;
 204         }
 205         if (rp == wp) {
 206             Empty = 1;
 207         }
 208         Full = 0;
 209     } else {
 210         character = GetC();
 211         switch (character) {
 212         case EOF:
 213             pC->type = LEX_END_OF_FILE;
 214             break;
 215         case '^':
 216             character = GetC();
 217             if (!IsPrint(character)) {
 218                 pC->type = LEX_ILLEGAL;
 219             } else {
 220                 pC->type = LEX_CARETED;
 221                 if (character == '?') {
 222                     character |= 0x40;  /* rubout */
 223                 } else {
 224                     character &= 0x1f;
 225                 }
 226             }
 227             break;
 228         case '\\':
 229             character = GetC();
 230             if (!IsPrint(character)) {
 231                 pC->type = LEX_ILLEGAL;
 232             } else {
 233                 pC->type = LEX_ESCAPED;
 234                 switch (character) {
 235                 case 'E': case 'e':
 236                     character = ESCAPE;
 237                     break;
 238                 case 't':
 239                     character = TAB;
 240                     break;
 241                 case 'n':
 242                     character = NEWLINE;
 243                     break;
 244                 case 'r':
 245                     character = CARRIAGE_RETURN;
 246                     break;
 247                 default:
 248                     pC->type = LEX_ILLEGAL;
 249                     break;
 250                 }
 251             }
 252             break;
 253         default:
 254             if ((IsPrint(character)) || isspace(character)) {
 255                 pC->type = LEX_CHAR;
 256             } else {
 257                 pC->type = LEX_ILLEGAL;
 258             }
 259             break;
 260         }
 261         pC->value = character;
 262     }
 263     return(*pC);
 264 }
 265
 266 static void
 267 UnGet(c)
 268 lexicon c;                      /* character to unget */
 269 {
 270     if (Full) {
 271         fprintf(stderr, "attempt to put too many characters in lifo\n");
 272         panic("map3270");
 273         /* NOTREACHED */
 274     } else {
 275         lifo[wp] = c;
 276         wp++;
 277         if (wp == sizeof lifo/sizeof (lexicon)) {
 278             wp = 0;
 279         }
 280         if (wp == rp) {
 281             Full = 1;
 282         }
 283         Empty = 0;
 284     }
 285 }
 286 \f
 287 /*
 288  * Construct a control character sequence
 289  * for a special character.
 290  */
 291 char *
 292 uncontrol(c)
 293         int c;
 294 {
 295         static char buf[3];
 296
 297         if (c == 0x7f)
 298                 return ("^?");
 299         if (c == '\377') {
 300                 return "-1";
 301         }
 302         if (c >= 0x20) {
 303                 buf[0] = c;
 304                 buf[1] = 0;
 305         } else {
 306                 buf[0] = '^';
 307                 buf[1] = '@'+c;
 308                 buf[2] = 0;
 309         }
 310         return (buf);
 311 }
 312 \f
 313 /* compare two strings, ignoring case */
 314
 315 int
 316 ustrcmp(string1, string2)
 317 char *string1;
 318 char *string2;
 319 {
 320     int c1, c2;
 321
 322     while ((c1 = (unsigned char) *string1++) != 0) {
 323         if (isupper(c1)) {
 324             c1 = tolower(c1);
 325         }
 326         if (isupper(c2 = (unsigned char) *string2++)) {
 327             c2 = tolower(c2);
 328         }
 329         if (c1 < c2) {
 330             return(-1);
 331         } else if (c1 > c2) {
 332             return(1);
 333         }
 334     }
 335     if (*string2) {
 336         return(-1);
 337     } else {
 338         return(0);
 339     }
 340 }
 341 \f
 342
 343 static stringWithLength *
 344 GetQuotedString()
 345 {
 346     lexicon lex;
 347     static stringWithLength output = { 0 };     /* where return value is held */
 348     char *pointer = output.array;
 349
 350     lex = Get();
 351     if ((lex.type != LEX_CHAR) || (lex.value != '\'')) {
 352         UnGet(lex);
 353         return(0);
 354     }
 355     while (1) {
 356         lex = Get();
 357         if ((lex.type == LEX_CHAR) && (lex.value == '\'')) {
 358             break;
 359         }
 360         if ((lex.type == LEX_CHAR) && !IsPrint(lex.value)) {
 361             UnGet(lex);
 362             return(0);          /* illegal character in quoted string */
 363         }
 364         if (pointer >= output.array+sizeof output.array) {
 365             return(0);          /* too long */
 366         }
 367         *pointer++ = lex.value;
 368     }
 369     output.length = pointer-output.array;
 370     return(&output);
 371 }
 372
 373 #ifdef  NOTUSED
 374 static stringWithLength *
 375 GetCharString()
 376 {
 377     lexicon lex;
 378     static stringWithLength output;
 379     char *pointer = output.array;
 380
 381     lex = Get();
 382
 383     while ((lex.type == LEX_CHAR) &&
 384                         !isspace(lex.value) && (lex.value != '=')) {
 385         *pointer++ = lex.value;
 386         lex = Get();
 387         if (pointer >= output.array + sizeof output.array) {
 388             return(0);          /* too long */
 389         }
 390     }
 391     UnGet(lex);
 392     output.length = pointer-output.array;
 393     return(&output);
 394 }
 395 #endif  /* NOTUSED */
 396
 397 static int
 398 GetCharacter(character)
 399 int     character;              /* desired character */
 400 {
 401     lexicon lex;
 402
 403     lex = Get();
 404
 405     if ((lex.type != LEX_CHAR) || (lex.value != character)) {
 406         UnGet(lex);
 407         return(0);
 408     }
 409     return(1);
 410 }
 411
 412 #ifdef  NOTUSED
 413 static int
 414 GetString(string)
 415 char    *string;                /* string to get */
 416 {
 417     lexicon lex;
 418
 419     while (*string) {
 420         lex = Get();
 421         if ((lex.type != LEX_CHAR) || (lex.value != *string&0xff)) {
 422             UnGet(lex);
 423             return(0);          /* XXX restore to state on entry */
 424         }
 425         string++;
 426     }
 427     return(1);
 428 }
 429 #endif  /* NOTUSED */
 430
 431
 432 static stringWithLength *
 433 GetAlphaMericString()
 434 {
 435     lexicon lex;
 436     static stringWithLength output = { 0 };
 437     char *pointer = output.array;
 438 #   define      IsAlnum(c)      (isalnum(c) || (c == '_') \
 439                                         || (c == '-') || (c == '.'))
 440
 441     lex = Get();
 442
 443     if ((lex.type != LEX_CHAR) || !IsAlnum(lex.value)) {
 444         UnGet(lex);
 445         return(0);
 446     }
 447
 448     while ((lex.type == LEX_CHAR) && IsAlnum(lex.value)) {
 449         *pointer++ = lex.value;
 450         lex = Get();
 451     }
 452     UnGet(lex);
 453     *pointer = 0;
 454     output.length = pointer-output.array;
 455     return(&output);
 456 }
 457
 458
 459 /* eat up characters until a new line, or end of file.  returns terminating
 460         character.
 461  */
 462
 463 static lexicon
 464 EatToNL()
 465 {
 466     lexicon lex;
 467
 468     lex = Get();
 469
 470     while (!((lex.type != LEX_ESCAPED) && (lex.type != LEX_CARETED) &&
 471                 (lex.value == '\n')) && (!(lex.type == LEX_END_OF_FILE))) {
 472         lex = Get();
 473     }
 474     if (lex.type != LEX_END_OF_FILE) {
 475         return(Get());
 476     } else {
 477         return(lex);
 478     }
 479 }
 480
 481
 482 static void
 483 GetWS()
 484 {
 485     lexicon lex;
 486
 487     lex = Get();
 488
 489     while ((lex.type == LEX_CHAR) &&
 490                         (isspace(lex.value) || (lex.value == '#'))) {
 491         if (lex.value == '#') {
 492             lex = EatToNL();
 493         } else {
 494             lex = Get();
 495         }
 496     }
 497     UnGet(lex);
 498 }
 499 \f
 500 static void
 501 FreeState(pState)
 502 state *pState;
 503 {
 504     free((char *)pState);
 505 }
 506
 507
 508 static state *
 509 GetState()
 510 {
 511     state *pState;
 512
 513     pState = (state *) malloc(sizeof (state));
 514
 515     pState->result = STATE_NULL;
 516     pState->next = 0;
 517
 518     return(pState);
 519 }
 520
 521
 522 static state *
 523 FindMatchAtThisLevel(pState, character)
 524 state   *pState;
 525 int     character;
 526 {
 527     while (pState) {
 528         if (pState->match == character) {
 529             return(pState);
 530         }
 531         pState = pState->next;
 532     }
 533     return(0);
 534 }
 535
 536
 537 static state *
 538 PasteEntry(head, string, count, identifier)
 539 state                   *head;          /* points to who should point here... */
 540 char                    *string;        /* which characters to paste */
 541 int                     count;          /* number of character to do */
 542 char                    *identifier;    /* for error messages */
 543 {
 544     state *pState, *other;
 545
 546     if (!doPaste) {             /* flag to not have any side effects */
 547         return((state *)1);
 548     }
 549     if (!count) {
 550         return(head);   /* return pointer to the parent */
 551     }
 552     if ((head->result != STATE_NULL) && (head->result != STATE_GOTO)) {
 553         /* this means that a previously defined sequence is an initial
 554          * part of this one.
 555          */
 556         fprintf(stderr, "Conflicting entries found when scanning %s\n",
 557                 identifier);
 558         return(0);
 559     }
 560 #   ifdef       DEBUG
 561         if (debug) {
 562             fprintf(stderr, "%s", uncontrol(*string));
 563         }
 564 #   endif       /* DEBUG */
 565     pState = GetState();
 566     pState->match = *string;
 567     if (head->result == STATE_NULL) {
 568         head->result = STATE_GOTO;
 569         head->address = pState;
 570         other = pState;
 571     } else {            /* search for same character */
 572         if ((other = FindMatchAtThisLevel(head->address, *string)) != 0) {
 573             FreeState(pState);
 574         } else {
 575             pState->next = head->address;
 576             head->address = pState;
 577             other = pState;
 578         }
 579     }
 580     return(PasteEntry(other, string+1, count-1, identifier));
 581 }
 582 \f
 583 static int
 584 GetInput(tc, identifier)
 585 int tc;
 586 char *identifier;               /* entry being parsed (for error messages) */
 587 {
 588     stringWithLength *outputString;
 589     state *head;
 590     state fakeQueue;
 591
 592     if (doPaste) {
 593         head = headOfQueue;     /* always points to level above this one */
 594     } else {
 595         head = &fakeQueue;      /* don't have any side effects... */
 596     }
 597
 598     if ((outputString = GetQuotedString()) == 0) {
 599         return(0);
 600     } else if (IsPrint(outputString->array[0])) {
 601         fprintf(stderr,
 602          "first character of sequence for %s is not a control type character\n",
 603                 identifier);
 604         return(0);
 605     } else {
 606         if ((head = PasteEntry(head, outputString->array,
 607                                 outputString->length, identifier)) == 0) {
 608             return(0);
 609         }
 610         GetWS();
 611         while ((outputString = GetQuotedString()) != 0) {
 612             if ((head = PasteEntry(head, outputString->array,
 613                                 outputString->length, identifier)) == 0) {
 614                 return(0);
 615             }
 616             GetWS();
 617         }
 618     }
 619     if (!doPaste) {
 620         return(1);
 621     }
 622     if ((head->result != STATE_NULL) && (head->result != tc)) {
 623         /* this means that this sequence is an initial part
 624          * of a previously defined one.
 625          */
 626         fprintf(stderr, "Conflicting entries found when scanning %s\n",
 627                 identifier);
 628         return(0);
 629     } else {
 630         head->result = tc;
 631         return(1);              /* done */
 632     }
 633 }
 634 \f
 635 static int
 636 GetDefinition()
 637 {
 638     stringWithLength *string;
 639     int Tc;
 640
 641     GetWS();
 642     if ((string = GetAlphaMericString()) == 0) {
 643         return(0);
 644     }
 645     string->array[string->length] = 0;
 646     if (doPaste) {
 647         if ((Tc = (*GetTc)(string->array)) == -1) {
 648             if (picky) {
 649                 fprintf(stderr, "%s: unknown 3270 key identifier\n",
 650                                                         string->array);
 651             }
 652             Tc = STATE_NULL;
 653         }
 654     } else {
 655         Tc = STATE_NULL;                /* XXX ? */
 656     }
 657     GetWS();
 658     if (!GetCharacter('=')) {
 659         fprintf(stderr,
 660                 "Required equal sign after 3270 key identifier %s missing\n",
 661                         string->array);
 662         return(0);
 663     }
 664     GetWS();
 665     if (!GetInput(Tc, string->array)) {
 666         fprintf(stderr, "Missing definition part for 3270 key %s\n",
 667                                 string->array);
 668         return(0);
 669     } else {
 670         GetWS();
 671         while (GetCharacter('|')) {
 672 #           ifdef       DEBUG
 673                 if (debug) {
 674                     fprintf(stderr, " or ");
 675                 }
 676 #           endif       /* DEBUG */
 677             GetWS();
 678             if (!GetInput(Tc, string->array)) {
 679                 fprintf(stderr, "Missing definition part for 3270 key %s\n",
 680                                         string->array);
 681                 return(0);
 682             }
 683             GetWS();
 684         }
 685     }
 686     GetWS();
 687     if (!GetCharacter(';')) {
 688         fprintf(stderr, "Missing semi-colon for 3270 key %s\n", string->array);
 689         return(0);
 690     }
 691 #   ifdef       DEBUG
 692         if (debug) {
 693             fprintf(stderr, ";\n");
 694         }
 695 #   endif       /* DEBUG */
 696     return(1);
 697 }
 698
 699
 700 static int
 701 GetDefinitions()
 702 {
 703     if (!GetDefinition()) {
 704         return(0);
 705     } else {
 706         while (GetDefinition()) {
 707             ;
 708         }
 709     }
 710     return(1);
 711 }
 712
 713 static int
 714 GetBegin()
 715 {
 716     GetWS();
 717     if (!GetCharacter('{')) {
 718         return(0);
 719     }
 720     return(1);
 721 }
 722
 723 static int
 724 GetEnd()
 725 {
 726     GetWS();
 727     if (!GetCharacter('}')) {
 728         return(0);
 729     }
 730     return(1);
 731 }
 732
 733 static int
 734 GetName()
 735 {
 736     if (!GetAlphaMericString()) {
 737         return(0);
 738     }
 739     GetWS();
 740     while (GetAlphaMericString()) {
 741         GetWS();
 742     }
 743     return(1);
 744 }
 745
 746 static int
 747 GetNames()
 748 {
 749     GetWS();
 750     if (!GetName()) {
 751         return(0);
 752     } else {
 753         GetWS();
 754         while (GetCharacter('|')) {
 755             GetWS();
 756             if (!GetName()) {
 757                 return(0);
 758             }
 759         }
 760     }
 761     return(1);
 762 }
 763
 764 static int
 765 GetEntry0()
 766 {
 767     if (!GetBegin()) {
 768         fprintf(stderr, "no '{'\n");
 769         return(0);
 770     } else if (!GetDefinitions()) {
 771         fprintf(stderr, "unable to parse the definitions\n");
 772         return(0);
 773     } else if (!GetEnd()) {
 774         fprintf(stderr, "No '}' or scanning stopped early due to error.\n");
 775         return(0);
 776     } else {
 777         /* done */
 778         return(1);
 779     }
 780 }
 781
 782
 783 static int
 784 GetEntry()
 785 {
 786     if (!GetNames()) {
 787         fprintf(stderr, "Invalid name field in entry.\n");
 788         return(0);
 789     } else {
 790         return(GetEntry0());
 791     }
 792 }
 793 \f
 794 /* position ourselves within a given filename to the entry for the current
 795  *      KEYBD (or TERM) variable
 796  */
 797
 798 int
 799 Position(filename, keybdPointer)
 800 char *filename;
 801 char *keybdPointer;
 802 {
 803     lexicon lex;
 804     stringWithLength *name = 0;
 805     stringWithLength *oldName;
 806 #   define      Return(x) {doPaste = 1; return(x);}
 807
 808     doPaste = 0;
 809
 810     if ((ourFile = fopen(filename, "r")) == NULL) {
 811 #   if !defined(MSDOS)
 812         fprintf(stderr, "Unable to open file %s\n", filename);
 813 #   endif /* !defined(MSDOS) */
 814         Return(0);
 815     }
 816     lex = Get();
 817     while (lex.type != LEX_END_OF_FILE) {
 818         UnGet(lex);
 819         /* now, find an entry that is our type. */
 820         GetWS();
 821         oldName = name;
 822         if ((name = GetAlphaMericString()) != 0) {
 823             if (!ustrcmp(name->array, keybdPointer)) {
 824                 /* need to make sure there is a name here... */
 825                 lex.type = LEX_CHAR;
 826                 lex.value = 'a';
 827                 UnGet(lex);
 828                 Return(1);
 829             }
 830         } else if (GetCharacter('|')) {
 831             ;           /* more names coming */
 832         } else {
 833             lex = Get();
 834             UnGet(lex);
 835             if (lex.type != LEX_END_OF_FILE) {
 836                     if (!GetEntry0()) { /* start of an entry */
 837                         fprintf(stderr,
 838                             "error was in entry for %s in file %s\n",
 839                             (oldName)? oldName->array:"(unknown)", filename);
 840                     Return(0);
 841                 }
 842             }
 843         }
 844         lex = Get();
 845     }
 846 #if !defined(MSDOS)
 847     fprintf(stderr, "Unable to find entry for %s in file %s\n", keybdPointer,
 848                     filename);
 849 #endif  /* !defined(MSDOS) */
 850     Return(0);
 851 }
 852
 853 char *
 854 strsave(string)
 855 char *string;
 856 {
 857     char *p;
 858
 859     p = malloc((unsigned int)strlen(string)+1);
 860     if (p != 0) {
 861         strcpy(p, string);
 862     }
 863     return(p);
 864 }
 865
 866
 867 /*
 868  * InitControl - our interface to the outside.  What we should
 869  *  do is figure out keyboard (or terminal) type, set up file pointer
 870  *  (or string pointer), etc.
 871  */
 872
 873 state *
 874 InitControl(keybdPointer, pickyarg, translator)
 875 char    *keybdPointer;
 876 int     pickyarg;               /* Should we be picky? */
 877 int     (*translator)(char *);  /* Translates ascii string to integer */
 878 {
 879     int GotIt;
 880
 881     picky = pickyarg;
 882     GetTc = translator;
 883
 884     if (keybdPointer == 0) {
 885         keybdPointer = getenv("KEYBD");
 886     }
 887     if (keybdPointer == 0) {
 888        keybdPointer = getenv("TERM");
 889     }
 890
 891                     /*
 892                      * Some environments have getenv() return
 893                      * out of a static area.  So, save the keyboard name.
 894                      */
 895     if (keybdPointer) {
 896         keybdPointer = strsave(keybdPointer);
 897     }
 898     environPointer = getenv("MAP3270");
 899     if (keybdPointer && environPointer
 900             && (environPointer[0] != '/')
 901 #if     defined(MSDOS)
 902             && (environPointer[0] != '\\')
 903 #endif  /* defined(MSDOS) */
 904             && (strncmp(keybdPointer, environPointer,
 905                         strlen(keybdPointer) != 0)
 906                 || (environPointer[strlen(keybdPointer)] != '{'))) /* } */
 907     {
 908         environPointer = 0;
 909     }
 910
 911     if ((!environPointer)
 912 #if     defined(MSDOS)
 913                 || (*environPointer == '\\')
 914 #endif  /* defined(MSDOS) */
 915                 || (*environPointer == '/')) {
 916         usePointer = 0;
 917         GotIt = 0;
 918         if (!keybdPointer) {
 919 #if !defined(MSDOS)
 920             fprintf(stderr, "%s%s%s%s",
 921                 "Neither the KEYBD environment variable nor the TERM ",
 922                 "environment variable\n(one of which is needed to determine ",
 923                 "the type of keyboard you are using)\n",
 924                 "is set.  To set it, say 'setenv KEYBD <type>'\n");
 925 #endif  /* !defined(MSDOS) */
 926         } else {
 927             if (environPointer) {
 928                 GotIt = Position(environPointer, keybdPointer);
 929             }
 930             if (!GotIt) {
 931                 GotIt = Position("/usr/share/misc/map3270", keybdPointer);
 932             }
 933         }
 934         if (!GotIt) {
 935             if (environPointer) {
 936                 GotIt = Position(environPointer, "unknown");
 937             }
 938             if (!GotIt && keybdPointer) {
 939                 GotIt = Position("/usr/share/misc/map3270", keybdPointer);
 940             }
 941         }
 942         if (!GotIt) {
 943 #if !defined(MSDOS)
 944             fprintf(stderr, "Using default key mappings.\n");
 945 #endif  /* !defined(MSDOS) */
 946             usePointer = 1;             /* flag use of non-file */
 947             whichkey = keysgeneric;
 948             environPointer = *whichkey; /* use default table */
 949         }
 950     } else {
 951         usePointer = 1;
 952     }
 953     (void) GetEntry();
 954     free(keybdPointer);
 955     return(firstentry.address);
 956 }