games/backgammon/common_source/fancy.c

   1 /*
   2  * Copyright (c) 1980, 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. All advertising materials mentioning features or use of this software
  14  *    must display the following acknowledgement:
  15  *      This product includes software developed by the University of
  16  *      California, Berkeley and its contributors.
  17  * 4. 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  * @(#)fancy.c  8.1 (Berkeley) 5/31/93
  34  * $FreeBSD: src/games/backgammon/common_source/fancy.c,v 1.7 1999/11/30 03:48:25 billf Exp $
  35  * $DragonFly: src/games/backgammon/common_source/fancy.c,v 1.3 2003/11/12 14:53:52 eirikn Exp $
  36  */
  37
  38 #include <stdlib.h>
  39 #include <string.h>
  40 #include <termcap.h>
  41 #include "back.h"
  42
  43 char    PC;                     /* padding character */
  44 char    *BC;                    /* backspace sequence */
  45 char    *CD;                    /* clear to end of screen sequence */
  46 char    *CE;                    /* clear to end of line sequence */
  47 char    *CL;                    /* clear screen sequence */
  48 char    *CM;                    /* cursor movement instructions */
  49 char    *HO;                    /* home cursor sequence */
  50 char    *MC;                    /* column cursor movement map */
  51 char    *ML;                    /* row cursor movement map */
  52 char    *ND;                    /* forward cursor sequence */
  53 char    *UP;                    /* up cursor sequence */
  54
  55 int     lHO;                    /* length of HO */
  56 int     lBC;                    /* length of BC */
  57 int     lND;                    /* length of ND */
  58 int     lUP;                    /* length of UP */
  59 int     CO;                     /* number of columns */
  60 int     LI;                     /* number of lines */
  61 int     *linect;                /* array of lengths of lines on screen
  62                                    (the actual screen is not stored) */
  63
  64                                 /* two letter codes */
  65 char    tcap[] = "bccdceclcmhomcmlndup";
  66                                 /* corresponding strings */
  67 char    **tstr[] = { &BC, &CD, &CE, &CL, &CM, &HO, &MC, &ML, &ND, &UP };
  68
  69 int     buffnum;                /* pointer to output buffer */
  70
  71 char    tbuf[1024];             /* buffer for decoded termcap entries */
  72
  73 int     oldb[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
  74
  75 int     oldr;
  76 int     oldw;
  77                                                 /* "real" cursor positions, so
  78                                                  * it knows when to reposition.
  79                                                  * These are -1 if curr and curc
  80                                                  * are accurate */
  81 int     realr;
  82 int     realc;
  83
  84 int     addbuf (int);
  85
  86 fboard ()  {
  87         int     i, j, l;
  88
  89         curmove (0,0);                          /* do top line */
  90         for (i = 0; i < 53; i++)
  91                 fancyc ('_');
  92
  93         curmove (15,0);                         /* do botttom line */
  94         for (i = 0; i < 53; i++)
  95                 fancyc ('_');
  96
  97         l = 1;                                  /* do vertical lines */
  98         for (i = 52; i > -1; i -= 28)  {
  99                 curmove ( (l == 1? 1: 15) ,i);
 100                 fancyc ('|');
 101                 for (j = 0; j < 14; j++)  {
 102                         curmove (curr+l,curc-1);
 103                         fancyc ('|');
 104                 }
 105                 if (i == 24)
 106                         i += 32;
 107                 l = -l;                         /* alternate directions */
 108         }
 109
 110         curmove (2,1);                          /* label positions 13-18 */
 111         for (i = 13; i < 18; i++)  {
 112                 fancyc ('1');
 113                 fancyc ((i % 10)+'0');
 114                 curmove (curr,curc+2);
 115         }
 116         fancyc ('1');
 117         fancyc ('8');
 118
 119         curmove (2,29);                         /* label positions 19-24 */
 120         fancyc ('1');
 121         fancyc ('9');
 122         for (i = 20; i < 25; i++)  {
 123                 curmove (curr,curc+2);
 124                 fancyc ('2');
 125                 fancyc ((i % 10)+'0');
 126         }
 127
 128         curmove (14,1);                         /* label positions 12-7 */
 129         fancyc ('1');
 130         fancyc ('2');
 131         for (i = 11; i > 6; i--)  {
 132                 curmove (curr,curc+2);
 133                 fancyc (i > 9? '1': ' ');
 134                 fancyc ((i % 10)+'0');
 135         }
 136
 137         curmove (14,30);                        /* label positions 6-1 */
 138         fancyc ('6');
 139         for (i = 5; i > 0; i--) {
 140                 curmove (curr,curc+3);
 141                 fancyc (i+'0');
 142         }
 143
 144         for (i = 12; i > 6; i--)                /* print positions 12-7 */
 145                 if (board[i])
 146                         bsect (board[i],13,1+4*(12-i),-1);
 147
 148         if (board[0])                           /* print red men on bar */
 149                 bsect (board[0],13,25,-1);
 150
 151         for (i = 6; i > 0; i--)                 /* print positions 6-1 */
 152                 if (board[i])
 153                         bsect (board[i],13,29+4*(6-i),-1);
 154
 155         l = (off[1] < 0? off[1]+15: off[1]);    /* print white's home */
 156         bsect (l,3,54,1);
 157
 158         curmove (8,25);                         /* print the word BAR */
 159         fancyc ('B');
 160         fancyc ('A');
 161         fancyc ('R');
 162
 163         for (i = 13; i < 19; i++)               /* print positions 13-18 */
 164                 if (board[i])
 165                         bsect (board[i],3,1+4*(i-13),1);
 166
 167         if (board[25])                          /* print white's men on bar */
 168                 bsect (board[25],3,25,1);
 169
 170         for (i = 19; i < 25; i++)               /* print positions 19-24 */
 171                 if (board[i])
 172                         bsect (board[i],3,29+4*(i-19),1);
 173
 174         l = (off[0] < 0? off[0]+15: off[0]);    /* print red's home */
 175         bsect (-l,13,54,-1);
 176
 177         for (i = 0; i < 26; i++)                /* save board position
 178                                                  * for refresh later */
 179                 oldb[i] = board[i];
 180         oldr = (off[1] < 0? off[1]+15: off[1]);
 181         oldw = -(off[0] < 0? off[0]+15: off[0]);
 182 }
 183 \f
 184 /*
 185  * bsect (b,rpos,cpos,cnext)
 186  *      Print the contents of a board position.  "b" has the value of the
 187  * position, "rpos" is the row to start printing, "cpos" is the column to
 188  * start printing, and "cnext" is positive if the position starts at the top
 189  * and negative if it starts at the bottom.  The value of "cpos" is checked
 190  * to see if the position is a player's home, since those are printed
 191  * differently.
 192  */
 193
 194 bsect (b,rpos,cpos,cnext)
 195 int     b;                                      /* contents of position */
 196 int     rpos;                                   /* row of position */
 197 int     cpos;                                   /* column of position */
 198 int     cnext;                                  /* direction of position */
 199
 200 {
 201         int             j;                      /* index */
 202         int             n;                      /* number of men on position */
 203         int             bct;                    /* counter */
 204         int             k;                      /* index */
 205         char            pc;                     /* color of men on position */
 206
 207         n = abs(b);                             /* initialize n and pc */
 208         pc = (b > 0? 'r': 'w');
 209
 210         if (n < 6 && cpos < 54)                 /* position cursor at start */
 211                 curmove (rpos,cpos+1);
 212         else
 213                 curmove (rpos,cpos);
 214
 215         for (j = 0; j < 5; j++)  {              /* print position row by row */
 216
 217                 for (k = 0; k < 15; k += 5)             /* print men */
 218                         if (n > j+k)
 219                                 fancyc (pc);
 220
 221                 if (j < 4)  {                           /* figure how far to
 222                                                          * back up for next
 223                                                          * row */
 224                         if (n < 6)  {                   /* stop if none left */
 225                                 if (j+1 == n)
 226                                         break;
 227                                 bct = 1;                /* single column */
 228                         } else  {
 229                                 if (n < 11)  {          /* two columns */
 230                                         if (cpos == 54)  {      /* home pos */
 231                                                 if (j+5 >= n)
 232                                                         bct = 1;
 233                                                 else
 234                                                         bct = 2;
 235                                         }
 236                                         if (cpos < 54)  {       /* not home */
 237                                                 if (j+6 >= n)
 238                                                         bct = 1;
 239                                                 else
 240                                                         bct = 2;
 241                                         }
 242                                 } else  {               /* three columns */
 243                                         if (j+10 >= n)
 244                                                 bct = 2;
 245                                         else
 246                                                 bct = 3;
 247                                 }
 248                         }
 249                         curmove (curr+cnext,curc-bct);  /* reposition cursor */
 250                 }
 251         }
 252 }
 253 \f
 254 refresh()  {
 255         int     i, r, c;
 256
 257         r = curr;                               /* save current position */
 258         c = curc;
 259
 260         for (i = 12; i > 6; i--)                /* fix positions 12-7 */
 261                 if (board[i] != oldb[i])  {
 262                         fixpos (oldb[i],board[i],13,1+(12-i)*4,-1);
 263                         oldb[i] = board[i];
 264                 }
 265
 266         if (board[0] != oldb[0])  {             /* fix red men on bar */
 267                 fixpos (oldb[0],board[0],13,25,-1);
 268                 oldb[0] = board[0];
 269         }
 270
 271         for (i = 6; i > 0; i--)                 /* fix positions 6-1 */
 272                 if (board[i] != oldb[i])  {
 273                         fixpos (oldb[i],board[i],13,29+(6-i)*4,-1);
 274                         oldb[i] = board[i];
 275                 }
 276
 277         i = -(off[0] < 0? off[0]+15: off[0]);   /* fix white's home */
 278         if (oldw != i)  {
 279                 fixpos (oldw,i,13,54,-1);
 280                 oldw = i;
 281         }
 282
 283         for (i = 13; i < 19; i++)               /* fix positions 13-18 */
 284                 if (board[i] != oldb[i])  {
 285                         fixpos (oldb[i],board[i],3,1+(i-13)*4,1);
 286                         oldb[i] = board[i];
 287                 }
 288
 289         if (board[25] != oldb[25])  {           /* fix white men on bar */
 290                 fixpos (oldb[25],board[25],3,25,1);
 291                 oldb[25] = board[25];
 292         }
 293
 294         for (i = 19; i < 25; i++)               /* fix positions 19-24 */
 295                 if (board[i] != oldb[i])  {
 296                         fixpos (oldb[i],board[i],3,29+(i-19)*4,1);
 297                         oldb[i] = board[i];
 298                 }
 299
 300         i = (off[1] < 0? off[1]+15: off[1]);    /* fix red's home */
 301         if (oldr != i)  {
 302                 fixpos (oldr,i,3,54,1);
 303                 oldr = i;
 304         }
 305
 306         curmove (r,c);                          /* return to saved position */
 307         newpos();
 308         buflush();
 309 }
 310 \f
 311 fixpos (old,new,r,c,inc)
 312 int     old, new, r, c, inc;
 313
 314 {
 315         int             o, n, nv;
 316         int             ov, nc;
 317         char            col;
 318
 319         if (old*new >= 0)  {
 320                 ov = abs(old);
 321                 nv = abs(new);
 322                 col = (old+new > 0? 'r': 'w');
 323                 o = (ov-1)/5;
 324                 n = (nv-1)/5;
 325                 if (o == n)  {
 326                         if (o == 2)
 327                                 nc = c+2;
 328                         if (o == 1)
 329                                 nc = c < 54? c: c+1;
 330                         if (o == 0)
 331                                 nc = c < 54? c+1: c;
 332                         if (ov > nv)
 333                                 fixcol (r+inc*(nv-n*5),nc,abs(ov-nv),' ',inc);
 334                         else
 335                                 fixcol (r+inc*(ov-o*5),nc,abs(ov-nv),col,inc);
 336                         return;
 337                 } else  {
 338                         if (c < 54)  {
 339                                 if (o+n == 1)  {
 340                                         if (n)  {
 341                                                 fixcol (r,c,abs(nv-5),col,inc);
 342                                                 if (ov != 5)
 343                                                         fixcol (r+inc*ov,c+1,abs(ov-5),col,inc);
 344                                         } else  {
 345                                                 fixcol (r,c,abs(ov-5),' ',inc);
 346                                                 if (nv != 5)
 347                                                         fixcol (r+inc*nv,c+1,abs(nv-5),' ',inc);
 348                                         }
 349                                         return;
 350                                 }
 351                                 if (n == 2)  {
 352                                         if (ov != 10)
 353                                                 fixcol (r+inc*(ov-5),c,abs(ov-10),col,inc);
 354                                         fixcol (r,c+2,abs(nv-10),col,inc);
 355                                 } else  {
 356                                         if (nv != 10)
 357                                                 fixcol (r+inc*(nv-5),c,abs(nv-10),' ',inc);
 358                                         fixcol (r,c+2,abs(ov-10),' ',inc);
 359                                 }
 360                                 return;
 361                         }
 362                         if (n > o)  {
 363                                 fixcol (r+inc*(ov%5),c+o,abs(5*n-ov),col,inc);
 364                                 if (nv != 5*n)
 365                                         fixcol (r,c+n,abs(5*n-nv),col,inc);
 366                         } else  {
 367                                 fixcol (r+inc*(nv%5),c+n,abs(5*n-nv),' ',inc);
 368                                 if (ov != 5*o)
 369                                         fixcol (r,c+o,abs(5*o-ov),' ',inc);
 370                         }
 371                         return;
 372                 }
 373         }
 374         nv = abs(new);
 375         fixcol (r,c+1,nv,new > 0? 'r': 'w',inc);
 376         if (abs(old) <= abs(new))
 377                 return;
 378         fixcol (r+inc*new,c+1,abs(old+new),' ',inc);
 379 }
 380
 381 fixcol (r,c,l,ch,inc)
 382 int             l, ch, r, c, inc;
 383
 384 {
 385         int     i;
 386
 387         curmove (r,c);
 388         fancyc (ch);
 389         for (i = 1; i < l; i++)  {
 390                 curmove (curr+inc,curc-1);
 391                 fancyc (ch);
 392         }
 393 }
 394 \f
 395 curmove (r,c)
 396 int     r, c;
 397
 398 {
 399         if (curr == r && curc == c)
 400                 return;
 401         if (realr == -1)  {
 402                 realr = curr;
 403                 realc = curc;
 404         }
 405         curr = r;
 406         curc = c;
 407 }
 408
 409 newpos ()  {
 410         int     r;              /* destination row */
 411         int     c;              /* destination column */
 412         int     mode = -1;      /* mode of movement */
 413
 414         int     count = 1000;           /* character count */
 415         int     i;                      /* index */
 416         int     j;                      /* index */
 417         int     n;                      /* temporary variable */
 418         char    *m;                     /* string containing CM movement */
 419
 420
 421         if (realr == -1)                /* see if already there */
 422                 return;
 423
 424         r = curr;                       /* set current and dest. positions */
 425         c = curc;
 426         curr = realr;
 427         curc = realc;
 428
 429                                         /* double check position */
 430         if (curr == r && curc == c)  {
 431                 realr = realc = -1;
 432                 return;
 433         }
 434
 435         if (CM)  {                      /* try CM to get there */
 436                 mode = 0;
 437                 m = (char *)tgoto (CM,c,r);
 438                 count = strlen (m);
 439         }
 440
 441                                         /* try HO and local movement */
 442         if (HO && (n = r+c*lND+lHO) < count)  {
 443                 mode = 1;
 444                 count = n;
 445         }
 446
 447                                         /* try various LF combinations */
 448         if (r >= curr)  {
 449                                                 /* CR, LF, and ND */
 450                 if ((n = (r-curr)+c*lND+1) < count)  {
 451                         mode = 2;
 452                         count = n;
 453                 }
 454                                                 /* LF, ND */
 455                 if (c >= curc && (n = (r-curr)+(c-curc)*lND) < count)  {
 456                         mode = 3;
 457                         count = n;
 458                 }
 459                                                 /* LF, BS */
 460                 if (c < curc && (n = (r-curr)+(curc-c)*lBC) < count)  {
 461                         mode = 4;
 462                         count = n;
 463                 }
 464         }
 465
 466                                         /* try corresponding UP combinations */
 467         if (r < curr)  {
 468                                                 /* CR, UP, and ND */
 469                 if ((n = (curr-r)*lUP+c*lND+1) < count)  {
 470                         mode = 5;
 471                         count = n;
 472                 }
 473                                                 /* UP and ND */
 474                 if (c >= curc && (n = (curr-r)*lUP+(c-curc)*lND) < count)  {
 475                         mode = 6;
 476                         count = n;
 477                 }
 478                                                 /* UP and BS */
 479                 if (c < curc && (n = (curr-r)*lUP+(curc-c)*lBC) < count)  {
 480                         mode = 7;
 481                         count = n;
 482                 }
 483         }
 484
 485                                                 /* space over */
 486         if (curr == r && c > curc && linect[r] < curc && c-curc < count)
 487                 mode = 8;
 488
 489         switch (mode)  {
 490
 491         case -1:                                /* error! */
 492                 write (2,"\r\nInternal cursor error.\r\n",26);
 493                 getout();
 494
 495                                                 /* direct cursor motion */
 496         case  0:
 497                 tputs (m,abs(curr-r),addbuf);
 498                 break;
 499
 500                                                 /* relative to "home" */
 501         case  1:
 502                 tputs (HO,r,addbuf);
 503                 for (i = 0; i < r; i++)
 504                         addbuf ('\012');
 505                 for (i = 0; i < c; i++)
 506                         tputs (ND,1,addbuf);
 507                 break;
 508
 509                                                 /* CR and down and over */
 510         case  2:
 511                 addbuf ('\015');
 512                 for (i = 0; i < r-curr; i++)
 513                         addbuf ('\012');
 514                 for (i = 0; i < c; i++)
 515                         tputs (ND,1,addbuf);
 516                 break;
 517
 518                                                 /* down and over */
 519         case  3:
 520                 for (i = 0; i < r-curr; i++)
 521                         addbuf ('\012');
 522                 for (i = 0; i < c-curc; i++)
 523                         tputs (ND,1,addbuf);
 524                 break;
 525
 526                                                 /* down and back */
 527         case  4:
 528                 for (i = 0; i < r-curr; i++)
 529                         addbuf ('\012');
 530                 for (i = 0; i < curc-c; i++)
 531                         addbuf ('\010');
 532                 break;
 533
 534                                                 /* CR and up and over */
 535         case  5:
 536                 addbuf ('\015');
 537                 for (i = 0; i < curr-r; i++)
 538                         tputs (UP,1,addbuf);
 539                 for (i = 0; i < c; i++)
 540                         tputs (ND,1,addbuf);
 541                 break;
 542
 543                                                 /* up and over */
 544         case  6:
 545                 for (i = 0; i < curr-r; i++)
 546                         tputs (UP,1,addbuf);
 547                 for (i = 0; i < c-curc; i++)
 548                         tputs (ND,1,addbuf);
 549                 break;
 550
 551                                                 /* up and back */
 552         case  7:
 553                 for (i = 0; i < curr-r; i++)
 554                         tputs (UP,1,addbuf);
 555                 for (i = 0; i < curc-c; i++)  {
 556                         if (BC)
 557                                 tputs (BC,1,addbuf);
 558                         else
 559                                 addbuf ('\010');
 560                 }
 561                 break;
 562
 563                                                 /* safe space */
 564         case  8:
 565                 for (i = 0; i < c-curc; i++)
 566                         addbuf (' ');
 567         }
 568
 569                                                 /* fix positions */
 570         curr = r;
 571         curc = c;
 572         realr = -1;
 573         realc = -1;
 574 }
 575 \f
 576 clear ()  {
 577         int     i;
 578
 579                                         /* double space if can't clear */
 580         if (CL == 0)  {
 581                 writel ("\n\n");
 582                 return;
 583         }
 584
 585         curr = curc = 0;                /* fix position markers */
 586         realr = realc = -1;
 587         for (i = 0; i < 24; i++)        /* clear line counts */
 588                 linect[i] = -1;
 589         buffnum = -1;                   /* ignore leftover buffer contents */
 590         tputs (CL,CO,addbuf);           /* put CL in buffer */
 591 }
 592
 593 \f
 594 fancyc (c)
 595 char    c;                      /* character to output */
 596 {
 597         int     sp;             /* counts spaces in a tab */
 598
 599         if (c == '\007')  {             /* bells go in blindly */
 600                 addbuf (c);
 601                 return;
 602         }
 603
 604                                         /* process tabs, use spaces if the
 605                                          * the tab should be erasing things,
 606                                          * otherwise use cursor movement
 607                                          * routines.  Note this does not use
 608                                          * hardware tabs at all. */
 609         if (c == '\t')  {
 610                 sp = (curc+8) & (~ 7);          /* compute spaces */
 611                                                 /* check line length */
 612                 if (linect[curr] >= curc || sp < 4)  {
 613                         for (; sp > curc; sp--)
 614                                 addbuf (' ');
 615                         curc = sp;              /* fix curc */
 616                 } else
 617                         curmove (curr,sp);
 618                 return;
 619         }
 620
 621                                         /* do newline be calling newline */
 622         if (c == '\n')  {
 623                 newline();
 624                 return;
 625         }
 626
 627                                         /* ignore any other control chars */
 628         if (c < ' ')
 629                 return;
 630
 631                                         /* if an erasing space or non-space,
 632                                          * just add it to buffer.  Otherwise
 633                                          * use cursor movement routine, so that
 634                                          * multiple spaces will be grouped
 635                                          * together */
 636         if (c > ' ' || linect[curr] >= curc)  {
 637                 newpos ();                      /* make sure position correct */
 638                 addbuf (c);                     /* add character to buffer */
 639                                                 /* fix line length */
 640                 if (c == ' ' && linect[curr] == curc)
 641                         linect[curr]--;
 642                 else if (linect[curr] < curc)
 643                         linect[curr] = curc;
 644                 curc++;                         /* fix curc */
 645         } else
 646                                         /* use cursor movement routine */
 647                 curmove (curr,curc+1);
 648 }
 649 \f
 650 clend()  {
 651         int     i;
 652         char    *s;
 653
 654
 655         if (CD)  {
 656                 tputs (CD,CO-curr,addbuf);
 657                 for (i = curr; i < LI; i++)
 658                         linect[i] = -1;
 659                 return;
 660         }
 661
 662         curmove (i = curr,0);
 663         cline();
 664         while (curr < LI-1)  {
 665                 curmove (curr+1,0);
 666                 if (linect[curr] > -1)
 667                         cline ();
 668         }
 669         curmove (i,0);
 670 }
 671
 672 cline ()  {
 673         int     i;
 674         int     c;
 675         char    *s;
 676
 677         if (curc > linect[curr])
 678                 return;
 679         newpos ();
 680         if (CE)  {
 681                 tputs (CE,1,addbuf);
 682                 linect[curr] = curc-1;
 683         } else  {
 684                 c = curc-1;
 685                 while (linect[curr] > c)  {
 686                         addbuf (' ');
 687                         curc++;
 688                         linect[curr]--;
 689                 }
 690                 curmove (curr,c+1);
 691         }
 692 }
 693
 694 newline ()  {
 695         cline();
 696         if (curr == LI-1)
 697                 curmove (begscr,0);
 698         else
 699                 curmove (curr+1,0);
 700 }
 701 \f
 702 int
 703 getcaps (s)
 704 const char      *s;
 705
 706 {
 707         char    *code;          /* two letter code */
 708         char    ***cap;         /* pointer to cap string */
 709         char            *bufp;          /* pointer to cap buffer */
 710         char            tentry[1024];   /* temporary uncoded caps buffer */
 711
 712         tgetent (tentry, (char *)s);            /* get uncoded termcap entry */
 713
 714         LI = tgetnum ("li");            /* get number of lines */
 715         if (LI == -1)
 716                 LI = 12;
 717         CO = tgetnum ("co");            /* get number of columns */
 718         if (CO == -1)
 719                 CO = 65;
 720
 721         bufp = tbuf;                    /* get padding character */
 722         tgetstr ("pc",&bufp);
 723         if (bufp != tbuf)
 724                 PC = *tbuf;
 725         else
 726                 PC = 0;
 727
 728         bufp = tbuf;                    /* get string entries */
 729         cap = tstr;
 730         for (code = tcap; *code; code += 2)
 731                 **cap++ = (char *)tgetstr (code,&bufp);
 732
 733                                         /* get pertinent lengths */
 734         if (HO)
 735                 lHO = strlen (HO);
 736         if (BC)
 737                 lBC = strlen (BC);
 738         else
 739                 lBC = 1;
 740         if (UP)
 741                 lUP = strlen (UP);
 742         if (ND)
 743                 lND = strlen (ND);
 744         if (LI < 24 || CO < 72 || !(CL && UP && ND))
 745                 return (0);
 746         linect = (int *)calloc (LI+1,sizeof(int));
 747         return (1);
 748 }