lib/libterminfo/termcap.c

   1 /* $NetBSD: termcap.c,v 1.17 2011/11/13 15:24:04 christos Exp $ */
   2
   3 /*
   4  * Copyright (c) 2009 The NetBSD Foundation, Inc.
   5  *
   6  * This code is derived from software contributed to The NetBSD Foundation
   7  * by Roy Marples.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  19  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  20  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  21  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  22  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  23  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  24  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  25  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  */
  29
  30 #include <sys/cdefs.h>
  31 __RCSID("$NetBSD: termcap.c,v 1.17 2011/11/13 15:24:04 christos Exp $");
  32
  33 #include <assert.h>
  34 #include <ctype.h>
  35 #include <errno.h>
  36 #include <stdint.h>
  37 #include <string.h>
  38 #include <term_private.h>
  39 #include <term.h>
  40 #include <termcap.h>
  41 #include <unistd.h>
  42 #include <stdio.h>
  43
  44 #include "termcap_map.c"
  45 #include "termcap_hash.c"
  46
  47 char *UP;
  48 char *BC;
  49
  50 /* ARGSUSED */
  51 int
  52 tgetent(__unused char *bp, const char *name)
  53 {
  54         int errret;
  55         static TERMINAL *last = NULL;
  56
  57         _DIAGASSERT(name != NULL);
  58
  59         /* Free the old term */
  60         if (last != NULL) {
  61                 del_curterm(last);
  62                 last = NULL;
  63         }
  64         errret = -1;
  65         if (setupterm(name, STDOUT_FILENO, &errret) != 0)
  66                 return errret;
  67         last = cur_term;
  68
  69         if (pad_char != NULL)
  70                 PC = pad_char[0];
  71         UP = __UNCONST(cursor_up);
  72         BC = __UNCONST(cursor_left);
  73         return 1;
  74 }
  75
  76 int
  77 tgetflag(const char *id2)
  78 {
  79         uint32_t ind;
  80         size_t i;
  81         TERMUSERDEF *ud;
  82         const char id[] = { id2[0], id2[0] ? id2[1] : '\0', '\0' };
  83
  84         if (cur_term == NULL)
  85                 return 0;
  86
  87         ind = _t_flaghash((const unsigned char *)id, strlen(id));
  88         if (ind <= __arraycount(_ti_cap_flagids)) {
  89                 if (strcmp(id, _ti_cap_flagids[ind].id) == 0)
  90                         return cur_term->flags[_ti_cap_flagids[ind].ti];
  91         }
  92         for (i = 0; i < cur_term->_nuserdefs; i++) {
  93                 ud = &cur_term->_userdefs[i];
  94                 if (ud->type == 'f' && strcmp(ud->id, id) == 0)
  95                         return ud->flag;
  96         }
  97         return 0;
  98 }
  99
 100 int
 101 tgetnum(const char *id2)
 102 {
 103         uint32_t ind;
 104         size_t i;
 105         TERMUSERDEF *ud;
 106         const TENTRY *te;
 107         const char id[] = { id2[0], id2[0] ? id2[1] : '\0', '\0' };
 108
 109         if (cur_term == NULL)
 110                 return -1;
 111
 112         ind = _t_numhash((const unsigned char *)id, strlen(id));
 113         if (ind <= __arraycount(_ti_cap_numids)) {
 114                 te = &_ti_cap_numids[ind];
 115                 if (strcmp(id, te->id) == 0) {
 116                         if (!VALID_NUMERIC(cur_term->nums[te->ti]))
 117                                 return ABSENT_NUMERIC;
 118                         return cur_term->nums[te->ti];
 119                 }
 120         }
 121         for (i = 0; i < cur_term->_nuserdefs; i++) {
 122                 ud = &cur_term->_userdefs[i];
 123                 if (ud->type == 'n' && strcmp(ud->id, id) == 0) {
 124                         if (!VALID_NUMERIC(ud->num))
 125                                 return ABSENT_NUMERIC;
 126                         return ud->num;
 127                 }
 128         }
 129         return -1;
 130 }
 131
 132 char *
 133 tgetstr(const char *id2, char **area)
 134 {
 135         uint32_t ind;
 136         size_t i;
 137         TERMUSERDEF *ud;
 138         const char *str;
 139         const char id[] = { id2[0], id2[0] ? id2[1] : '\0', '\0' };
 140
 141         if (cur_term == NULL)
 142                 return NULL;
 143
 144         str = NULL;
 145         ind = _t_strhash((const unsigned char *)id, strlen(id));
 146         if (ind <= __arraycount(_ti_cap_strids)) {
 147                 if (strcmp(id, _ti_cap_strids[ind].id) == 0) {
 148                         str = cur_term->strs[_ti_cap_strids[ind].ti];
 149                         if (str == NULL)
 150                                 return NULL;
 151                 }
 152         }
 153         if (str != NULL)
 154                 for (i = 0; i < cur_term->_nuserdefs; i++) {
 155                         ud = &cur_term->_userdefs[i];
 156                         if (ud->type == 's' && strcmp(ud->id, id) == 0)
 157                                 str = ud->str;
 158                 }
 159
 160         /* XXX: FXIXME
 161          * We should fix sgr0(me) as it has a slightly different meaning
 162          * for termcap. */
 163
 164         if (str != NULL && area != NULL && *area != NULL) {
 165                 char *s;
 166                 s = *area;
 167                 strcpy(*area, str);
 168                 *area += strlen(*area) + 1;
 169                 return s;
 170         }
 171
 172         return __UNCONST(str);
 173 }
 174
 175 char *
 176 tgoto(const char *cm, int destcol, int destline)
 177 {
 178         _DIAGASSERT(cm != NULL);
 179         return tiparm(cm, destline, destcol);
 180 }
 181
 182 static const char *
 183 flagname(const char *key)
 184 {
 185         uint32_t idx;
 186
 187         idx = _t_flaghash((const unsigned char *)key, strlen(key));
 188         if (idx <= __arraycount(_ti_cap_flagids) &&
 189             strcmp(key, _ti_cap_flagids[idx].id) == 0)
 190                 return _ti_flagid(_ti_cap_flagids[idx].ti);
 191         return key;
 192 }
 193
 194 static const char *
 195 numname(const char *key)
 196 {
 197         uint32_t idx;
 198
 199         idx = _t_numhash((const unsigned char *)key, strlen(key));
 200         if (idx <= __arraycount(_ti_cap_numids) &&
 201             strcmp(key, _ti_cap_numids[idx].id) == 0)
 202                 return _ti_numid(_ti_cap_numids[idx].ti);
 203         return key;
 204 }
 205
 206 static const char *
 207 strname(const char *key)
 208 {
 209         uint32_t idx;
 210
 211         idx = _t_strhash((const unsigned char *)key, strlen(key));
 212         if (idx <= __arraycount(_ti_cap_strids) &&
 213             strcmp(key, _ti_cap_strids[idx].id) == 0)
 214                 return _ti_strid(_ti_cap_strids[idx].ti);
 215
 216         if (strcmp(key, "tc") == 0)
 217                 return "use";
 218
 219         return key;
 220 }
 221
 222 /* Print a parameter if needed */
 223 static int
 224 printparam(char **dst, char p, int *nop)
 225 {
 226         if (*nop != 0) {
 227                 *nop = 0;
 228                 return 0;
 229         }
 230
 231         *(*dst)++ = '%';
 232         *(*dst)++ = 'p';
 233         *(*dst)++ = '0' + p;
 234         return 3;
 235 }
 236
 237 /* Convert a termcap character into terminfo equivalents */
 238 static int
 239 printchar(char **dst, const char **src)
 240 {
 241         unsigned char v;
 242         int l;
 243
 244         l = 4;
 245         v = (unsigned char) *++(*src);
 246         if (v == '\\') {
 247                 v = (unsigned char) *++(*src);
 248                 switch (v) {
 249                 case '0':
 250                 case '1':
 251                 case '2':
 252                 case '3':
 253                         v = 0;
 254                         while (isdigit((unsigned char) **src))
 255                                 v = 8 * v + ((unsigned char) *(*src)++ - '0');
 256                         (*src)--;
 257                         break;
 258                 case '\0':
 259                         v = '\\';
 260                         break;
 261                 }
 262         } else if (v == '^')
 263                 v = (unsigned char) (*++(*src) & 0x1f);
 264         *(*dst)++ = '%';
 265         if (isgraph(v) && v != ',' && v != '\'' && v != '\\' && v != ':') {
 266                 *(*dst)++ = '\'';
 267                 *(*dst)++ = v;
 268                 *(*dst)++ = '\'';
 269         } else {
 270                 *(*dst)++ = '{';
 271                 if (v > 99) {
 272                         *(*dst)++ = '0'+ v / 100;
 273                         l++;
 274                 }
 275                 if (v > 9) {
 276                         *(*dst)++ = '0' + ((int) (v / 10)) % 10;
 277                         l++;
 278                 }
 279                 *(*dst)++ = '0' + v % 10;
 280                 *(*dst)++ = '}';
 281         }
 282         return l;
 283 }
 284
 285 /* Convert termcap commands into terminfo commands */
 286 static const char fmtB[] = "%p0%{10}%/%{16}%*%p0%{10}%m%+";
 287 static const char fmtD[] = "%p0%p0%{2}%*%-";
 288 static const char fmtIf[] = "%p0%p0%?";
 289 static const char fmtThen[] = "%>%t";
 290 static const char fmtElse[] = "%+%;";
 291
 292 static char *
 293 strval(const char *val)
 294 {
 295         char *info, *ip, c;
 296         const char *ps, *pe;
 297         int p, nop;
 298         size_t len, l;
 299
 300         len = 1024; /* no single string should be bigger */
 301         info = ip = malloc(len);
 302         if (info == NULL)
 303                 return 0;
 304
 305         /* Move the = */
 306         *ip++ = *val++;
 307
 308         /* Set ps and pe to point to the start and end of the padding */
 309         if (isdigit((unsigned char)*val)) {
 310                 for (ps = pe = val;
 311                      isdigit((unsigned char)*val) || *val == '.';
 312                      val++)
 313                         pe++;
 314                 if (*val == '*') {
 315                         val++;
 316                         pe++;
 317                 }
 318         } else
 319                 ps = pe  = NULL;
 320
 321         l = nop = 0;
 322         p = 1;
 323         for (; *val != '\0'; val++) {
 324                 if (l + 2 > len)
 325                         goto elen;
 326                 if (*val != '%') {
 327                         if (*val == ',') {
 328                                 if (l + 3 > len)
 329                                         goto elen;
 330                                 *ip++ = '\\';
 331                                 l++;
 332                         }
 333                         *ip++ = *val;
 334                         l++;
 335                         continue;
 336                 }
 337                 switch (c = *++(val)) {
 338                 case 'B':
 339                         if (l + sizeof(fmtB) > len)
 340                                 goto elen;
 341                         memcpy(ip, fmtB, sizeof(fmtB) - 1);
 342                         /* Replace the embedded parameters with real ones */
 343                         ip[2] += p;
 344                         ip[19] += p;
 345                         ip += sizeof(fmtB) - 1;
 346                         l += sizeof(fmtB) - 1;
 347                         nop = 1;
 348                         continue;
 349                 case 'D':
 350                         if (l + sizeof(fmtD) > len)
 351                                 goto elen;
 352                         memcpy(ip, fmtD, sizeof(fmtD) - 1);
 353                         /* Replace the embedded parameters with real ones */
 354                         ip[2] += p;
 355                         ip[5] += p;
 356                         ip += sizeof(fmtD) - 1;
 357                         l += sizeof(fmtD) - 1;
 358                         nop = 1;
 359                         continue;
 360                 case 'r':
 361                         /* non op as switched below */
 362                         break;
 363                 case '2': /* FALLTHROUGH */
 364                 case '3': /* FALLTHROUGH */
 365                 case 'd':
 366                         if (l + 7 > len)
 367                                 goto elen;
 368                         l += printparam(&ip, p, &nop);
 369                         *ip++ = '%';
 370                         if (c != 'd') {
 371                                 *ip++ = c;
 372                                 l++;
 373                         }
 374                         *ip++ = 'd';
 375                         l += 2;
 376                         break;
 377                 case '+':
 378                         if (l + 13 > len)
 379                                 goto elen;
 380                         l += printparam(&ip, p, &nop);
 381                         l += printchar(&ip, &val);
 382                         *ip++ = '%';
 383                         *ip++ = c;
 384                         *ip++ = '%';
 385                         *ip++ = 'c';
 386                         l += 7;
 387                         break;
 388                 case '>':
 389                         if (l + sizeof(fmtIf) + sizeof(fmtThen) +
 390                             sizeof(fmtElse) + (6 * 2) > len)
 391                                 goto elen;
 392
 393                         memcpy(ip, fmtIf, sizeof(fmtIf) - 1);
 394                         /* Replace the embedded parameters with real ones */
 395                         ip[2] += p;
 396                         ip[5] += p;
 397                         ip += sizeof(fmtIf) - 1;
 398                         l += sizeof(fmtIf) - 1;
 399                         l += printchar(&ip, &val);
 400                         memcpy(ip, fmtThen, sizeof(fmtThen) - 1);
 401                         ip += sizeof(fmtThen) - 1;
 402                         l += sizeof(fmtThen) - 1;
 403                         l += printchar(&ip, &val);
 404                         memcpy(ip, fmtElse, sizeof(fmtElse) - 1);
 405                         ip += sizeof(fmtElse) - 1;
 406                         l += sizeof(fmtElse) - 1;
 407                         l += 16;
 408                         nop = 1;
 409                         continue;
 410                 case '.':
 411                         if (l + 6 > len)
 412                                 goto elen;
 413                         l += printparam(&ip, p, &nop);
 414                         *ip++ = '%';
 415                         *ip++ = 'c';
 416                         l += 2;
 417                         break;
 418                 default:
 419                         /* Hope it matches a terminfo command. */
 420                         *ip++ = '%';
 421                         *ip++ = c;
 422                         l += 2;
 423                         if (c == 'i')
 424                                 continue;
 425                         break;
 426                 }
 427                 /* Swap p1 and p2 */
 428                 p = 3 - p;
 429         }
 430
 431         /* \E\ is valid termcap.
 432          * We need to escape the final \ for terminfo. */
 433         if (l > 2 && info[l - 1] == '\\' &&
 434             (info[l - 2] != '\\' && info[l - 2] != '^'))
 435         {
 436                 if (l + 1 > len)
 437                         goto elen;
 438                 *ip++ = '\\';
 439         }
 440
 441         /* Add our padding at the end. */
 442         if (ps != NULL) {
 443                 size_t n = pe - ps;
 444                 if (l + n + 4 > len)
 445                         goto elen;
 446                 *ip++ = '$';
 447                 *ip++ = '<';
 448                 strncpy(ip, ps, n);
 449                 ip += n;
 450                 *ip++ = '/';
 451                 *ip++ = '>';
 452         }
 453
 454         *ip = '\0';
 455         return info;
 456
 457 elen:
 458         free(info);
 459         errno = ENOMEM;
 460         return NULL;
 461 }
 462
 463 typedef struct {
 464         const char *name;
 465         const char *cap;
 466 } DEF_INFO;
 467
 468 static DEF_INFO def_infos[] = {
 469         { "bel",        "^G" },
 470         { "cr",         "^M" },
 471         { "cud1",       "^J" },
 472         { "ht",         "^I" },
 473         { "ind",        "^J" },
 474         { "kbs",        "^H" },
 475         { "kcub1",      "^H" },
 476         { "kcud1",      "^J" },
 477         { "nel",        "^M^J" }
 478 };
 479
 480 char *
 481 captoinfo(char *cap)
 482 {
 483         char *info, *ip, *token, *val, *p, tok[3];
 484         const char *name;
 485         size_t len, lp, nl, vl, rl;
 486         int defs[__arraycount(def_infos)], fv;
 487
 488         _DIAGASSERT(cap != NULL);
 489
 490         len = strlen(cap) * 2;
 491         len += __arraycount(def_infos) * (5 + 4 + 3); /* reserve for defs */
 492         info = ip = malloc(len);
 493         if (info == NULL)
 494                 return NULL;
 495
 496         memset(defs, 0, sizeof(defs));
 497         lp = 0;
 498         tok[2] = '\0';
 499         for (token = _ti_get_token(&cap, ':');
 500              token != NULL;
 501              token = _ti_get_token(&cap, ':'))
 502         {
 503                 if (token[0] == '\0')
 504                         continue;
 505                 name = token;
 506                 val = p = NULL;
 507                 fv = nl = 0;
 508                 if (token[1] != '\0') {
 509                         tok[0] = token[0];
 510                         tok[1] = token[1];
 511                         nl = 1;
 512                         if (token[2] == '\0') {
 513                                 name = flagname(tok);
 514                                 val = NULL;
 515                         } else if (token[2] == '#') {
 516                                 name = numname(tok);
 517                                 val = token + 2;
 518                         } else if (token[2] == '=') {
 519                                 name = strname(tok);
 520                                 val = strval(token + 2);
 521                                 fv = 1;
 522                         } else
 523                                 nl = 0;
 524                 }
 525                 /* If not matched we may need to convert padding still. */
 526                 if (nl == 0) {
 527                         p = strchr(name, '=');
 528                         if (p != NULL) {
 529                                 val = strval(p);
 530                                 *p = '\0';
 531                                 fv = 1;
 532                         }
 533                 }
 534
 535                 /* See if this sets a default. */
 536                 for (nl = 0; nl < __arraycount(def_infos); nl++) {
 537                         if (strcmp(name, def_infos[nl].name) == 0) {
 538                                 defs[nl] = 1;
 539                                 break;
 540                         }
 541                 }
 542
 543                 nl = strlen(name);
 544                 if (val == NULL)
 545                         vl = 0;
 546                 else
 547                         vl = strlen(val);
 548                 rl = nl + vl + 3; /* , \0 */
 549
 550                 if (lp + rl > len) {
 551                         if (rl < 256)
 552                                 len += 256;
 553                         else
 554                                 len += rl;
 555                         p = realloc(info, len);
 556                         if (p == NULL)
 557                                 return NULL;
 558                         info = p;
 559                 }
 560
 561                 if (ip != info) {
 562                         *ip++ = ',';
 563                         *ip++ = ' ';
 564                 }
 565
 566                 strcpy(ip, name);
 567                 ip += nl;
 568                 if (val != NULL) {
 569                         strcpy(ip, val);
 570                         ip += vl;
 571                         if (fv == 1)
 572                                 free(val);
 573                 }
 574         }
 575
 576         /* Add any defaults not set above. */
 577         for (nl = 0; nl < __arraycount(def_infos); nl++) {
 578                 if (defs[nl] == 0) {
 579                         *ip++ = ',';
 580                         *ip++ = ' ';
 581                         strcpy(ip, def_infos[nl].name);
 582                         ip += strlen(def_infos[nl].name);
 583                         *ip++ = '=';
 584                         strcpy(ip, def_infos[nl].cap);
 585                         ip += strlen(def_infos[nl].cap);
 586                 }
 587         }
 588
 589         *ip = '\0';
 590         return info;
 591 }
 592