contrib/tcsh/ed.screen.c

   1 /* $Header: /src/pub/tcsh/ed.screen.c,v 3.63 2005/01/18 20:43:30 christos Exp $ */
   2 /*
   3  * ed.screen.c: Editor/termcap-curses interface
   4  */
   5 /*-
   6  * Copyright (c) 1980, 1991 The Regents of the University of California.
   7  * All rights reserved.
   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  * 3. Neither the name of the University nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  */
  33 #include "sh.h"
  34
  35 RCSID("$Id: ed.screen.c,v 3.63 2005/01/18 20:43:30 christos Exp $")
  36
  37 #include "ed.h"
  38 #include "tc.h"
  39 #include "ed.defns.h"
  40
  41 /* #define DEBUG_LITERAL */
  42
  43 /*
  44  * IMPORTANT NOTE: these routines are allowed to look at the current screen
  45  * and the current possition assuming that it is correct.  If this is not
  46  * true, then the update will be WRONG!  This is (should be) a valid
  47  * assumption...
  48  */
  49
  50 #define TC_BUFSIZE 2048
  51
  52 #define GoodStr(a) (tstr[a].str != NULL && tstr[a].str[0] != '\0')
  53 #define Str(a) tstr[a].str
  54 #define Val(a) tval[a].val
  55
  56 static struct {
  57     const char   *b_name;
  58     speed_t b_rate;
  59 }       baud_rate[] = {
  60
  61 #ifdef B0
  62     { "0", B0 },
  63 #endif
  64 #ifdef B50
  65     { "50", B50 },
  66 #endif
  67 #ifdef B75
  68     { "75", B75 },
  69 #endif
  70 #ifdef B110
  71     { "110", B110 },
  72 #endif
  73 #ifdef B134
  74     { "134", B134 },
  75 #endif
  76 #ifdef B150
  77     { "150", B150 },
  78 #endif
  79 #ifdef B200
  80     { "200", B200 },
  81 #endif
  82 #ifdef B300
  83     { "300", B300 },
  84 #endif
  85 #ifdef B600
  86     { "600", B600 },
  87 #endif
  88 #ifdef B900
  89     { "900", B900 },
  90 #endif
  91 #ifdef B1200
  92     { "1200", B1200 },
  93 #endif
  94 #ifdef B1800
  95     { "1800", B1800 },
  96 #endif
  97 #ifdef B2400
  98     { "2400", B2400 },
  99 #endif
 100 #ifdef B3600
 101     { "3600", B3600 },
 102 #endif
 103 #ifdef B4800
 104     { "4800", B4800 },
 105 #endif
 106 #ifdef B7200
 107     { "7200", B7200 },
 108 #endif
 109 #ifdef B9600
 110     { "9600", B9600 },
 111 #endif
 112 #ifdef EXTA
 113     { "19200", EXTA },
 114 #endif
 115 #ifdef B19200
 116     { "19200", B19200 },
 117 #endif
 118 #ifdef EXTB
 119     { "38400", EXTB },
 120 #endif
 121 #ifdef B38400
 122     { "38400", B38400 },
 123 #endif
 124     { NULL, 0 }
 125 };
 126
 127 #define T_al    0
 128 #define T_bl    1
 129 #define T_cd    2
 130 #define T_ce    3
 131 #define T_ch    4
 132 #define T_cl    5
 133 #define T_dc    6
 134 #define T_dl    7
 135 #define T_dm    8
 136 #define T_ed    9
 137 #define T_ei    10
 138 #define T_fs    11
 139 #define T_ho    12
 140 #define T_ic    13
 141 #define T_im    14
 142 #define T_ip    15
 143 #define T_kd    16
 144 #define T_kl    17
 145 #define T_kr    18
 146 #define T_ku    19
 147 #define T_md    20
 148 #define T_me    21
 149 #define T_nd    22
 150 #define T_se    23
 151 #define T_so    24
 152 #define T_ts    25
 153 #define T_up    26
 154 #define T_us    27
 155 #define T_ue    28
 156 #define T_vb    29
 157 #define T_DC    30
 158 #define T_DO    31
 159 #define T_IC    32
 160 #define T_LE    33
 161 #define T_RI    34
 162 #define T_UP    35
 163 #define T_kh    36
 164 #define T_at7   37
 165 #define T_str   38
 166 static struct termcapstr {
 167     const char   *name;
 168     const char   *long_name;
 169     char   *str;
 170 } tstr[T_str + 1];
 171
 172
 173 #define T_am    0
 174 #define T_pt    1
 175 #define T_li    2
 176 #define T_co    3
 177 #define T_km    4
 178 #define T_xn    5
 179 #define T_val   6
 180 static struct termcapval {
 181     const char   *name;
 182     const char   *long_name;
 183     int     val;
 184 } tval[T_val + 1];
 185
 186 void
 187 terminit()
 188 {
 189 #ifdef NLS_CATALOGS
 190     int i;
 191
 192     for (i = 0; i < T_str + 1; i++)
 193         xfree((ptr_t) tstr[i].long_name);
 194
 195     for (i = 0; i < T_val + 1; i++)
 196         xfree((ptr_t) tval[i].long_name);
 197 #endif
 198
 199     tstr[T_al].name = "al";
 200     tstr[T_al].long_name = CSAVS(4, 1, "add new blank line");
 201
 202     tstr[T_bl].name = "bl";
 203     tstr[T_bl].long_name = CSAVS(4, 2, "audible bell");
 204
 205     tstr[T_cd].name = "cd";
 206     tstr[T_cd].long_name = CSAVS(4, 3, "clear to bottom");
 207
 208     tstr[T_ce].name = "ce";
 209     tstr[T_ce].long_name = CSAVS(4, 4, "clear to end of line");
 210
 211     tstr[T_ch].name = "ch";
 212     tstr[T_ch].long_name = CSAVS(4, 5, "cursor to horiz pos");
 213
 214     tstr[T_cl].name = "cl";
 215     tstr[T_cl].long_name = CSAVS(4, 6, "clear screen");
 216
 217     tstr[T_dc].name = "dc";
 218     tstr[T_dc].long_name = CSAVS(4, 7, "delete a character");
 219
 220     tstr[T_dl].name = "dl";
 221     tstr[T_dl].long_name = CSAVS(4, 8, "delete a line");
 222
 223     tstr[T_dm].name = "dm";
 224     tstr[T_dm].long_name = CSAVS(4, 9, "start delete mode");
 225
 226     tstr[T_ed].name = "ed";
 227     tstr[T_ed].long_name = CSAVS(4, 10, "end delete mode");
 228
 229     tstr[T_ei].name = "ei";
 230     tstr[T_ei].long_name = CSAVS(4, 11, "end insert mode");
 231
 232     tstr[T_fs].name = "fs";
 233     tstr[T_fs].long_name = CSAVS(4, 12, "cursor from status line");
 234
 235     tstr[T_ho].name = "ho";
 236     tstr[T_ho].long_name = CSAVS(4, 13, "home cursor");
 237
 238     tstr[T_ic].name = "ic";
 239     tstr[T_ic].long_name = CSAVS(4, 14, "insert character");
 240
 241     tstr[T_im].name = "im";
 242     tstr[T_im].long_name = CSAVS(4, 15, "start insert mode");
 243
 244     tstr[T_ip].name = "ip";
 245     tstr[T_ip].long_name = CSAVS(4, 16, "insert padding");
 246
 247     tstr[T_kd].name = "kd";
 248     tstr[T_kd].long_name = CSAVS(4, 17, "sends cursor down");
 249
 250     tstr[T_kl].name = "kl";
 251     tstr[T_kl].long_name = CSAVS(4, 18, "sends cursor left");
 252
 253     tstr[T_kr].name = "kr";
 254     tstr[T_kr].long_name = CSAVS(4, 19, "sends cursor right");
 255
 256     tstr[T_ku].name = "ku";
 257     tstr[T_ku].long_name = CSAVS(4, 20, "sends cursor up");
 258
 259     tstr[T_md].name = "md";
 260     tstr[T_md].long_name = CSAVS(4, 21, "begin bold");
 261
 262     tstr[T_me].name = "me";
 263     tstr[T_me].long_name = CSAVS(4, 22, "end attributes");
 264
 265     tstr[T_nd].name = "nd";
 266     tstr[T_nd].long_name = CSAVS(4, 23, "non destructive space");
 267
 268     tstr[T_se].name = "se";
 269     tstr[T_se].long_name = CSAVS(4, 24, "end standout");
 270
 271     tstr[T_so].name = "so";
 272     tstr[T_so].long_name = CSAVS(4, 25, "begin standout");
 273
 274     tstr[T_ts].name = "ts";
 275     tstr[T_ts].long_name = CSAVS(4, 26, "cursor to status line");
 276
 277     tstr[T_up].name = "up";
 278     tstr[T_up].long_name = CSAVS(4, 27, "cursor up one");
 279
 280     tstr[T_us].name = "us";
 281     tstr[T_us].long_name = CSAVS(4, 28, "begin underline");
 282
 283     tstr[T_ue].name = "ue";
 284     tstr[T_ue].long_name = CSAVS(4, 29, "end underline");
 285
 286     tstr[T_vb].name = "vb";
 287     tstr[T_vb].long_name = CSAVS(4, 30, "visible bell");
 288
 289     tstr[T_DC].name = "DC";
 290     tstr[T_DC].long_name = CSAVS(4, 31, "delete multiple chars");
 291
 292     tstr[T_DO].name = "DO";
 293     tstr[T_DO].long_name = CSAVS(4, 32, "cursor down multiple");
 294
 295     tstr[T_IC].name = "IC";
 296     tstr[T_IC].long_name = CSAVS(4, 33, "insert multiple chars");
 297
 298     tstr[T_LE].name = "LE";
 299     tstr[T_LE].long_name = CSAVS(4, 34, "cursor left multiple");
 300
 301     tstr[T_RI].name = "RI";
 302     tstr[T_RI].long_name = CSAVS(4, 35, "cursor right multiple");
 303
 304     tstr[T_UP].name = "UP";
 305     tstr[T_UP].long_name = CSAVS(4, 36, "cursor up multiple");
 306
 307     tstr[T_kh].name = "kh";
 308     tstr[T_kh].long_name = CSAVS(4, 37, "send cursor home");
 309
 310     tstr[T_at7].name = "@7";
 311     tstr[T_at7].long_name = CSAVS(4, 38, "send cursor end");
 312
 313     tstr[T_str].name = NULL;
 314     tstr[T_str].long_name = NULL;
 315
 316
 317     tval[T_am].name = "am";
 318     tval[T_am].long_name = CSAVS(4, 37, "Has automatic margins");
 319
 320     tval[T_pt].name = "pt";
 321     tval[T_pt].long_name = CSAVS(4, 38, "Can use physical tabs");
 322
 323     tval[T_li].name = "li";
 324     tval[T_li].long_name = CSAVS(4, 39, "Number of lines");
 325
 326     tval[T_co].name = "co";
 327     tval[T_co].long_name = CSAVS(4, 40, "Number of columns");
 328
 329     tval[T_km].name = "km";
 330     tval[T_km].long_name = CSAVS(4, 41, "Has meta key");
 331
 332     tval[T_xn].name = "xn";
 333     tval[T_xn].long_name = CSAVS(4, 42, "Newline ignored at right margin");
 334
 335     tval[T_val].name = NULL;
 336     tval[T_val].long_name = NULL;
 337 }
 338
 339 /*
 340  * A very useful table from justin@crim.ca (Justin Bur) :-)
 341  * (Modified by per@erix.ericsson.se (Per Hedeland)
 342  *  - first (and second:-) case fixed)
 343  *
 344  * Description     Termcap variables       tcsh behavior
 345  *                 am      xn              UseRightmost    SendCRLF
 346  * --------------  ------- -------         ------------    ------------
 347  * Automargins     yes     no              yes             no
 348  * Magic Margins   yes     yes             yes             no
 349  * No Wrap         no      --              yes             yes
 350  */
 351
 352 static int me_all = 0;          /* does two or more of the attributes use me */
 353
 354 static  void    ReBufferDisplay __P((void));
 355 static  void    TCalloc         __P((struct termcapstr *, char *));
 356
 357
 358 static void
 359 TCalloc(t, cap)
 360     struct termcapstr *t;
 361     char   *cap;
 362 {
 363     static char termcap_alloc[TC_BUFSIZE];
 364     char    termbuf[TC_BUFSIZE];
 365     struct termcapstr *ts;
 366     static int tloc = 0;
 367     int     tlen, clen;
 368
 369     if (cap == NULL || *cap == '\0') {
 370         t->str = NULL;
 371         return;
 372     }
 373     else
 374         clen = strlen(cap);
 375
 376     if (t->str == NULL)
 377         tlen = 0;
 378     else
 379         tlen = strlen(t->str);
 380
 381     /*
 382      * New string is shorter; no need to allocate space
 383      */
 384     if (clen <= tlen) {
 385         (void) strcpy(t->str, cap);
 386         return;
 387     }
 388
 389     /*
 390      * New string is longer; see if we have enough space to append
 391      */
 392     if (tloc + 3 < TC_BUFSIZE) {
 393         (void) strcpy(t->str = &termcap_alloc[tloc], cap);
 394         tloc += clen + 1;       /* one for \0 */
 395         return;
 396     }
 397
 398     /*
 399      * Compact our buffer; no need to check compaction, cause we know it
 400      * fits...
 401      */
 402     tlen = 0;
 403     for (ts = tstr; ts->name != NULL; ts++)
 404         if (t != ts && ts->str != NULL && ts->str[0] != '\0') {
 405             char   *ptr;
 406
 407             for (ptr = ts->str; *ptr != '\0'; termbuf[tlen++] = *ptr++)
 408                 continue;
 409             termbuf[tlen++] = '\0';
 410         }
 411     (void) memmove((ptr_t) termcap_alloc, (ptr_t) termbuf, (size_t) TC_BUFSIZE);
 412     tloc = tlen;
 413     if (tloc + 3 >= TC_BUFSIZE) {
 414         stderror(ERR_NAME | ERR_TCNOSTR);
 415         return;
 416     }
 417     (void) strcpy(t->str = &termcap_alloc[tloc], cap);
 418     tloc += clen + 1;           /* one for \0 */
 419     return;
 420 }
 421
 422
 423 /*ARGSUSED*/
 424 void
 425 TellTC()
 426 {
 427     struct termcapstr *t;
 428     char *s;
 429
 430     xprintf(CGETS(7, 1, "\n\tTcsh thinks your terminal has the\n"));
 431     xprintf(CGETS(7, 2, "\tfollowing characteristics:\n\n"));
 432     xprintf(CGETS(7, 3, "\tIt has %d columns and %d lines\n"),
 433             Val(T_co), Val(T_li));
 434     s = strsave(T_HasMeta ? CGETS(7, 5, "a") : CGETS(7, 6, "no"));
 435     xprintf(CGETS(7, 4, "\tIt has %s meta key\n"), s);
 436     xfree(s);
 437     s = strsave(T_Tabs ? "" : CGETS(7, 8, " not"));
 438     xprintf(CGETS(7, 7, "\tIt can%s use tabs\n"), s);
 439     xfree(s);
 440     s = strsave((T_Margin&MARGIN_AUTO) ?
 441                 CGETS(7, 10, "has") : CGETS(7, 11, "does not have"));
 442     xprintf(CGETS(7, 9, "\tIt %s automatic margins\n"), s);
 443     xfree(s);
 444     if (T_Margin & MARGIN_AUTO) {
 445         s = strsave((T_Margin & MARGIN_MAGIC) ?
 446                         CGETS(7, 10, "has") : CGETS(7, 11, "does not have"));
 447         xprintf(CGETS(7, 12, "\tIt %s magic margins\n"), s);
 448         xfree(s);
 449     }
 450     for (t = tstr; t->name != NULL; t++) {
 451         s = strsave(t->str && *t->str ? t->str : CGETS(7, 13, "(empty)"));
 452         xprintf("\t%36s (%s) == %s\n", t->long_name, t->name, s);
 453         xfree(s);
 454     }
 455     xputchar('\n');
 456 }
 457
 458
 459 static void
 460 ReBufferDisplay()
 461 {
 462     int i;
 463     Char **b;
 464     Char **bufp;
 465
 466     b = Display;
 467     Display = NULL;
 468     if (b != NULL) {
 469         for (bufp = b; *bufp != NULL; bufp++)
 470             xfree((ptr_t) * bufp);
 471         xfree((ptr_t) b);
 472     }
 473     b = Vdisplay;
 474     Vdisplay = NULL;
 475     if (b != NULL) {
 476         for (bufp = b; *bufp != NULL; bufp++)
 477             xfree((ptr_t) * bufp);
 478         xfree((ptr_t) b);
 479     }
 480     TermH = Val(T_co);
 481     TermV = (INBUFSIZE * 4) / TermH + 1;
 482     b = (Char **) xmalloc((size_t) (sizeof(*b) * (TermV + 1)));
 483     for (i = 0; i < TermV; i++)
 484         b[i] = (Char *) xmalloc((size_t) (sizeof(*b[i]) * (TermH + 1)));
 485     b[TermV] = NULL;
 486     Display = b;
 487     b = (Char **) xmalloc((size_t) (sizeof(*b) * (TermV + 1)));
 488     for (i = 0; i < TermV; i++)
 489         b[i] = (Char *) xmalloc((size_t) (sizeof(*b[i]) * (TermH + 1)));
 490     b[TermV] = NULL;
 491     Vdisplay = b;
 492 }
 493
 494 void
 495 SetTC(what, how)
 496     char   *what, *how;
 497 {
 498     struct termcapstr *ts;
 499     struct termcapval *tv;
 500
 501     /*
 502      * Do the strings first
 503      */
 504     setname("settc");
 505     for (ts = tstr; ts->name != NULL; ts++)
 506         if (strcmp(ts->name, what) == 0)
 507             break;
 508     if (ts->name != NULL) {
 509         TCalloc(ts, how);
 510         /*
 511          * Reset variables
 512          */
 513         if (GoodStr(T_me) && GoodStr(T_ue))
 514             me_all = (strcmp(Str(T_me), Str(T_ue)) == 0);
 515         else
 516             me_all = 0;
 517         if (GoodStr(T_me) && GoodStr(T_se))
 518             me_all |= (strcmp(Str(T_me), Str(T_se)) == 0);
 519
 520         T_CanCEOL = GoodStr(T_ce);
 521         T_CanDel = GoodStr(T_dc) || GoodStr(T_DC);
 522         T_CanIns = GoodStr(T_im) || GoodStr(T_ic) || GoodStr(T_IC);
 523         T_CanUP = GoodStr(T_up) || GoodStr(T_UP);
 524         return;
 525     }
 526
 527     /*
 528      * Do the numeric ones second
 529      */
 530     for (tv = tval; tv->name != NULL; tv++)
 531         if (strcmp(tv->name, what) == 0)
 532             break;
 533
 534     if (tv->name != NULL) {
 535         if (tv == &tval[T_pt] || tv == &tval[T_km] ||
 536             tv == &tval[T_am] || tv == &tval[T_xn]) {
 537             if (strcmp(how, "yes") == 0)
 538                 tv->val = 1;
 539             else if (strcmp(how, "no") == 0)
 540                 tv->val = 0;
 541             else {
 542                 stderror(ERR_SETTCUS, tv->name);
 543                 return;
 544             }
 545             T_Tabs = (Char) Val(T_pt);
 546             T_HasMeta = (Char) Val(T_km);
 547             T_Margin = (Char) Val(T_am) ? MARGIN_AUTO : 0;
 548             T_Margin |= (Char) Val(T_xn) ? MARGIN_MAGIC : 0;
 549             if (tv == &tval[T_am] || tv == &tval[T_xn])
 550                 ChangeSize(Val(T_li), Val(T_co));
 551             return;
 552         }
 553         else {
 554             tv->val = atoi(how);
 555             T_Cols = (Char) Val(T_co);
 556             T_Lines = (Char) Val(T_li);
 557             if (tv == &tval[T_co] || tv == &tval[T_li])
 558                 ChangeSize(Val(T_li), Val(T_co));
 559             return;
 560         }
 561     }
 562     stderror(ERR_NAME | ERR_TCCAP, what);
 563     return;
 564 }
 565
 566
 567 /*
 568  * Print the termcap string out with variable substitution
 569  */
 570 void
 571 EchoTC(v)
 572     Char  **v;
 573 {
 574     char   *cap, *scap, cv[BUFSIZE];
 575     int     arg_need, arg_cols, arg_rows;
 576     int     verbose = 0, silent = 0;
 577     char   *area;
 578     static const char *fmts = "%s\n", *fmtd = "%d\n";
 579     struct termcapstr *t;
 580     char    buf[TC_BUFSIZE];
 581
 582     area = buf;
 583
 584     setname("echotc");
 585
 586     tglob(v);
 587     if (gflag) {
 588         v = globall(v);
 589         if (v == 0)
 590             stderror(ERR_NAME | ERR_NOMATCH);
 591     }
 592     else
 593         v = gargv = saveblk(v);
 594     trim(v);
 595
 596     if (!*v || *v[0] == '\0')
 597         return;
 598     if (v[0][0] == '-') {
 599         switch (v[0][1]) {
 600         case 'v':
 601             verbose = 1;
 602             break;
 603         case 's':
 604             silent = 1;
 605             break;
 606         default:
 607             stderror(ERR_NAME | ERR_TCUSAGE);
 608             break;
 609         }
 610         v++;
 611     }
 612     if (!*v || *v[0] == '\0')
 613         return;
 614     (void) strcpy(cv, short2str(*v));
 615     if (strcmp(cv, "tabs") == 0) {
 616         xprintf(fmts, T_Tabs ? CGETS(7, 14, "yes") :
 617                 CGETS(7, 15, "no"));
 618         flush();
 619         return;
 620     }
 621     else if (strcmp(cv, "meta") == 0) {
 622         xprintf(fmts, Val(T_km) ? CGETS(7, 14, "yes") :
 623                 CGETS(7, 15, "no"));
 624         flush();
 625         return;
 626     }
 627     else if (strcmp(cv, "xn") == 0) {
 628         xprintf(fmts, T_Margin & MARGIN_MAGIC ? CGETS(7, 14, "yes") :
 629                 CGETS(7, 15,  "no"));
 630         flush();
 631         return;
 632     }
 633     else if (strcmp(cv, "am") == 0) {
 634         xprintf(fmts, T_Margin & MARGIN_AUTO ? CGETS(7, 14, "yes") :
 635                 CGETS(7, 15, "no"));
 636         flush();
 637         return;
 638     }
 639     else if (strcmp(cv, "baud") == 0) {
 640         int     i;
 641
 642         for (i = 0; baud_rate[i].b_name != NULL; i++)
 643             if (T_Speed == baud_rate[i].b_rate) {
 644                 xprintf(fmts, baud_rate[i].b_name);
 645                 flush();
 646                 return;
 647             }
 648         xprintf(fmtd, 0);
 649         flush();
 650         return;
 651     }
 652     else if (strcmp(cv, "rows") == 0 || strcmp(cv, "lines") == 0) {
 653         xprintf(fmtd, Val(T_li));
 654         flush();
 655         return;
 656     }
 657     else if (strcmp(cv, "cols") == 0) {
 658         xprintf(fmtd, Val(T_co));
 659         flush();
 660         return;
 661     }
 662
 663     /*
 664      * Try to use our local definition first
 665      */
 666     scap = NULL;
 667     for (t = tstr; t->name != NULL; t++)
 668         if (strcmp(t->name, cv) == 0) {
 669             scap = t->str;
 670             break;
 671         }
 672     if (t->name == NULL)
 673         scap = tgetstr(cv, &area);
 674     if (!scap || scap[0] == '\0') {
 675         if (tgetflag(cv)) {
 676             xprintf(CGETS(7, 14, "yes\n"));
 677             return;
 678         }
 679         if (silent)
 680             return;
 681         else
 682             stderror(ERR_NAME | ERR_TCCAP, cv);
 683     }
 684
 685     /*
 686      * Count home many values we need for this capability.
 687      */
 688     for (cap = scap, arg_need = 0; *cap; cap++)
 689         if (*cap == '%')
 690             switch (*++cap) {
 691             case 'd':
 692             case '2':
 693             case '3':
 694             case '.':
 695             case '+':
 696                 arg_need++;
 697                 break;
 698             case '%':
 699             case '>':
 700             case 'i':
 701             case 'r':
 702             case 'n':
 703             case 'B':
 704             case 'D':
 705                 break;
 706             default:
 707                 /*
 708                  * hpux has lot's of them...
 709                  */
 710                 if (verbose)
 711                     stderror(ERR_NAME | ERR_TCPARM, *cap);
 712                 /* This is bad, but I won't complain */
 713                 break;
 714             }
 715
 716     switch (arg_need) {
 717     case 0:
 718         v++;
 719         if (*v && *v[0]) {
 720             if (silent)
 721                 return;
 722             else
 723                 stderror(ERR_NAME | ERR_TCARGS, cv, arg_need);
 724         }
 725         (void) tputs(scap, 1, PUTRAW);
 726         break;
 727     case 1:
 728         v++;
 729         if (!*v || *v[0] == '\0')
 730             stderror(ERR_NAME | ERR_TCNARGS, cv, 1);
 731         arg_cols = 0;
 732         arg_rows = atoi(short2str(*v));
 733         v++;
 734         if (*v && *v[0]) {
 735             if (silent)
 736                 return;
 737             else
 738                 stderror(ERR_NAME | ERR_TCARGS, cv, arg_need);
 739         }
 740         (void) tputs(tgoto(scap, arg_cols, arg_rows), 1, PUTRAW);
 741         break;
 742     default:
 743         /* This is wrong, but I will ignore it... */
 744         if (verbose)
 745             stderror(ERR_NAME | ERR_TCARGS, cv, arg_need);
 746         /*FALLTHROUGH*/
 747     case 2:
 748         v++;
 749         if (!*v || *v[0] == '\0') {
 750             if (silent)
 751                 return;
 752             else
 753                 stderror(ERR_NAME | ERR_TCNARGS, cv, 2);
 754         }
 755         arg_cols = atoi(short2str(*v));
 756         v++;
 757         if (!*v || *v[0] == '\0') {
 758             if (silent)
 759                 return;
 760             else
 761                 stderror(ERR_NAME | ERR_TCNARGS, cv, 2);
 762         }
 763         arg_rows = atoi(short2str(*v));
 764         v++;
 765         if (*v && *v[0]) {
 766             if (silent)
 767                 return;
 768             else
 769                 stderror(ERR_NAME | ERR_TCARGS, cv, arg_need);
 770         }
 771         (void) tputs(tgoto(scap, arg_cols, arg_rows), arg_rows, PUTRAW);
 772         break;
 773     }
 774     flush();
 775     if (gargv) {
 776         blkfree(gargv);
 777         gargv = 0;
 778     }
 779 }
 780
 781 int    GotTermCaps = 0;
 782
 783 static struct {
 784     Char   *name;
 785     int     key;
 786     XmapVal fun;
 787     int     type;
 788 } arrow[] = {
 789 #define A_K_DN  0
 790     { STRdown,  T_kd, { 0 }, 0 },
 791 #define A_K_UP  1
 792     { STRup,    T_ku, { 0 }, 0 },
 793 #define A_K_LT  2
 794     { STRleft,  T_kl, { 0 }, 0 },
 795 #define A_K_RT  3
 796     { STRright, T_kr, { 0 }, 0 },
 797 #define A_K_HO  4
 798     { STRhome,  T_kh, { 0 }, 0 },
 799 #define A_K_EN  5
 800     { STRend,   T_at7, { 0 }, 0}
 801 };
 802 #define A_K_NKEYS 6
 803
 804 void
 805 ResetArrowKeys()
 806 {
 807     arrow[A_K_DN].fun.cmd = F_DOWN_HIST;
 808     arrow[A_K_DN].type    = XK_CMD;
 809
 810     arrow[A_K_UP].fun.cmd = F_UP_HIST;
 811     arrow[A_K_UP].type    = XK_CMD;
 812
 813     arrow[A_K_LT].fun.cmd = F_CHARBACK;
 814     arrow[A_K_LT].type    = XK_CMD;
 815
 816     arrow[A_K_RT].fun.cmd = F_CHARFWD;
 817     arrow[A_K_RT].type    = XK_CMD;
 818
 819     arrow[A_K_HO].fun.cmd = F_TOBEG;
 820     arrow[A_K_HO].type    = XK_CMD;
 821
 822     arrow[A_K_EN].fun.cmd = F_TOEND;
 823     arrow[A_K_EN].type    = XK_CMD;
 824 }
 825
 826 void
 827 DefaultArrowKeys()
 828 {
 829     static Char strA[] = {033, '[', 'A', '\0'};
 830     static Char strB[] = {033, '[', 'B', '\0'};
 831     static Char strC[] = {033, '[', 'C', '\0'};
 832     static Char strD[] = {033, '[', 'D', '\0'};
 833     static Char strH[] = {033, '[', 'H', '\0'};
 834     static Char strF[] = {033, '[', 'F', '\0'};
 835     static Char stOA[] = {033, 'O', 'A', '\0'};
 836     static Char stOB[] = {033, 'O', 'B', '\0'};
 837     static Char stOC[] = {033, 'O', 'C', '\0'};
 838     static Char stOD[] = {033, 'O', 'D', '\0'};
 839     static Char stOH[] = {033, 'O', 'H', '\0'};
 840     static Char stOF[] = {033, 'O', 'F', '\0'};
 841
 842     CStr cs;
 843 #ifndef IS_ASCII
 844     if (strA[0] == 033)
 845     {
 846         strA[0] = CTL_ESC('\033');
 847         strB[0] = CTL_ESC('\033');
 848         strC[0] = CTL_ESC('\033');
 849         strD[0] = CTL_ESC('\033');
 850         strH[0] = CTL_ESC('\033');
 851         strF[0] = CTL_ESC('\033');
 852         stOA[0] = CTL_ESC('\033');
 853         stOB[0] = CTL_ESC('\033');
 854         stOC[0] = CTL_ESC('\033');
 855         stOD[0] = CTL_ESC('\033');
 856         stOH[0] = CTL_ESC('\033');
 857         stOF[0] = CTL_ESC('\033');
 858     }
 859 #endif
 860
 861     cs.len = 3;
 862
 863     cs.buf = strA; AddXkey(&cs, &arrow[A_K_UP].fun, arrow[A_K_UP].type);
 864     cs.buf = strB; AddXkey(&cs, &arrow[A_K_DN].fun, arrow[A_K_DN].type);
 865     cs.buf = strC; AddXkey(&cs, &arrow[A_K_RT].fun, arrow[A_K_RT].type);
 866     cs.buf = strD; AddXkey(&cs, &arrow[A_K_LT].fun, arrow[A_K_LT].type);
 867     cs.buf = strH; AddXkey(&cs, &arrow[A_K_HO].fun, arrow[A_K_HO].type);
 868     cs.buf = strF; AddXkey(&cs, &arrow[A_K_EN].fun, arrow[A_K_EN].type);
 869     cs.buf = stOA; AddXkey(&cs, &arrow[A_K_UP].fun, arrow[A_K_UP].type);
 870     cs.buf = stOB; AddXkey(&cs, &arrow[A_K_DN].fun, arrow[A_K_DN].type);
 871     cs.buf = stOC; AddXkey(&cs, &arrow[A_K_RT].fun, arrow[A_K_RT].type);
 872     cs.buf = stOD; AddXkey(&cs, &arrow[A_K_LT].fun, arrow[A_K_LT].type);
 873     cs.buf = stOH; AddXkey(&cs, &arrow[A_K_HO].fun, arrow[A_K_HO].type);
 874     cs.buf = stOF; AddXkey(&cs, &arrow[A_K_EN].fun, arrow[A_K_EN].type);
 875
 876     if (VImode) {
 877         cs.len = 2;
 878         cs.buf = &strA[1]; AddXkey(&cs, &arrow[A_K_UP].fun, arrow[A_K_UP].type);
 879         cs.buf = &strB[1]; AddXkey(&cs, &arrow[A_K_DN].fun, arrow[A_K_DN].type);
 880         cs.buf = &strC[1]; AddXkey(&cs, &arrow[A_K_RT].fun, arrow[A_K_RT].type);
 881         cs.buf = &strD[1]; AddXkey(&cs, &arrow[A_K_LT].fun, arrow[A_K_LT].type);
 882         cs.buf = &strH[1]; AddXkey(&cs, &arrow[A_K_HO].fun, arrow[A_K_HO].type);
 883         cs.buf = &strF[1]; AddXkey(&cs, &arrow[A_K_EN].fun, arrow[A_K_EN].type);
 884         cs.buf = &stOA[1]; AddXkey(&cs, &arrow[A_K_UP].fun, arrow[A_K_UP].type);
 885         cs.buf = &stOB[1]; AddXkey(&cs, &arrow[A_K_DN].fun, arrow[A_K_DN].type);
 886         cs.buf = &stOC[1]; AddXkey(&cs, &arrow[A_K_RT].fun, arrow[A_K_RT].type);
 887         cs.buf = &stOD[1]; AddXkey(&cs, &arrow[A_K_LT].fun, arrow[A_K_LT].type);
 888         cs.buf = &stOH[1]; AddXkey(&cs, &arrow[A_K_HO].fun, arrow[A_K_HO].type);
 889         cs.buf = &stOF[1]; AddXkey(&cs, &arrow[A_K_EN].fun, arrow[A_K_EN].type);
 890     }
 891 }
 892
 893
 894 int
 895 SetArrowKeys(name, fun, type)
 896     CStr *name;
 897     XmapVal *fun;
 898     int type;
 899 {
 900     int i;
 901     for (i = 0; i < A_K_NKEYS; i++)
 902         if (Strcmp(name->buf, arrow[i].name) == 0) {
 903             arrow[i].fun  = *fun;
 904             arrow[i].type = type;
 905             return 0;
 906         }
 907     return -1;
 908 }
 909
 910 int
 911 IsArrowKey(name)
 912     Char *name;
 913 {
 914     int i;
 915     for (i = 0; i < A_K_NKEYS; i++)
 916         if (Strcmp(name, arrow[i].name) == 0)
 917             return 1;
 918     return 0;
 919 }
 920
 921 int
 922 ClearArrowKeys(name)
 923     CStr *name;
 924 {
 925     int i;
 926     for (i = 0; i < A_K_NKEYS; i++)
 927         if (Strcmp(name->buf, arrow[i].name) == 0) {
 928             arrow[i].type = XK_NOD;
 929             return 0;
 930         }
 931     return -1;
 932 }
 933
 934 void
 935 PrintArrowKeys(name)
 936     CStr *name;
 937 {
 938     int i;
 939
 940     for (i = 0; i < A_K_NKEYS; i++)
 941         if (name->len == 0 || Strcmp(name->buf, arrow[i].name) == 0)
 942             if (arrow[i].type != XK_NOD) {
 943                 CStr cs;
 944                 cs.buf = arrow[i].name;
 945                 cs.len = Strlen(cs.buf);
 946                 (void) printOne(&cs, &arrow[i].fun, arrow[i].type);
 947             }
 948 }
 949
 950
 951 void
 952 BindArrowKeys()
 953 {
 954     KEYCMD *map, *dmap;
 955     int     i, j;
 956     char   *p;
 957     CStr    cs;
 958
 959     if (!GotTermCaps)
 960         return;
 961     map = VImode ? CcAltMap : CcKeyMap;
 962     dmap = VImode ? CcViCmdMap : CcEmacsMap;
 963
 964     DefaultArrowKeys();
 965
 966     for (i = 0; i < A_K_NKEYS; i++) {
 967         p = tstr[arrow[i].key].str;
 968         if (p && *p) {
 969             j = (unsigned char) *p;
 970             cs.buf = str2short(p);
 971             cs.len = Strlen(cs.buf);
 972             /*
 973              * Assign the arrow keys only if:
 974              *
 975              * 1. They are multi-character arrow keys and the user
 976              *    has not re-assigned the leading character, or
 977              *    has re-assigned the leading character to be F_XKEY
 978              * 2. They are single arrow keys pointing to an unassigned key.
 979              */
 980             if (arrow[i].type == XK_NOD) {
 981                 ClearXkey(map, &cs);
 982             }
 983             else {
 984                 if (p[1] && (dmap[j] == map[j] || map[j] == F_XKEY)) {
 985                     AddXkey(&cs, &arrow[i].fun, arrow[i].type);
 986                     map[j] = F_XKEY;
 987                 }
 988                 else if (map[j] == F_UNASSIGNED) {
 989                     ClearXkey(map, &cs);
 990                     if (arrow[i].type == XK_CMD)
 991                         map[j] = arrow[i].fun.cmd;
 992                     else
 993                         AddXkey(&cs, &arrow[i].fun, arrow[i].type);
 994                 }
 995             }
 996         }
 997     }
 998 }
 999
