1 /* vi:set ts=8 sts=4 sw=4: */ 2 /* 3 * The following software is (C) 1984 Peter da Silva, the Mad Australian, in 4 * the public domain. It may be re-distributed for any purpose with the 5 * inclusion of this notice. 6 */ 7 8 /* Modified by Bram Moolenaar for use with VIM - Vi Improved. */ 9 /* A few bugs removed by Olaf 'Rhialto' Seibert. */ 10 11 /* TERMLIB: Terminal independent database. */ 12 13 #include "vim.h" 14 #include "termlib.pro" 15 16 #if !defined(AMIGA) && !defined(VMS) && !defined(MACOS) 17 # include <sgtty.h> 18 #endif 19 20 static int getent __ARGS((char *, char *, FILE *, int)); 21 static int nextent __ARGS((char *, FILE *, int)); 22 static int _match __ARGS((char *, char *)); 23 static char *_addfmt __ARGS((char *, char *, int)); 24 static char *_find __ARGS((char *, char *)); 25 26 /* 27 * Global variables for termlib 28 */ 29 30 char *tent; /* Pointer to terminal entry, set by tgetent */ 31 char PC = 0; /* Pad character, default NULL */ 32 char *UP = 0, *BC = 0; /* Pointers to UP and BC strings from database */ 33 short ospeed; /* Baud rate (1-16, 1=300, 16=19200), as in stty */ 34 35 /* 36 * Module: tgetent 37 * 38 * Purpose: Get termcap entry for <term> into buffer at <tbuf>. 39 * 40 * Calling conventions: char tbuf[TBUFSZ+], term=canonical name for terminal. 41 * 42 * Returned values: 1 = success, -1 = can't open file, 43 * 0 = can't find terminal. 44 * 45 * Notes: 46 * - Should probably supply static buffer. 47 * - Uses environment variables "TERM" and "TERMCAP". If TERM = term (that is, 48 * if the argument matches the environment) then it looks at TERMCAP. 49 * - If TERMCAP begins with a slash, then it assumes this is the file to 50 * search rather than /etc/termcap. 51 * - If TERMCAP does not begin with a slash, and it matches TERM, then this is 52 * used as the entry. 53 * - This could be simplified considerably for non-UNIX systems. 54 */ 55 56 #ifndef TERMCAPFILE 57 # ifdef AMIGA 58 # define TERMCAPFILE "s:termcap" 59 # else 60 # ifdef VMS 61 # define TERMCAPFILE "VIMRUNTIME:termcap" 62 # else 63 # define TERMCAPFILE "/etc/termcap" 64 # endif 65 # endif 66 #endif 67 68 int 69 tgetent(tbuf, term) 70 char *tbuf; /* Buffer to hold termcap entry, TBUFSZ bytes max */ 71 char *term; /* Name of terminal */ 72 { 73 char tcbuf[32]; /* Temp buffer to handle */ 74 char *tcptr = tcbuf; /* extended entries */ 75 char *tcap = TERMCAPFILE; /* Default termcap file */ 76 char *tmp; 77 FILE *termcap; 78 int retval = 0; 79 int len; 80 81 if ((tmp = (char *)mch_getenv((char_u *)"TERMCAP")) != NULL) 82 { 83 if (*tmp == '/') /* TERMCAP = name of termcap file */ 84 { 85 tcap = tmp ; 86 #if defined(AMIGA) 87 /* Convert /usr/share/lib/termcap to usr:share/lib/termcap */ 88 tcap++; 89 tmp = strchr(tcap, '/'); 90 if (tmp) 91 *tmp = ':'; 92 #endif 93 } 94 else /* TERMCAP = termcap entry itself */ 95 { 96 int tlen = strlen(term); 97 98 while (*tmp && *tmp != ':') /* Check if TERM matches */ 99 { 100 char *nexttmp; 101 102 while (*tmp == '|') 103 tmp++; 104 nexttmp = _find(tmp, ":|"); /* Rhialto */ 105 if (tmp+tlen == nexttmp && _match(tmp, term) == tlen) 106 { 107 strcpy(tbuf, tmp); 108 tent = tbuf; 109 return 1; 110 } 111 else 112 tmp = nexttmp; 113 } 114 } 115 } 116 if (!(termcap = mch_fopen(tcap, "r"))) 117 { 118 strcpy(tbuf, tcap); 119 return -1; 120 } 121 122 len = 0; 123 while (getent(tbuf + len, term, termcap, TBUFSZ - len)) 124 { 125 tcptr = tcbuf; /* Rhialto */ 126 if ((term = tgetstr("tc", &tcptr))) /* extended entry */ 127 { 128 rewind(termcap); 129 len = strlen(tbuf); 130 } 131 else 132 { 133 retval = 1; 134 tent = tbuf; /* reset it back to the beginning */ 135 break; 136 } 137 } 138 fclose(termcap); 139 return retval; 140 } 141 142 static int 143 getent(tbuf, term, termcap, buflen) 144 char *tbuf, *term; 145 FILE *termcap; 146 int buflen; 147 { 148 char *tptr; 149 int tlen = strlen(term); 150 151 while (nextent(tbuf, termcap, buflen)) /* For each possible entry */ 152 { 153 tptr = tbuf; 154 while (*tptr && *tptr != ':') /* : terminates name field */ 155 { 156 char *nexttptr; 157 158 while (*tptr == '|') /* | separates names */ 159 tptr++; 160 nexttptr = _find(tptr, ":|"); /* Rhialto */ 161 if (tptr + tlen == nexttptr && 162 _match(tptr, term) == tlen) /* FOUND! */ 163 { 164 tent = tbuf; 165 return 1; 166 } 167 else /* Look for next name */ 168 tptr = nexttptr; 169 } 170 } 171 return 0; 172 } 173 174 static int 175 nextent(tbuf, termcap, buflen) /* Read 1 entry from TERMCAP file */ 176 char *tbuf; 177 FILE *termcap; 178 int buflen; 179 { 180 char *lbuf = tbuf; /* lbuf=line buffer */ 181 /* read lines straight into buffer */ 182 183 while (lbuf < tbuf+buflen && /* There's room and */ 184 fgets(lbuf, (int)(tbuf+buflen-lbuf), termcap)) /* another line */ 185 { 186 int llen = strlen(lbuf); 187 188 if (*lbuf == '#') /* eat comments */ 189 continue; 190 if (lbuf[-1] == ':' && /* and whitespace */ 191 lbuf[0] == '\t' && 192 lbuf[1] == ':') 193 { 194 STRMOVE(lbuf, lbuf + 2); 195 llen -= 2; 196 } 197 if (lbuf[llen-2] == '\\') /* and continuations */ 198 lbuf += llen-2; 199 else 200 { 201 lbuf[llen-1]=0; /* no continuation, return */ 202 return 1; 203 } 204 } 205 206 return 0; /* ran into end of file */ 207 } 208 209 /* 210 * Module: tgetflag 211 * 212 * Purpose: returns flag true or false as to the existence of a given entry. 213 * used with 'bs', 'am', etc... 214 * 215 * Calling conventions: id is the 2 character capability id. 216 * 217 * Returned values: 1 for success, 0 for failure. 218 */ 219 220 int 221 tgetflag(id) 222 char *id; 223 { 224 char buf[256], *ptr = buf; 225 226 return tgetstr(id, &ptr) ? 1 : 0; 227 } 228 229 /* 230 * Module: tgetnum 231 * 232 * Purpose: get numeric value such as 'li' or 'co' from termcap. 233 * 234 * Calling conventions: id = 2 character id. 235 * 236 * Returned values: -1 for failure, else numerical value. 237 */ 238 239 int 240 tgetnum(id) 241 char *id; 242 { 243 char *ptr, buf[256]; 244 ptr = buf; 245 246 if (tgetstr(id, &ptr)) 247 return atoi(buf); 248 else 249 return 0; 250 } 251 252 /* 253 * Module: tgetstr 254 * 255 * Purpose: get terminal capability string from database. 256 * 257 * Calling conventions: id is the two character capability id. 258 * (*buf) points into a hold buffer for the 259 * id. the capability is copied into the buffer 260 * and (*buf) is advanced to point to the next 261 * free byte in the buffer. 262 * 263 * Returned values: 0 = no such entry, otherwise returns original 264 * (*buf) (now a pointer to the string). 265 * 266 * Notes 267 * It also decodes certain escape sequences in the buffer. 268 * they should be obvious from the code: 269 * \E = escape. 270 * \n, \r, \t, \f, \b match the 'c' escapes. 271 * ^x matches control-x (^@...^_). 272 * \nnn matches nnn octal. 273 * \x, where x is anything else, matches x. I differ 274 * from the standard library here, in that I allow ^: to match 275 * :. 276 * 277 */ 278 279 char * 280 tgetstr(id, buf) 281 char *id, **buf; 282 { 283 int len = strlen(id); 284 char *tmp=tent; 285 char *hold; 286 int i; 287 288 do { 289 tmp = _find(tmp, ":"); /* For each field */ 290 while (*tmp == ':') /* skip empty fields */ 291 tmp++; 292 if (!*tmp) 293 break; 294 295 if (_match(id, tmp) == len) { 296 tmp += len; /* find '=' '@' or '#' */ 297 if (*tmp == '@') /* :xx@: entry for tc */ 298 return 0; /* deleted entry */ 299 hold= *buf; 300 while (*++tmp && *tmp != ':') { /* not at end of field */ 301 switch(*tmp) { 302 case '\\': /* Expand escapes here */ 303 switch(*++tmp) { 304 case 0: /* ignore backslashes */ 305 tmp--; /* at end of entry */ 306 break; /* shouldn't happen */ 307 case 'e': 308 case 'E': /* ESC */ 309 *(*buf)++ = ESC; 310 break; 311 case 'n': /* \n */ 312 *(*buf)++ = '\n'; 313 break; 314 case 'r': /* \r */ 315 *(*buf)++ = '\r'; 316 break; 317 case 't': /* \t */ 318 *(*buf)++ = '\t'; 319 break; 320 case 'b': /* \b */ 321 *(*buf)++ = '\b'; 322 break; 323 case 'f': /* \f */ 324 *(*buf)++ = '\f'; 325 break; 326 case '0': /* \nnn */ 327 case '1': 328 case '2': 329 case '3': 330 case '4': 331 case '5': 332 case '6': 333 case '7': 334 case '8': 335 case '9': 336 **buf = 0; 337 /* get up to three digits */ 338 for (i = 0; i < 3 && VIM_ISDIGIT(*tmp); ++i) 339 **buf = **buf * 8 + *tmp++ - '0'; 340 (*buf)++; 341 tmp--; 342 break; 343 default: /* \x, for all other x */ 344 *(*buf)++= *tmp; 345 } 346 break; 347 case '^': /* control characters */ 348 ++tmp; 349 *(*buf)++ = Ctrl_chr(*tmp); 350 break; 351 default: 352 *(*buf)++ = *tmp; 353 } 354 } 355 *(*buf)++ = 0; 356 return hold; 357 } 358 } while (*tmp); 359 360 return 0; 361 } 362 363 /* 364 * Module: tgoto 365 * 366 * Purpose: decode cm cursor motion string. 367 * 368 * Calling conventions: cm is cursor motion string. line, col, are the 369 * desired destination. 370 * 371 * Returned values: a string pointing to the decoded string, or "OOPS" if it 372 * cannot be decoded. 373 * 374 * Notes 375 * The accepted escapes are: 376 * %d as in printf, 0 origin. 377 * %2, %3 like %02d, %03d in printf. 378 * %. like %c 379 * %+x adds <x> to value, then %. 380 * %>xy if value>x, adds y. No output. 381 * %i increments line& col, no output. 382 * %r reverses order of line&col. No output. 383 * %% prints as a single %. 384 * %n exclusive or row & col with 0140. 385 * %B BCD, no output. 386 * %D reverse coding (x-2*(x%16)), no output. 387 */ 388 389 char * 390 tgoto(cm, col, line) 391 char *cm; /* cm string, from termcap */ 392 int col, /* column, x position */ 393 line; /* line, y position */ 394 { 395 char gx, gy, /* x, y */ 396 *ptr, /* pointer in 'cm' */ 397 reverse = 0, /* reverse flag */ 398 *bufp, /* pointer in returned string */ 399 addup = 0, /* add upline */ 400 addbak = 0, /* add backup */ 401 c; 402 static char buffer[32]; 403 404 if (!cm) 405 return "OOPS"; /* Kludge, but standard */ 406 407 bufp = buffer; 408 ptr = cm; 409 410 while (*ptr) { 411 if ((c = *ptr++) != '%') { /* normal char */ 412 *bufp++ = c; 413 } else { /* % escape */ 414 switch(c = *ptr++) { 415 case 'd': /* decimal */ 416 bufp = _addfmt(bufp, "%d", line); 417 line = col; 418 break; 419 case '2': /* 2 digit decimal */ 420 bufp = _addfmt(bufp, "%02d", line); 421 line = col; 422 break; 423 case '3': /* 3 digit decimal */ 424 bufp = _addfmt(bufp, "%03d", line); 425 line = col; 426 break; 427 case '>': /* %>xy: if >x, add y */ 428 gx = *ptr++; 429 gy = *ptr++; 430 if (col>gx) col += gy; 431 if (line>gx) line += gy; 432 break; 433 case '+': /* %+c: add c */ 434 line += *ptr++; 435 case '.': /* print x/y */ 436 if (line == '\t' || /* these are */ 437 line == '\n' || /* chars that */ 438 line == '\004' || /* UNIX hates */ 439 line == '\0') { 440 line++; /* so go to next pos */ 441 if (reverse == (line == col)) 442 addup=1; /* and mark UP */ 443 else 444 addbak=1; /* or BC */ 445 } 446 *bufp++=line; 447 line = col; 448 break; 449 case 'r': /* r: reverse */ 450 gx = line; 451 line = col; 452 col = gx; 453 reverse = 1; 454 break; 455 case 'i': /* increment (1-origin screen) */ 456 col++; 457 line++; 458 break; 459 case '%': /* %%=% literally */ 460 *bufp++='%'; 461 break; 462 case 'n': /* magic DM2500 code */ 463 line ^= 0140; 464 col ^= 0140; 465 break; 466 case 'B': /* bcd encoding */ 467 line = line/10<<4+line%10; 468 col = col/10<<4+col%10; 469 break; 470 case 'D': /* magic Delta Data code */ 471 line = line-2*(line&15); 472 col = col-2*(col&15); 473 break; 474 default: /* Unknown escape */ 475 return "OOPS"; 476 } 477 } 478 } 479 480 if (addup) /* add upline */ 481 if (UP) { 482 ptr=UP; 483 while (VIM_ISDIGIT(*ptr) || *ptr == '.') 484 ptr++; 485 if (*ptr == '*') 486 ptr++; 487 while (*ptr) 488 *bufp++ = *ptr++; 489 } 490 491 if (addbak) /* add backspace */ 492 if (BC) { 493 ptr=BC; 494 while (VIM_ISDIGIT(*ptr) || *ptr == '.') 495 ptr++; 496 if (*ptr == '*') 497 ptr++; 498 while (*ptr) 499 *bufp++ = *ptr++; 500 } 501 else 502 *bufp++='\b'; 503 504 *bufp = 0; 505 506 return(buffer); 507 } 508 509 /* 510 * Module: tputs 511 * 512 * Purpose: decode padding information 513 * 514 * Calling conventions: cp = string to be padded, affcnt = # of items affected 515 * (lines, characters, whatever), outc = routine to output 1 character. 516 * 517 * Returned values: none 518 * 519 * Notes 520 * cp has padding information ahead of it, in the form 521 * nnnTEXT or nnn*TEXT. nnn is the number of milliseconds to delay, 522 * and may be a decimal (nnn.mmm). If the asterisk is given, then 523 * the delay is multiplied by afcnt. The delay is produced by outputting 524 * a number of nulls (or other padding char) after printing the 525 * TEXT. 526 * 527 */ 528 529 long _bauds[16]={ 530 0, 50, 75, 110, 531 134, 150, 200, 300, 532 600, 1200, 1800, 2400, 533 4800, 9600, 19200, 19200 }; 534 535 int 536 tputs(cp, affcnt, outc) 537 char *cp; /* string to print */ 538 int affcnt; /* Number of lines affected */ 539 void (*outc) __ARGS((unsigned int));/* routine to output 1 character */ 540 { 541 long frac, /* 10^(#digits after decimal point) */ 542 counter, /* digits */ 543 atol __ARGS((const char *)); 544 545 if (VIM_ISDIGIT(*cp)) { 546 counter = 0; 547 frac = 1000; 548 while (VIM_ISDIGIT(*cp)) 549 counter = counter * 10L + (long)(*cp++ - '0'); 550 if (*cp == '.') 551 while (VIM_ISDIGIT(*++cp)) { 552 counter = counter * 10L + (long)(*cp++ - '0'); 553 frac = frac * 10; 554 } 555 if (*cp!='*') { /* multiply by affected lines */ 556 if (affcnt>1) affcnt = 1; 557 } 558 else 559 cp++; 560 561 /* Calculate number of characters for padding counter/frac ms delay */ 562 if (ospeed) 563 counter = (counter * _bauds[ospeed] * (long)affcnt) / frac; 564 565 while (*cp) /* output string */ 566 (*outc)(*cp++); 567 if (ospeed) 568 while (counter--) /* followed by pad characters */ 569 (*outc)(PC); 570 } 571 else 572 while (*cp) 573 (*outc)(*cp++); 574 return 0; 575 } 576 577 /* 578 * Module: tutil.c 579 * 580 * Purpose: Utility routines for TERMLIB functions. 581 * 582 */ 583 static int 584 _match(s1, s2) /* returns length of text common to s1 and s2 */ 585 char *s1, *s2; 586 { 587 int i = 0; 588 589 while (s1[i] && s1[i] == s2[i]) 590 i++; 591 592 return i; 593 } 594 595 /* 596 * finds next c in s that's a member of set, returns pointer 597 */ 598 static char * 599 _find(s, set) 600 char *s, *set; 601 { 602 for(; *s; s++) 603 { 604 char *ptr = set; 605 606 while (*ptr && *s != *ptr) 607 ptr++; 608 609 if (*ptr) 610 return s; 611 } 612 613 return s; 614 } 615 616 /* 617 * add val to buf according to format fmt 618 */ 619 static char * 620 _addfmt(buf, fmt, val) 621 char *buf, *fmt; 622 int val; 623 { 624 sprintf(buf, fmt, val); 625 while (*buf) 626 buf++; 627 return buf; 628 } 629