ncurses/parse_entry.c

   1 /***************************************************************************
   2 *                            COPYRIGHT NOTICE                              *
   3 ****************************************************************************
   4 *                ncurses is copyright (C) 1992-1995                        *
   5 *                          Zeyd M. Ben-Halim                               *
   6 *                          zmbenhal@netcom.com                             *
   7 *                          Eric S. Raymond                                 *
   8 *                          esr@snark.thyrsus.com                           *
   9 *                                                                          *
  10 *        Permission is hereby granted to reproduce and distribute ncurses  *
  11 *        by any means and for any fee, whether alone or as part of a       *
  12 *        larger distribution, in source or in binary form, PROVIDED        *
  13 *        this notice is included with any such distribution, and is not    *
  14 *        removed from any of its header files. Mention of ncurses in any   *
  15 *        applications linked with it is highly appreciated.                *
  16 *                                                                          *
  17 *        ncurses comes AS IS with no warranty, implied or expressed.       *
  18 *                                                                          *
  19 ***************************************************************************/
  20
  21
  22 /*
  23  *      parse_entry.c -- compile one terminfo or termcap entry
  24  *
  25  *      Get an exact in-core representation of an entry.  Don't
  26  *      try to resolve use or tc capabilities, that is someone
  27  *      else's job.  Depends on the lexical analyzer to get tokens
  28  *      from the input stream.
  29  */
  30
  31 #include <curses.priv.h>
  32
  33 #include <ctype.h>
  34 #include <tic.h>
  35 #define __INTERNAL_CAPS_VISIBLE
  36 #include <term.h>
  37 #include <term_entry.h>
  38
  39 MODULE_ID("$Id: parse_entry.c,v 1.18 1997/02/02 01:50:15 tom Exp $")
  40
  41 #ifdef LINT
  42 static short const parametrized[] = { 0 };
  43 #else
  44 #include <parametrized.h>
  45 #endif
  46
  47 struct token    _nc_curr_token;
  48
  49 static  void postprocess_termcap(TERMTYPE *, bool);
  50 static  void postprocess_terminfo(TERMTYPE *);
  51 static  struct name_table_entry const * lookup_fullname(const char *name);
  52
  53 /*
  54  *      int
  55  *      _nc_parse_entry(entry, literal, silent)
  56  *
  57  *      Compile one entry.  Doesn't try to resolve use or tc capabilities.
  58  *
  59  *      found-forward-use = FALSE
  60  *      re-initialise internal arrays
  61  *      get_token();
  62  *      if the token was not a name in column 1, complain and die
  63  *      save names in entry's string table
  64  *      while (get_token() is not EOF and not NAMES)
  65  *              check for existance and type-correctness
  66  *              enter cap into structure
  67  *              if STRING
  68  *                  save string in entry's string table
  69  *      push back token
  70  */
  71
  72 int _nc_parse_entry(struct entry *entryp, int literal, bool silent)
  73 {
  74     int                 token_type;
  75     struct name_table_entry     const *entry_ptr;
  76     char                        *ptr, namecpy[MAX_NAME_SIZE+1];
  77
  78     token_type = _nc_get_token();
  79
  80     if (token_type == EOF)
  81         return(EOF);
  82     if (token_type != NAMES)
  83         _nc_err_abort("Entry does not start with terminal names in column one");
  84
  85     _nc_init_entry(&entryp->tterm);
  86
  87     entryp->cstart = _nc_comment_start;
  88     entryp->cend = _nc_comment_end;
  89     entryp->startline = _nc_start_line;
  90     DEBUG(2, ("Comment range is %ld to %ld", entryp->cstart, entryp->cend));
  91
  92     /* junk the 2-character termcap name, if present */
  93     ptr = _nc_curr_token.tk_name;
  94     if (ptr[2] == '|')
  95     {
  96         ptr = _nc_curr_token.tk_name + 3;
  97         _nc_curr_token.tk_name[2] = '\0';
  98     }
  99
 100     entryp->tterm.str_table = entryp->tterm.term_names = _nc_save_str(ptr);
 101
 102     DEBUG(1, ("Starting '%s'", ptr));
 103
 104     /*
 105      * We do this because the one-token lookahead in the parse loop
 106      * results in the terminal type getting prematurely set to correspond
 107      * to that of the next entry.
 108      */
 109     _nc_set_type(_nc_first_name(entryp->tterm.term_names));
 110
 111     /* check for overly-long names and aliases */
 112     (void) strncpy(namecpy, entryp->tterm.term_names, MAX_NAME_SIZE);
 113     namecpy[MAX_NAME_SIZE] = '\0';
 114     if ((ptr = strrchr(namecpy, '|')) != (char *)NULL)
 115         *ptr = '\0';
 116     ptr = strtok(namecpy, "|");
 117     if (strlen(ptr) > MAX_ALIAS)
 118         _nc_warning("primary name may be too long");
 119     while ((ptr = strtok((char *)NULL, "|")) != (char *)NULL)
 120         if (strlen(ptr) > MAX_ALIAS)
 121             _nc_warning("alias `%s' may be too long", ptr);
 122
 123     entryp->nuses = 0;
 124
 125     for (token_type = _nc_get_token();
 126          token_type != EOF  &&  token_type != NAMES;
 127          token_type = _nc_get_token())
 128     {
 129         if (strcmp(_nc_curr_token.tk_name, "use") == 0
 130             || strcmp(_nc_curr_token.tk_name, "tc") == 0) {
 131             entryp->uses[entryp->nuses].parent = (void *)_nc_save_str(_nc_curr_token.tk_valstring);
 132             entryp->uses[entryp->nuses].line = _nc_curr_line;
 133             entryp->nuses++;
 134         } else {
 135             /* normal token lookup */
 136             entry_ptr = _nc_find_entry(_nc_curr_token.tk_name,
 137                                        _nc_syntax ? _nc_cap_hash_table : _nc_info_hash_table);
 138
 139             /*
 140              * Our kluge to handle aliasing.  The reason it's done
 141              * this ugly way, with a linear search, is so the hashing
 142              * machinery doesn't have to be made really complicated
 143              * (also we get better warnings this way).  No point in
 144              * making this case fast, aliased caps aren't common now
 145              * and will get rarer.
 146              */
 147             if (entry_ptr == NOTFOUND)
 148             {
 149                 const struct alias      *ap;
 150
 151                 if (_nc_syntax == SYN_TERMCAP)
 152                 {
 153                     for (ap = _nc_capalias_table; ap->from; ap++)
 154                         if (strcmp(ap->from, _nc_curr_token.tk_name) == 0)
 155                         {
 156                             if (ap->to == (char *)NULL)
 157                             {
 158                                 _nc_warning("%s (%s termcap extension) ignored",
 159                                             ap->from, ap->source);
 160                                 goto nexttok;
 161                             }
 162
 163                             entry_ptr = _nc_find_entry(ap->to, _nc_cap_hash_table);
 164                             if (entry_ptr && !silent)
 165                                 _nc_warning("%s (%s termcap extension) aliased to %s", ap->from, ap->source, ap->to);
 166                             break;
 167                         }
 168                 }
 169                 else /* if (_nc_syntax == SYN_TERMINFO) */
 170                 {
 171                     for (ap = _nc_infoalias_table; ap->from; ap++)
 172                         if (strcmp(ap->from, _nc_curr_token.tk_name) == 0)
 173                         {
 174                             if (ap->to == (char *)NULL)
 175                             {
 176                                 _nc_warning("%s (%s terminfo extension) ignored",
 177                                             ap->from, ap->source);
 178                                 goto nexttok;
 179                             }
 180
 181                             entry_ptr = _nc_find_entry(ap->to, _nc_info_hash_table);
 182                             if (entry_ptr && !silent)
 183                                 _nc_warning("%s (%s terminfo extension) aliased to %s", ap->from, ap->source, ap->to);
 184                             break;
 185                         }
 186
 187                     /* last chance: a full-name */
 188                     if (entry_ptr == NOTFOUND) {
 189                         entry_ptr = lookup_fullname(_nc_curr_token.tk_name);
 190                     }
 191                 }
 192             }
 193
 194             /* can't find this cap name, not even as an alias */
 195             if (entry_ptr == NOTFOUND) {
 196                 if (!silent)
 197                     _nc_warning("unknown capability '%s'",
 198                                 _nc_curr_token.tk_name);
 199                 continue;
 200             }
 201
 202             /* deal with bad type/value combinations. */
 203             if (token_type != CANCEL &&  entry_ptr->nte_type != token_type)
 204             {
 205                 /*
 206                  * Nasty special cases here handle situations in which type
 207                  * information can resolve name clashes.  Normal lookup
 208                  * finds the last instance in the capability table of a
 209                  * given name, regardless of type.  find_type_entry looks
 210                  * for a first matching instance with given type.  So as
 211                  * long as all ambiguous names occur in pairs of distinct
 212                  * type, this will do the job.
 213                  */
 214
 215                 /* tell max_attributes from arrow_key_map */
 216                 if (token_type == NUMBER && !strcmp("ma", _nc_curr_token.tk_name))
 217                     entry_ptr = _nc_find_type_entry("ma", NUMBER,
 218                                         _nc_get_table(_nc_syntax != 0));
 219
 220                 /* map terminfo's string MT to MT */
 221                 else if (token_type==STRING &&!strcmp("MT",_nc_curr_token.tk_name))
 222                     entry_ptr = _nc_find_type_entry("MT", STRING,
 223                                         _nc_get_table(_nc_syntax != 0));
 224
 225                 /* treat strings without following "=" as empty strings */
 226                 else if (token_type==BOOLEAN && entry_ptr->nte_type==STRING)
 227                     token_type = STRING;
 228                 /* we couldn't recover; skip this token */
 229                 else
 230                 {
 231                     if (!silent)
 232                     {
 233                         const char *type_name;
 234                         switch (entry_ptr->nte_type)
 235                         {
 236                         case BOOLEAN:
 237                                 type_name = "boolean";
 238                                 break;
 239                         case STRING:
 240                                 type_name = "string";
 241                                 break;
 242                         case NUMBER:
 243                                 type_name = "numeric";
 244                                 break;
 245                         default:
 246                                 type_name = "unknown";
 247                                 break;
 248                         }
 249                         _nc_warning("wrong type used for %s capability '%s'",
 250                                 type_name, _nc_curr_token.tk_name);
 251                     }
 252                     continue;
 253                 }
 254             }
 255
 256             /* now we know that the type/value combination is OK */
 257             switch (token_type) {
 258             case CANCEL:
 259                 switch (entry_ptr->nte_type) {
 260                 case BOOLEAN:
 261                     entryp->tterm.Booleans[entry_ptr->nte_index] = CANCELLED_BOOLEAN;
 262                     break;
 263
 264                 case NUMBER:
 265                     entryp->tterm.Numbers[entry_ptr->nte_index] = CANCELLED_NUMERIC;
 266                     break;
 267
 268                 case STRING:
 269                     entryp->tterm.Strings[entry_ptr->nte_index] = CANCELLED_STRING;
 270                     break;
 271                 }
 272                 break;
 273
 274             case BOOLEAN:
 275                 entryp->tterm.Booleans[entry_ptr->nte_index] = TRUE;
 276                 break;
 277
 278             case NUMBER:
 279                 entryp->tterm.Numbers[entry_ptr->nte_index] =
 280                     _nc_curr_token.tk_valnumber;
 281                 break;
 282
 283             case STRING:
 284                 ptr = _nc_curr_token.tk_valstring;
 285                 if (_nc_syntax==SYN_TERMCAP)
 286                     ptr = _nc_captoinfo(_nc_curr_token.tk_name,
 287                                     ptr,
 288                                     parametrized[entry_ptr->nte_index]);
 289                 entryp->tterm.Strings[entry_ptr->nte_index] = _nc_save_str(ptr);
 290                 break;
 291
 292             default:
 293                 if (!silent)
 294                     _nc_warning("unknown token type");
 295                 _nc_panic_mode((_nc_syntax==SYN_TERMCAP) ? ':' : ',');
 296                 continue;
 297             }
 298         } /* end else cur_token.name != "use" */
 299     nexttok:
 300         continue;       /* cannot have a label w/o statement */
 301     } /* endwhile (not EOF and not NAMES) */
 302
 303     _nc_push_token(token_type);
 304     _nc_set_type(_nc_first_name(entryp->tterm.term_names));
 305
 306     /*
 307      * Try to deduce as much as possible from extension capabilities
 308      * (this includes obsolete BSD capabilities).  Sigh...it would be more
 309      * space-efficient to call this after use resolution, but it has
 310      * to be done before entry allocation is wrapped up.
 311      */
 312     if (!literal)
 313         if (_nc_syntax == SYN_TERMCAP)
 314         {
 315             bool        has_base_entry = FALSE;
 316             int         i;
 317
 318             /*
 319              * Don't insert defaults if this is a `+' entry meant only
 320              * for inclusion in other entries (not sure termcap ever
 321              * had these, actually).
 322              */
 323             if (strchr(entryp->tterm.term_names, '+'))
 324                 has_base_entry = TRUE;
 325             else
 326                 /*
 327                  * Otherwise, look for a base entry that will already
 328                  * have picked up defaults via translation.
 329                  */
 330                 for (i = 0; i < entryp->nuses; i++)
 331                     if (!strchr(entryp->uses[i].parent, '+'))
 332                         has_base_entry = TRUE;
 333
 334             postprocess_termcap(&entryp->tterm, has_base_entry);
 335         }
 336         else
 337             postprocess_terminfo(&entryp->tterm);
 338
 339     _nc_wrap_entry(entryp);
 340
 341     return(OK);
 342 }
 343
 344 int _nc_capcmp(const char *s, const char *t)
 345 /* compare two string capabilities, stripping out padding */
 346 {
 347     if (!s && !t)
 348         return(0);
 349     else if (!s || !t)
 350         return(1);
 351
 352     for (;;)
 353     {
 354         if (s[0] == '$' && s[1] == '<')
 355         {
 356             for (s += 2; ; s++)
 357                 if (!(isdigit(*s) || *s=='.' || *s=='*' || *s=='/' || *s=='>'))
 358                     break;
 359         }
 360
 361         if (t[0] == '$' && t[1] == '<')
 362         {
 363             for (t += 2; ; t++)
 364                 if (!(isdigit(*t) || *t=='.' || *t=='*' || *t=='/' || *t=='>'))
 365                     break;
 366         }
 367
 368         /* we've now pushed s and t past any padding they were pointing at */
 369
 370         if (*s == '\0' && *t == '\0')
 371                 return(0);
 372
 373         if (*s != *t)
 374             return(*t - *s);
 375
 376         /* else *s == *t but one is not NUL, so continue */
 377         s++, t++;
 378     }
 379 }
 380
 381 /*
 382  * The ko capability, if present, consists of a comma-separated capability
 383  * list.  For each capability, we may assume there is a keycap that sends the
 384  * string which is the value of that capability.
 385  */
 386 typedef struct {const char *from; const char *to;} assoc;
 387 static assoc const ko_xlate[] =
 388 {
 389     {"al",      "kil1"},        /* insert line key  -> KEY_IL    */
 390     {"bt",      "kcbt"},        /* back tab         -> KEY_BTAB  */
 391     {"cd",      "ked"},         /* clear-to-eos key -> KEY_EOL   */
 392     {"ce",      "kel"},         /* clear-to-eol key -> KEY_EOS   */
 393     {"cl",      "kclr"},        /* clear key        -> KEY_CLEAR */
 394     {"ct",      "tbc"},         /* clear all tabs   -> KEY_CATAB */
 395     {"dc",      "kdch1"},       /* delete char      -> KEY_DC    */
 396     {"dl",      "kdl1"},        /* delete line      -> KEY_DL    */
 397     {"do",      "kcud1"},       /* down key         -> KEY_DOWN  */
 398     {"ei",      "krmir"},       /* exit insert key  -> KEY_EIC   */
 399     {"ho",      "khome"},       /* home key         -> KEY_HOME  */
 400     {"ic",      "kich1"},       /* insert char key  -> KEY_IC    */
 401     {"im",      "kIC"},         /* insert-mode key  -> KEY_SIC   */
 402     {"le",      "kcub1"},       /* le key           -> KEY_LEFT  */
 403     {"nd",      "kcuf1"},       /* nd key           -> KEY_RIGHT */
 404     {"nl",      "kent"},        /* new line key     -> KEY_ENTER */
 405     {"st",      "khts"},        /* set-tab key      -> KEY_STAB  */
 406     {"ta",      CANCELLED_STRING},
 407     {"up",      "kcuu1"},       /* up-arrow key     -> KEY_UP    */
 408     {(char *)NULL, (char *)NULL},
 409 };
 410
 411 /*
 412  * This routine fills in string caps that either had defaults under
 413  * termcap or can be manufactured from obsolete termcap capabilities.
 414  * It was lifted from Ross Ridge's mytinfo package.
 415  */
 416
 417 static const char C_CR[] = "\r";
 418 static const char C_LF[] = "\n";
 419 static const char C_BS[] = "\b";
 420 static const char C_HT[] = "\t";
 421
 422 /*
 423  * Note that WANTED and PRESENT are not simple inverses!  If a capability
 424  * has been explicitly cancelled, it's not considered WANTED.
 425  */
 426 #define WANTED(s)       ((s) == (char *)NULL)
 427 #define PRESENT(s)      (((s) != (char *)NULL) && ((s) != CANCELLED_STRING))
 428
 429 /*
 430  * This bit of legerdemain turns all the terminfo variable names into
 431  * references to locations in the arrays Booleans, Numbers, and Strings ---
 432  * precisely what's needed.
 433  */
 434
 435 #undef CUR
 436 #define CUR tp->
 437
 438 static
 439 void postprocess_termcap(TERMTYPE *tp, bool has_base)
 440 {
 441     char buf[MAX_LINE * 2 + 2];
 442
 443     /*
 444      * TERMCAP DEFAULTS AND OBSOLETE-CAPABILITY TRANSLATIONS
 445      *
 446      * This first part of the code is the functional inverse of the
 447      * fragment in capdefaults.c.
 448      * ----------------------------------------------------------------------
 449      */
 450
 451     /* if there was a tc entry, assume we picked up defaults via that */
 452     if (!has_base)
 453     {
 454         if (WANTED(init_3string) && termcap_init2)
 455             init_3string = _nc_save_str(termcap_init2);
 456
 457         if (WANTED(reset_1string) && termcap_reset)
 458             reset_1string = _nc_save_str(termcap_reset);
 459
 460         if (WANTED(carriage_return)) {
 461             if (carriage_return_delay > 0) {
 462                 sprintf(buf, "%s$<%d>", C_CR, carriage_return_delay);
 463                 carriage_return = _nc_save_str(buf);
 464             } else
 465                 carriage_return = _nc_save_str(C_CR);
 466         }
 467         if (WANTED(cursor_left)) {
 468             if (backspace_delay > 0) {
 469                 sprintf(buf, "%s$<%d>", C_BS, backspace_delay);
 470                 cursor_left = _nc_save_str(buf);
 471             } else if (backspaces_with_bs == 1)
 472                 cursor_left = _nc_save_str(C_BS);
 473             else if (PRESENT(backspace_if_not_bs))
 474                 cursor_left = backspace_if_not_bs;
 475         }
 476         /* vi doesn't use "do", but it does seems to use nl (or '\n') instead */
 477         if (WANTED(cursor_down)) {
 478             if (PRESENT(linefeed_if_not_lf))
 479                 cursor_down = linefeed_if_not_lf;
 480             else if (linefeed_is_newline != 1) {
 481                 if (new_line_delay > 0) {
 482                     sprintf(buf, "%s$<%d>", C_LF, new_line_delay);
 483                     cursor_down = _nc_save_str(buf);
 484                 } else
 485                     cursor_down = _nc_save_str(C_LF);
 486             }
 487         }
 488         if (WANTED(scroll_forward) && crt_no_scrolling != 1) {
 489             if (PRESENT(linefeed_if_not_lf))
 490                 cursor_down = linefeed_if_not_lf;
 491             else if (linefeed_is_newline != 1) {
 492                 if (new_line_delay > 0) {
 493                     sprintf(buf, "%s$<%d>", C_LF, new_line_delay);
 494                     scroll_forward = _nc_save_str(buf);
 495                 } else
 496                     scroll_forward = _nc_save_str(C_LF);
 497             }
 498         }
 499         if (WANTED(newline)) {
 500             if (linefeed_is_newline == 1) {
 501                 if (new_line_delay > 0) {
 502                     sprintf(buf, "%s$<%d>", C_LF, new_line_delay);
 503                     newline = _nc_save_str(buf);
 504                 } else
 505                     newline = _nc_save_str(C_LF);
 506             } else if (PRESENT(carriage_return) && PRESENT(scroll_forward)) {
 507                 strncpy(buf, carriage_return, MAX_LINE-2);
 508                 buf[MAX_LINE-1] = '\0';
 509                 strncat(buf, scroll_forward, MAX_LINE-strlen(buf)-1);
 510                 buf[MAX_LINE] = '\0';
 511                 newline = _nc_save_str(buf);
 512             } else if (PRESENT(carriage_return) && PRESENT(cursor_down)) {
 513                 strncpy(buf, carriage_return, MAX_LINE-2);
 514                 buf[MAX_LINE-1] = '\0';
 515                 strncat(buf, cursor_down, MAX_LINE-strlen(buf)-1);
 516                 buf[MAX_LINE] = '\0';
 517                 newline = _nc_save_str(buf);
 518             }
 519         }
 520     }
 521
 522     /*
 523      * Inverse of capdefaults.c code ends here.
 524      * ----------------------------------------------------------------------
 525      *
 526      * TERMCAP-TO TERMINFO MAPPINGS FOR SOURCE TRANSLATION
 527      *
 528      * These translations will *not* be inverted by tgetent().
 529      */
 530
 531     if (!has_base)
 532     {
 533         /*
 534          * We wait until now to decide if we've got a working cr because even
 535          * one that doesn't work can be used for newline. Unfortunately the
 536          * space allocated for it is wasted.
 537          */
 538         if (return_does_clr_eol == 1 || no_correctly_working_cr == 1)
 539             carriage_return = NULL;
 540
 541         /*
 542          * Supposedly most termcap entries have ta now and '\t' is no longer a
 543          * default, but it doesn't seem to be true...
 544          */
 545         if (WANTED(tab)) {
 546             if (horizontal_tab_delay > 0) {
 547                 sprintf(buf, "%s$<%d>", C_HT, horizontal_tab_delay);
 548                 tab = _nc_save_str(buf);
 549             } else
 550                 tab = _nc_save_str(C_HT);
 551         }
 552         if (init_tabs == -1 && has_hardware_tabs == TRUE)
 553             init_tabs = 8;
 554
 555         /*
 556          * Assume we can beep with ^G unless we're given bl@.
 557          */
 558         if (WANTED(bell))
 559             bell = _nc_save_str("\007");
 560     }
 561
 562     /*
 563      * Translate the old termcap :pt: capability to it#8 + ht=\t
 564      */
 565     if (has_hardware_tabs == TRUE)
 566         if (init_tabs != 8)
 567             _nc_warning("hardware tabs with a width other than 8: %d", init_tabs);
 568         else
 569         {
 570             if (tab && _nc_capcmp(tab, C_HT))
 571                 _nc_warning("hardware tabs with a non-^I tab string %s",
 572                             _nc_visbuf(tab));
 573             else
 574             {
 575                 if (WANTED(tab))
 576                     tab = _nc_save_str(C_HT);
 577                 init_tabs = 8;
 578             }
 579         }
 580
 581     /*
 582      * Now translate the ko capability, if there is one.  This
 583      * isn't from mytinfo...
 584      */
 585     if (PRESENT(other_non_function_keys))
 586     {
 587         char    *dp, *cp = strtok(other_non_function_keys, ",");
 588         struct name_table_entry const *from_ptr;
 589         struct name_table_entry const *to_ptr;
 590         assoc   const *ap;
 591         char    buf2[MAX_TERMINFO_LENGTH];
 592         bool    foundim;
 593
 594         /* we're going to use this for a special case later */
 595         dp = strchr(other_non_function_keys, 'i');
 596         foundim = dp && dp[1] == 'm';
 597
 598         /* look at each comma-separated capability in the ko string... */
 599         do {
 600             for (ap = ko_xlate; ap->from; ap++)
 601                 if (strcmp(ap->from, cp) == 0)
 602                     break;
 603             if (!ap->to)
 604             {
 605                 _nc_warning("unknown capability `%s' in ko string", cp);
 606                 continue;
 607             }
 608             else if (ap->to == CANCELLED_STRING)        /* ignore it */
 609                 continue;
 610
 611             /* now we know we found a match in ko_table, so... */
 612
 613             from_ptr = _nc_find_entry(ap->from, _nc_cap_hash_table);
 614             to_ptr   = _nc_find_entry(ap->to,   _nc_info_hash_table);
 615
 616             if (!from_ptr || !to_ptr)   /* should never happen! */
 617                 _nc_err_abort("ko translation table is invalid, I give up");
 618
 619             if (WANTED(tp->Strings[from_ptr->nte_index]))
 620             {
 621                 _nc_warning("no value for ko capability %s", ap->from);
 622                 continue;
 623             }
 624
 625             if (tp->Strings[to_ptr->nte_index])
 626             {
 627                 /* There's no point in warning about it if it's the same
 628                  * string; that's just an inefficiency.
 629                  */
 630                 if (strcmp(
 631                         tp->Strings[from_ptr->nte_index],
 632                         tp->Strings[to_ptr->nte_index]) != 0)
 633                     _nc_warning("%s (%s) already has an explicit value %s, ignoring ko",
 634                             ap->to, ap->from,
 635                             _nc_visbuf(tp->Strings[to_ptr->nte_index]) );
 636                 continue;
 637             }
 638
 639             /*
 640              * The magic moment -- copy the mapped key string over,
 641              * stripping out padding.
 642              */
 643             dp = buf2;
 644             for (cp = tp->Strings[from_ptr->nte_index]; *cp; cp++)
 645             {
 646                 if (cp[0] == '$' && cp[1] == '<')
 647                 {
 648                     while (*cp && *cp != '>')
 649                         if (!*cp)
 650                             break;
 651                         else
 652                             ++cp;
 653                 }
 654                 else
 655                     *dp++ = *cp;
 656             }
 657             *dp++ = '\0';
 658
 659             tp->Strings[to_ptr->nte_index] = _nc_save_str(buf2);
 660         } while
 661             ((cp = strtok((char *)NULL, ",")) != 0);
 662
 663         /*
 664          * Note: ko=im and ko=ic both want to grab the `Insert'
 665          * keycap.  There's a kich1 but no ksmir, so the ic capability
 666          * got mapped to kich1 and im to kIC to avoid a collision.
 667          * If the description has im but not ic, hack kIC back to kich1.
 668          */
 669         if (foundim && WANTED(key_ic) && key_sic)
 670         {
 671             key_ic = key_sic;
 672             key_sic = ABSENT_STRING;
 673         }
 674     }
 675
 676     if (!hard_copy)
 677     {
 678         if (WANTED(key_backspace))
 679             key_backspace = _nc_save_str(C_BS);
 680         if (WANTED(key_left))
 681             key_left = _nc_save_str(C_BS);
 682         if (WANTED(key_down))
 683             key_down = _nc_save_str(C_LF);
 684     }
 685
 686     /*
 687      * Translate XENIX forms characters.
 688      */
 689     if (PRESENT(acs_ulcorner) ||
 690         PRESENT(acs_llcorner) ||
 691         PRESENT(acs_urcorner) ||
 692         PRESENT(acs_lrcorner) ||
 693         PRESENT(acs_ltee) ||
 694         PRESENT(acs_rtee) ||
 695         PRESENT(acs_btee) ||
 696         PRESENT(acs_ttee) ||
 697         PRESENT(acs_hline) ||
 698         PRESENT(acs_vline) ||
 699         PRESENT(acs_plus))
 700     {
 701         char    buf2[MAX_TERMCAP_LENGTH], *bp = buf2;
 702
 703         if (acs_ulcorner && acs_ulcorner[1] == '\0')
 704         {
 705             *bp++ = 'l';
 706             *bp++ = *acs_ulcorner;
 707         }
 708         if (acs_llcorner && acs_llcorner[1] == '\0')
 709         {
 710             *bp++ = 'm';
 711             *bp++ = *acs_llcorner;
 712         }
 713         if (acs_urcorner && acs_urcorner[1] == '\0')
 714         {
 715             *bp++ = 'k';
 716             *bp++ = *acs_urcorner;
 717         }
 718         if (acs_lrcorner && acs_lrcorner[1] == '\0')
 719         {
 720             *bp++ = 'j';
 721             *bp++ = *acs_lrcorner;
 722         }
 723         if (acs_ltee && acs_ltee[1] == '\0')
 724         {
 725             *bp++ = 't';
 726             *bp++ = *acs_ltee;
 727         }
 728         if (acs_rtee && acs_rtee[1] == '\0')
 729         {
 730             *bp++ = 'u';
 731             *bp++ = *acs_rtee;
 732         }
 733         if (acs_btee && acs_btee[1] == '\0')
 734         {
 735             *bp++ = 'v';
 736             *bp++ = *acs_btee;
 737         }
 738         if (acs_ttee && acs_ttee[1] == '\0')
 739         {
 740             *bp++ = 'w';
 741             *bp++ = *acs_ttee;
 742         }
 743         if (acs_hline && acs_hline[1] == '\0')
 744         {
 745             *bp++ = 'q';
 746             *bp++ = *acs_hline;
 747         }
 748         if (acs_vline && acs_vline[1] == '\0')
 749         {
 750             *bp++ = 'x';
 751             *bp++ = *acs_vline;
 752         }
 753         if (acs_plus)
 754         {
 755             *bp++ = 'n';
 756             strcpy(bp, acs_plus);
 757             bp = buf2 + strlen(buf2);
 758         }
 759
 760         if (bp != buf2)
 761         {
 762             *bp++ = '\0';
 763             acs_chars = _nc_save_str(buf2);
 764             _nc_warning("acsc string synthesized from XENIX capabilities");
 765         }
 766     }
 767 }
 768
 769 static
 770 void postprocess_terminfo(TERMTYPE *tp)
 771 {
 772     /*
 773      * TERMINFO-TO-TERMINFO MAPPINGS FOR SOURCE TRANSLATION
 774      * ----------------------------------------------------------------------
 775      */
 776
 777     /*
 778      * Translate AIX forms characters.
 779      */
 780     if (PRESENT(box_chars_1))
 781     {
 782         char    buf2[MAX_TERMCAP_LENGTH], *bp = buf2;
 783
 784         if (box_chars_1[0])     /* ACS_ULCORNER */
 785         {
 786             *bp++ = 'l';
 787             *bp++ = box_chars_1[0];
 788         }
 789         if (box_chars_1[1])     /* ACS_HLINE */
 790         {
 791             *bp++ = 'q';
 792             *bp++ = box_chars_1[1];
 793         }
 794         if (box_chars_1[2])     /* ACS_URCORNER */
 795         {
 796             *bp++ = 'k';
 797             *bp++ = box_chars_1[2];
 798         }
 799         if (box_chars_1[3])     /* ACS_VLINE */
 800         {
 801             *bp++ = 'x';
 802             *bp++ = box_chars_1[3];
 803         }
 804         if (box_chars_1[4])     /* ACS_LRCORNER */
 805         {
 806             *bp++ = 'j';
 807             *bp++ = box_chars_1[4];
 808         }
 809         if (box_chars_1[5])     /* ACS_LLCORNER */
 810         {
 811             *bp++ = 'm';
 812             *bp++ = box_chars_1[5];
 813         }
 814         if (box_chars_1[6])     /* ACS_TTEE */
 815         {
 816             *bp++ = 'w';
 817             *bp++ = box_chars_1[6];
 818         }
 819         if (box_chars_1[7])     /* ACS_RTEE */
 820         {
 821             *bp++ = 'u';
 822             *bp++ = box_chars_1[7];
 823         }
 824         if (box_chars_1[8])     /* ACS_BTEE */
 825         {
 826             *bp++ = 'v';
 827             *bp++ = box_chars_1[8];
 828         }
 829         if (box_chars_1[9])     /* ACS_LTEE */
 830         {
 831             *bp++ = 't';
 832             *bp++ = box_chars_1[9];
 833         }
 834         if (box_chars_1[10])    /* ACS_PLUS */
 835         {
 836             *bp++ = 'n';
 837             *bp++ = box_chars_1[10];
 838         }
 839
 840         if (bp != buf2)
 841         {
 842             *bp++ = '\0';
 843             acs_chars = _nc_save_str(buf2);
 844             _nc_warning("acsc string synthesized from AIX capabilities");
 845             box_chars_1 = ABSENT_STRING;
 846         }
 847     }
 848     /*
 849      * ----------------------------------------------------------------------
 850      */
 851 }
 852
 853 /*
 854  * Do a linear search through the terminfo tables to find a given full-name.
 855  * We don't expect to do this often, so there's no hashing function.
 856  *
 857  * In effect, this scans through the 3 lists of full-names, and looks them
 858  * up in _nc_info_table, which is organized so that the nte_index fields are
 859  * sorted, but the nte_type fields are not necessarily grouped together.
 860  */
 861 static
 862 struct name_table_entry const * lookup_fullname(const char *find)
 863 {
 864     int state = -1;
 865
 866     for (;;) {
 867         int count = 0;
 868         char *const *names;
 869
 870         switch (++state) {
 871         case BOOLEAN:
 872             names = boolfnames;
 873             break;
 874         case STRING:
 875             names = strfnames;
 876             break;
 877         case NUMBER:
 878             names = numfnames;
 879             break;
 880         default:
 881             return NOTFOUND;
 882         }
 883
 884         for (count = 0; names[count] != 0; count++) {
 885             if (!strcmp(names[count], find)) {
 886                 struct name_table_entry const *entry_ptr = _nc_get_table(FALSE);
 887                 while (entry_ptr->nte_type  != state
 888                     || entry_ptr->nte_index != count)
 889                         entry_ptr++;
 890                 return entry_ptr;
 891             }
 892         }
 893     }
 894 }
 895
 896 /* parse_entry.c ends here */