1000 static Char cur_atr = 0;        /* current attributes */
1001
1002 void
1003 SetAttributes(atr)
1004     Char     atr;
1005 {
1006     atr &= ATTRIBUTES;
1007     if (atr != cur_atr) {
1008         if (me_all && GoodStr(T_me)) {
1009             if (((cur_atr & BOLD) && !(atr & BOLD)) ||
1010                 ((cur_atr & UNDER) && !(atr & UNDER)) ||
1011                 ((cur_atr & STANDOUT) && !(atr & STANDOUT))) {
1012                 (void) tputs(Str(T_me), 1, PUTPURE);
1013                 cur_atr = 0;
1014             }
1015         }
1016         if ((atr & BOLD) != (cur_atr & BOLD)) {
1017             if (atr & BOLD) {
1018                 if (GoodStr(T_md) && GoodStr(T_me)) {
1019                     (void) tputs(Str(T_md), 1, PUTPURE);
1020                     cur_atr |= BOLD;
1021                 }
1022             }
1023             else {
1024                 if (GoodStr(T_md) && GoodStr(T_me)) {
1025                     (void) tputs(Str(T_me), 1, PUTPURE);
1026                     if ((cur_atr & STANDOUT) && GoodStr(T_se)) {
1027                         (void) tputs(Str(T_se), 1, PUTPURE);
1028                         cur_atr &= ~STANDOUT;
1029                     }
1030                     if ((cur_atr & UNDER) && GoodStr(T_ue)) {
1031                         (void) tputs(Str(T_ue), 1, PUTPURE);
1032                         cur_atr &= ~UNDER;
1033                     }
1034                     cur_atr &= ~BOLD;
1035                 }
1036             }
1037         }
1038         if ((atr & STANDOUT) != (cur_atr & STANDOUT)) {
1039             if (atr & STANDOUT) {
1040                 if (GoodStr(T_so) && GoodStr(T_se)) {
1041                     (void) tputs(Str(T_so), 1, PUTPURE);
1042                     cur_atr |= STANDOUT;
1043                 }
1044             }
1045             else {
1046                 if (GoodStr(T_se)) {
1047                     (void) tputs(Str(T_se), 1, PUTPURE);
1048                     cur_atr &= ~STANDOUT;
1049                 }
1050             }
1051         }
1052         if ((atr & UNDER) != (cur_atr & UNDER)) {
1053             if (atr & UNDER) {
1054                 if (GoodStr(T_us) && GoodStr(T_ue)) {
1055                     (void) tputs(Str(T_us), 1, PUTPURE);
1056                     cur_atr |= UNDER;
1057                 }
1058             }
1059             else {
1060                 if (GoodStr(T_ue)) {
1061                     (void) tputs(Str(T_ue), 1, PUTPURE);
1062                     cur_atr &= ~UNDER;
1063                 }
1064             }
1065         }
1066     }
1067 }
1068
1069 /* PWP 6-27-88 -- if the tty driver thinks that we can tab, we ask termcap */
1070 int
1071 CanWeTab()
1072 {
1073     return (Val(T_pt));
1074 }
1075
1076 void
1077 MoveToLine(where)               /* move to line <where> (first line == 0) */
1078     int     where;              /* as efficiently as possible; */
1079 {
1080     int     del;
1081
1082     if (where == CursorV)
1083         return;
1084
1085     if (where > TermV) {
1086 #ifdef DEBUG_SCREEN
1087         xprintf("MoveToLine: where is ridiculous: %d\r\n", where);
1088         flush();
1089 #endif /* DEBUG_SCREEN */
1090         return;
1091     }
1092
1093     del = where - CursorV;
1094
1095     if (del > 0) {
1096         while (del > 0) {
1097             if ((T_Margin & MARGIN_AUTO) && Display[CursorV][0] != '\0') {
1098                 size_t h;
1099
1100                 for (h = TermH - 1; h > 0 && Display[CursorV][h] == CHAR_DBWIDTH;
1101                      h--)
1102                     ;
1103                 /* move without newline */
1104                 MoveToChar(h);
1105                 so_write(&Display[CursorV][CursorH], TermH - CursorH); /* updates CursorH/V*/
1106                 del--;
1107             }
1108             else {
1109                 if ((del > 1) && GoodStr(T_DO)) {
1110                     (void) tputs(tgoto(Str(T_DO), del, del), del, PUTPURE);
1111                     del = 0;
1112                 }
1113                 else {
1114                     for ( ; del > 0; del--)
1115                         (void) putraw('\n');
1116                     CursorH = 0;        /* because the \n will become \r\n */
1117                 }
1118             }
1119         }
1120     }
1121     else {                      /* del < 0 */
1122         if (GoodStr(T_UP) && (-del > 1 || !GoodStr(T_up)))
1123             (void) tputs(tgoto(Str(T_UP), -del, -del), -del, PUTPURE);
1124         else {
1125             int i;
1126             if (GoodStr(T_up))
1127                 for (i = 0; i < -del; i++)
1128                     (void) tputs(Str(T_up), 1, PUTPURE);
1129         }
1130     }
1131     CursorV = where;            /* now where is here */
1132 }
1133
1134 void
1135 MoveToChar(where)               /* move to character position (where) */
1136     int     where;
1137 {                               /* as efficiently as possible */
1138     int     del;
1139
1140 mc_again:
1141     if (where == CursorH)
1142         return;
1143
1144     if (where >= TermH) {
1145 #ifdef DEBUG_SCREEN
1146         xprintf("MoveToChar: where is riduculous: %d\r\n", where);
1147         flush();
1148 #endif /* DEBUG_SCREEN */
1149         return;
1150     }
1151
1152     if (!where) {               /* if where is first column */
1153         (void) putraw('\r');    /* do a CR */
1154         CursorH = 0;
1155         return;
1156     }
1157
1158     del = where - CursorH;
1159
1160     if ((del < -4 || del > 4) && GoodStr(T_ch))
1161         /* go there directly */
1162         (void) tputs(tgoto(Str(T_ch), where, where), where, PUTPURE);
1163     else {
1164         int i;
1165         if (del > 0) {          /* moving forward */
1166             if ((del > 4) && GoodStr(T_RI))
1167                 (void) tputs(tgoto(Str(T_RI), del, del), del, PUTPURE);
1168             else {
1169                 /* if I can do tabs, use them */
1170                 if (T_Tabs) {
1171                     if ((CursorH & 0370) != (where & ~0x7)
1172                         && Display[CursorV][where & ~0x7] != CHAR_DBWIDTH) {
1173                         /* if not within tab stop */
1174                         for (i = (CursorH & 0370); i < (where & ~0x7); i += 8)
1175                             (void) putraw('\t');        /* then tab over */
1176                         CursorH = where & ~0x7;
1177                         /* Note: considering that we often want to go to
1178                            TermH - 1 for the wrapping, it would be nice to
1179                            optimize this case by tabbing to the last column
1180                            - but this doesn't work for all terminals! */
1181                     }
1182                 }
1183                 /* it's usually cheaper to just write the chars, so we do. */
1184
1185                 /* NOTE THAT so_write() WILL CHANGE CursorH!!! */
1186                 so_write(&Display[CursorV][CursorH], where - CursorH);
1187
1188             }
1189         }
1190         else {                  /* del < 0 := moving backward */
1191             if ((-del > 4) && GoodStr(T_LE))
1192                 (void) tputs(tgoto(Str(T_LE), -del, -del), -del, PUTPURE);
1193             else {              /* can't go directly there */
1194                 /* if the "cost" is greater than the "cost" from col 0 */
1195                 if (T_Tabs ? (-del > ((where >> 3) + (where & 07)))
1196                     : (-del > where)) {
1197                     (void) putraw('\r');        /* do a CR */
1198                     CursorH = 0;
1199                     goto mc_again;      /* and try again */
1200                 }
1201                 for (i = 0; i < -del; i++)
1202                     (void) putraw('\b');
1203             }
1204         }
1205     }
1206     CursorH = where;            /* now where is here */
1207 }
1208
1209 void
1210 so_write(cp, n)
1211     Char *cp;
1212     int n;
1213 {
1214     if (n <= 0)
1215         return;                 /* catch bugs */
1216
1217     if (n > TermH) {
1218 #ifdef DEBUG_SCREEN
1219         xprintf("so_write: n is riduculous: %d\r\n", n);
1220         flush();
1221 #endif /* DEBUG_SCREEN */
1222         return;
1223     }
1224
1225     do {
1226         if (*cp != CHAR_DBWIDTH) {
1227             if (*cp & LITERAL) {
1228                 Char   *d;
1229 #ifdef DEBUG_LITERAL
1230                 xprintf("so: litnum %d\r\n", (int)(*cp & ~LITERAL));
1231 #endif /* DEBUG_LITERAL */
1232                 for (d = litptr + (*cp & ~LITERAL) * LIT_FACTOR; *d; d++)
1233                     (void) putwraw(*d);
1234             }
1235             else
1236                 (void) putwraw(*cp);
1237         }
1238         cp++;
1239         CursorH++;
1240     } while (--n);
1241
1242     if (CursorH >= TermH) { /* wrap? */
1243         if (T_Margin & MARGIN_AUTO) { /* yes */
1244             CursorH = 0;
1245             CursorV++;
1246             if (T_Margin & MARGIN_MAGIC) {
1247                 /* force the wrap to avoid the "magic" situation */
1248                 Char c;
1249                 if ((c = Display[CursorV][CursorH]) != '\0') {
1250                     so_write(&c, 1);
1251                     while(Display[CursorV][CursorH] == CHAR_DBWIDTH)
1252                         CursorH++;
1253                 }
1254                 else {
1255                     (void) putraw(' ');
1256                     CursorH = 1;
1257                 }
1258             }
1259         }
1260         else                    /* no wrap, but cursor stays on screen */
1261             CursorH = TermH - 1;
1262     }
1263 }
1264
1265
1266 void
1267 DeleteChars(num)                /* deletes <num> characters */
1268     int     num;
1269 {
1270     if (num <= 0)
1271         return;
1272
1273     if (!T_CanDel) {
1274 #ifdef DEBUG_EDIT
1275         xprintf(CGETS(7, 16, "ERROR: cannot delete\r\n"));
1276 #endif /* DEBUG_EDIT */
1277         flush();
1278         return;
1279     }
1280
1281     if (num > TermH) {
1282 #ifdef DEBUG_SCREEN
1283         xprintf(CGETS(7, 17, "DeleteChars: num is riduculous: %d\r\n"), num);
1284         flush();
1285 #endif /* DEBUG_SCREEN */
1286         return;
1287     }
1288
1289     if (GoodStr(T_DC))          /* if I have multiple delete */
1290         if ((num > 1) || !GoodStr(T_dc)) {      /* if dc would be more expen. */
1291             (void) tputs(tgoto(Str(T_DC), num, num), num, PUTPURE);
1292             return;
1293         }
1294
1295     if (GoodStr(T_dm))          /* if I have delete mode */
1296         (void) tputs(Str(T_dm), 1, PUTPURE);
1297
1298     if (GoodStr(T_dc))          /* else do one at a time */
1299         while (num--)
1300             (void) tputs(Str(T_dc), 1, PUTPURE);
1301
1302     if (GoodStr(T_ed))          /* if I have delete mode */
1303         (void) tputs(Str(T_ed), 1, PUTPURE);
1304 }
1305
1306 void
1307 Insert_write(cp, num)           /* Puts terminal in insert character mode, */
1308     Char *cp;
1309     int num;            /* or inserts num characters in the line */
1310 {
1311     if (num <= 0)
1312         return;
1313     if (!T_CanIns) {
1314 #ifdef DEBUG_EDIT
1315         xprintf(CGETS(7, 18, "ERROR: cannot insert\r\n"));
1316 #endif /* DEBUG_EDIT */
1317         flush();
1318         return;
1319     }
1320
1321     if (num > TermH) {
1322 #ifdef DEBUG_SCREEN
1323         xprintf(CGETS(7, 19, "StartInsert: num is riduculous: %d\r\n"), num);
1324         flush();
1325 #endif /* DEBUG_SCREEN */
1326         return;
1327     }
1328
1329     if (GoodStr(T_IC))          /* if I have multiple insert */
1330         if ((num > 1) || !GoodStr(T_ic)) {      /* if ic would be more expen. */
1331             (void) tputs(tgoto(Str(T_IC), num, num), num, PUTPURE);
1332             so_write(cp, num);  /* this updates CursorH/V */
1333             return;
1334         }
1335
1336     if (GoodStr(T_im) && GoodStr(T_ei)) { /* if I have insert mode */
1337         (void) tputs(Str(T_im), 1, PUTPURE);
1338
1339         so_write(cp, num);      /* this updates CursorH/V */
1340
1341         if (GoodStr(T_ip))      /* have to make num chars insert */
1342             (void) tputs(Str(T_ip), 1, PUTPURE);
1343
1344         (void) tputs(Str(T_ei), 1, PUTPURE);
1345         return;
1346     }
1347
1348     do {
1349         if (GoodStr(T_ic))      /* have to make num chars insert */
1350             (void) tputs(Str(T_ic), 1, PUTPURE);        /* insert a char */
1351
1352         so_write(cp++, 1);      /* this updates CursorH/V */
1353
1354         if (GoodStr(T_ip))      /* have to make num chars insert */
1355             (void) tputs(Str(T_ip), 1, PUTPURE);/* pad the inserted char */
1356
1357     } while (--num);
1358
1359 }
1360
1361 void
1362 ClearEOL(num)                   /* clear to end of line.  There are num */
1363     int     num;                /* characters to clear */
1364 {
1365     int i;
1366
1367     if (num <= 0)
1368         return;
1369
1370     if (T_CanCEOL && GoodStr(T_ce))
1371         (void) tputs(Str(T_ce), 1, PUTPURE);
1372     else {
1373         for (i = 0; i < num; i++)
1374             (void) putraw(' ');
1375         CursorH += num;         /* have written num spaces */
1376     }
1377 }
1378
1379 void
1380 ClearScreen()
1381 {                               /* clear the whole screen and home */
1382     if (GoodStr(T_cl))
1383         /* send the clear screen code */
1384         (void) tputs(Str(T_cl), Val(T_li), PUTPURE);
1385     else if (GoodStr(T_ho) && GoodStr(T_cd)) {
1386         (void) tputs(Str(T_ho), Val(T_li), PUTPURE);    /* home */
1387         /* clear to bottom of screen */
1388         (void) tputs(Str(T_cd), Val(T_li), PUTPURE);
1389     }
1390     else {
1391         (void) putraw('\r');
1392         (void) putraw('\n');
1393     }
1394 }
1395
1396 void
1397 SoundBeep()
1398 {                               /* produce a sound */
1399     beep_cmd ();
1400     if (adrof(STRnobeep))
1401         return;
1402
1403     if (GoodStr(T_vb) && adrof(STRvisiblebell))
1404         (void) tputs(Str(T_vb), 1, PUTPURE);    /* visible bell */
1405     else if (GoodStr(T_bl))
1406         /* what termcap says we should use */
1407         (void) tputs(Str(T_bl), 1, PUTPURE);
1408     else
1409         (void) putraw(CTL_ESC('\007')); /* an ASCII bell; ^G */
1410 }
1411
1412 void
1413 ClearToBottom()
1414 {                               /* clear to the bottom of the screen */
1415     if (GoodStr(T_cd))
1416         (void) tputs(Str(T_cd), Val(T_li), PUTPURE);
1417     else if (GoodStr(T_ce))
1418         (void) tputs(Str(T_ce), Val(T_li), PUTPURE);
1419 }
1420
1421 void
1422 GetTermCaps()
1423 {                               /* read in the needed terminal capabilites */
1424     int i;
1425     const char   *ptr;
1426     char    buf[TC_BUFSIZE];
1427     static char bp[TC_BUFSIZE];
1428     char   *area;
1429     struct termcapstr *t;
1430
1431
1432 #ifdef SIG_WINDOW
1433 # ifdef BSDSIGS
1434     sigmask_t omask;
1435 # endif /* BSDSIGS */
1436     int     lins, cols;
1437
1438     /* don't want to confuse things here */
1439 # ifdef BSDSIGS
1440     omask = sigblock(sigmask(SIG_WINDOW)) & ~sigmask(SIG_WINDOW);
1441 # else /* BSDSIGS */
1442     (void) sighold(SIG_WINDOW);
1443 # endif /* BSDSIGS */
1444 #endif /* SIG_WINDOW */
1445     area = buf;
1446
1447     GotTermCaps = 1;
1448
1449     setname("gettermcaps");
1450     ptr = getenv("TERM");
1451
1452 #ifdef apollo
1453     /*
1454      * If we are on a pad, we pretend that we are dumb. Otherwise the termcap
1455      * library will put us in a weird screen mode, thinking that we are going
1456      * to use curses
1457      */
1458     if (isapad())
1459         ptr = "dumb";
1460 #endif /* apollo */
1461
1462     if (!ptr || !ptr[0] || !strcmp(ptr, "wm") || !strcmp(ptr,"dmx"))
1463         ptr = "dumb";
1464
1465     setzero(bp, TC_BUFSIZE);
1466
1467     i = tgetent(bp, ptr);
1468     if (i <= 0) {
1469         if (i == -1) {
1470 #if (SYSVREL == 0) || defined(IRIS3D)
1471             xprintf(CGETS(7, 20, "%s: Cannot open /etc/termcap.\n"), progname);
1472         }
1473         else if (i == 0) {
1474 #endif /* SYSVREL */
1475             xprintf(CGETS(7, 21,
1476                           "%s: No entry for terminal type \"%s\"\n"), progname,
1477                     getenv("TERM"));
1478         }
1479         xprintf(CGETS(7, 22, "%s: using dumb terminal settings.\n"), progname);
1480         Val(T_co) = 80;         /* do a dumb terminal */
1481         Val(T_pt) = Val(T_km) = Val(T_li) = 0;
1482         for (t = tstr; t->name != NULL; t++)
1483             TCalloc(t, NULL);
1484     }
1485     else {
1486         /* Can we tab */
1487         Val(T_pt) = tgetflag("pt") && !tgetflag("xt");
1488         /* do we have a meta? */
1489         Val(T_km) = (tgetflag("km") || tgetflag("MT"));
1490         Val(T_am) = tgetflag("am");
1491         Val(T_xn) = tgetflag("xn");
1492         Val(T_co) = tgetnum("co");
1493         Val(T_li) = tgetnum("li");
1494         for (t = tstr; t->name != NULL; t++)
1495             TCalloc(t, tgetstr(t->name, &area));
1496     }
1497     if (Val(T_co) < 2)
1498         Val(T_co) = 80;         /* just in case */
1499     if (Val(T_li) < 1)
1500         Val(T_li) = 24;
1501
1502     T_Cols = (Char) Val(T_co);
1503     T_Lines = (Char) Val(T_li);
1504     if (T_Tabs)
1505         T_Tabs = (Char) Val(T_pt);
1506     T_HasMeta = (Char) Val(T_km);
1507     T_Margin = (Char) Val(T_am) ? MARGIN_AUTO : 0;
1508     T_Margin |= (Char) Val(T_xn) ? MARGIN_MAGIC : 0;
1509     T_CanCEOL = GoodStr(T_ce);
1510     T_CanDel = GoodStr(T_dc) || GoodStr(T_DC);
1511     T_CanIns = GoodStr(T_im) || GoodStr(T_ic) || GoodStr(T_IC);
1512     T_CanUP = GoodStr(T_up) || GoodStr(T_UP);
1513     if (GoodStr(T_me) && GoodStr(T_ue))
1514         me_all = (strcmp(Str(T_me), Str(T_ue)) == 0);
1515     else
1516         me_all = 0;
1517     if (GoodStr(T_me) && GoodStr(T_se))
1518         me_all |= (strcmp(Str(T_me), Str(T_se)) == 0);
1519
1520
1521 #ifdef DEBUG_SCREEN
1522     if (!T_CanUP) {
1523         xprintf(CGETS(7, 23, "%s: WARNING: Your terminal cannot move up.\n",
1524                 progname));
1525         xprintf(CGETS(7, 24, "Editing may be odd for long lines.\n"));
1526     }
1527     if (!T_CanCEOL)
1528         xprintf(CGETS(7, 25, "no clear EOL capability.\n"));
1529     if (!T_CanDel)
1530         xprintf(CGETS(7, 26, "no delete char capability.\n"));
1531     if (!T_CanIns)
1532         xprintf(CGETS(7, 27, "no insert char capability.\n"));
1533 #endif /* DEBUG_SCREEN */
1534
1535
1536
1537 #ifdef SIG_WINDOW
1538     (void) GetSize(&lins, &cols);       /* get the correct window size */
1539     ChangeSize(lins, cols);
1540
1541 # ifdef BSDSIGS
1542     (void) sigsetmask(omask);   /* can change it again */
1543 # else /* BSDSIGS */
1544     (void) sigrelse(SIG_WINDOW);
1545 # endif /* BSDSIGS */
1546 #else /* SIG_WINDOW */
1547     ChangeSize(Val(T_li), Val(T_co));
1548 #endif /* SIG_WINDOW */
1549
1550     BindArrowKeys();
1551 }
1552
1553 #ifdef SIG_WINDOW
1554 /* GetSize():
1555  *      Return the new window size in lines and cols, and
1556  *      true if the size was changed. This can fail if SHIN
1557  *      is not a tty, but it will work in most cases.
1558  */
1559 int
1560 GetSize(lins, cols)
1561     int    *lins, *cols;
1562 {
1563     *cols = Val(T_co);
1564     *lins = Val(T_li);
1565
1566 #ifdef TIOCGWINSZ
1567 # define KNOWsize
1568 # ifndef lint
1569     {
1570         struct winsize ws;      /* from 4.3 */
1571
1572         if (ioctl(SHIN, TIOCGWINSZ, (ioctl_t) &ws) != -1) {
1573             if (ws.ws_col)
1574                 *cols = ws.ws_col;
1575             if (ws.ws_row)
1576                 *lins = ws.ws_row;
1577         }
1578     }
1579 # endif /* !lint */
1580 #else /* TIOCGWINSZ */
1581 # ifdef TIOCGSIZE
1582 #  define KNOWsize
1583     {
1584         struct ttysize ts;      /* from Sun */
1585
1586         if (ioctl(SHIN, TIOCGSIZE, (ioctl_t) &ts) != -1) {
1587             if (ts.ts_cols)
1588                 *cols = ts.ts_cols;
1589             if (ts.ts_lines)
1590                 *lins = ts.ts_lines;
1591         }
1592     }
1593 # endif /* TIOCGSIZE */
1594 #endif /* TIOCGWINSZ */
1595
1596     return (Val(T_co) != *cols || Val(T_li) != *lins);
1597 }
1598
1599 #endif /* SIGWINDOW */
1600
1601 void
1602 ChangeSize(lins, cols)
1603     int     lins, cols;
1604 {
1605     /*
1606      * Just in case
1607      */
1608     Val(T_co) = (cols < 2) ? 80 : cols;
1609     Val(T_li) = (lins < 1) ? 24 : lins;
1610
1611 #ifdef KNOWsize
1612     /*
1613      * We want to affect the environment only when we have a valid
1614      * setup, not when we get bad settings. Consider the following scenario:
1615      * We just logged in, and we have not initialized the editor yet.
1616      * We reset termcap with tset, and not $TERMCAP has the right
1617      * terminal size. But since the editor is not initialized yet, and
1618      * the kernel's notion of the terminal size might be wrong we arrive
1619      * here with lines = columns = 0. If we reset the environment we lose
1620      * our only chance to get the window size right.
1621      */
1622     if (Val(T_co) == cols && Val(T_li) == lins) {
1623         Char    buf[10];
1624         char   *tptr;
1625
1626         if (getenv("COLUMNS")) {
1627             (void) Itoa(Val(T_co), buf, 0, 0);
1628             tsetenv(STRCOLUMNS, buf);
1629         }
1630
1631         if (getenv("LINES")) {
1632             (void) Itoa(Val(T_li), buf, 0, 0);
1633             tsetenv(STRLINES, buf);
1634         }
1635
1636         if ((tptr = getenv("TERMCAP")) != NULL) {
1637             /* Leave 64 characters slop in case we enlarge the termcap string */
1638             Char    termcap[1024+64], backup[1024+64], *ptr;
1639
1640             ptr = str2short(tptr);
1641             (void) Strncpy(termcap, ptr, 1024);
1642             termcap[1023] = '\0';
1643
1644             /* update termcap string; first do columns */
1645             buf[0] = 'c';
1646             buf[1] = 'o';
1647             buf[2] = '#';
1648             buf[3] = '\0';
1649             if ((ptr = Strstr(termcap, buf)) == NULL) {
1650                 (void) Strcpy(backup, termcap);
1651             }
1652             else {
1653                 size_t len = (ptr - termcap) + Strlen(buf);
1654                 (void) Strncpy(backup, termcap, len);
1655                 backup[len] = '\0';
1656                 (void) Itoa(Val(T_co), buf, 0, 0);
1657                 (void) Strcat(backup + len, buf);
1658                 ptr = Strchr(ptr, ':');
1659                 (void) Strcat(backup, ptr);
1660             }
1661
1662             /* now do lines */
1663             buf[0] = 'l';
1664             buf[1] = 'i';
1665             buf[2] = '#';
1666             buf[3] = '\0';
1667             if ((ptr = Strstr(backup, buf)) == NULL) {
1668                 (void) Strcpy(termcap, backup);
1669             }
1670             else {
1671                 size_t len = (ptr - backup) + Strlen(buf);
1672                 (void) Strncpy(termcap, backup, len);
1673                 termcap[len] = '\0';
1674                 (void) Itoa(Val(T_li), buf, 0, 0);
1675                 (void) Strcat(termcap, buf);
1676                 ptr = Strchr(ptr, ':');
1677                 (void) Strcat(termcap, ptr);
1678             }
1679             /*
1680              * Chop the termcap string at 1024 characters to avoid core-dumps
1681              * in the termcap routines
1682              */
1683             termcap[1023] = '\0';
1684             tsetenv(STRTERMCAP, termcap);
1685         }
1686     }
1687 #endif /* KNOWsize */
1688
1689     ReBufferDisplay();          /* re-make display buffers */
1690     ClearDisp();
1691 }