hack/hack.termcap.c

   1 /*      $NetBSD: hack.termcap.c,v 1.12 2003/04/02 18:36:40 jsm Exp $    */
   2
   3 /*
   4  * Copyright (c) 1985, Stichting Centrum voor Wiskunde en Informatica,
   5  * Amsterdam
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions are
  10  * met:
  11  *
  12  * - Redistributions of source code must retain the above copyright notice,
  13  * this list of conditions and the following disclaimer.
  14  *
  15  * - Redistributions in binary form must reproduce the above copyright
  16  * notice, this list of conditions and the following disclaimer in the
  17  * documentation and/or other materials provided with the distribution.
  18  *
  19  * - Neither the name of the Stichting Centrum voor Wiskunde en
  20  * Informatica, nor the names of its contributors may be used to endorse or
  21  * promote products derived from this software without specific prior
  22  * written permission.
  23  *
  24  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
  25  * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  26  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
  27  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
  28  * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  29  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  30  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  31  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  32  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  33  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  34  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  35  */
  36
  37 /*
  38  * Copyright (c) 1982 Jay Fenlason <hack@gnu.org>
  39  * All rights reserved.
  40  *
  41  * Redistribution and use in source and binary forms, with or without
  42  * modification, are permitted provided that the following conditions
  43  * are met:
  44  * 1. Redistributions of source code must retain the above copyright
  45  *    notice, this list of conditions and the following disclaimer.
  46  * 2. Redistributions in binary form must reproduce the above copyright
  47  *    notice, this list of conditions and the following disclaimer in the
  48  *    documentation and/or other materials provided with the distribution.
  49  * 3. The name of the author may not be used to endorse or promote products
  50  *    derived from this software without specific prior written permission.
  51  *
  52  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
  53  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
  54  * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
  55  * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  56  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  57  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  58  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  59  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  60  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  61  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  62  */
  63
  64 #include <sys/cdefs.h>
  65 #ifndef lint
  66 __RCSID("$NetBSD: hack.termcap.c,v 1.12 2003/04/02 18:36:40 jsm Exp $");
  67 #endif                          /* not lint */
  68
  69 #include <string.h>
  70 #include <termios.h>
  71 #include <termcap.h>
  72 #include <stdlib.h>
  73 #include <unistd.h>
  74 #include "hack.h"
  75 #include "extern.h"
  76 #include "def.flag.h"           /* for flags.nonull */
  77
  78 static struct tinfo *info;
  79 static char    *HO, *CL, *CE, *UP, *CM, *ND, *XD, *BC, *SO, *SE, *TI, *TE;
  80 static char    *VS, *VE;
  81 static int      SG;
  82 static char     PC = '\0';
  83 static char     BC_char = '\b'; /* if bc is not set use this */
  84 char           *CD;             /* tested in pri.c: docorner() */
  85 int             CO, LI;         /* used in pri.c and whatis.c */
  86
  87 void
  88 startup()
  89 {
  90         char           *term;
  91         char           *pc;
  92
  93
  94         if (!(term = getenv("TERM")))
  95                 error("Can't get TERM.");
  96         if (!strncmp(term, "5620", 4))
  97                 flags.nonull = 1;       /* this should be a termcap flag */
  98         if (t_getent(&info, term) < 1)
  99                 error("Unknown terminal type: %s.", term);
 100         if ((pc = t_agetstr(info, "pc")) != NULL)
 101                 PC = *pc;
 102         if (!(BC = t_agetstr(info, "bc"))) {
 103                 if (!t_getflag(info, "bs"))
 104                         error("Terminal must backspace.");
 105                 BC = &BC_char;
 106         }
 107         HO = t_agetstr(info, "ho");
 108         CO = t_getnum(info, "co");
 109         LI = t_getnum(info, "li");
 110         if (CO < COLNO || LI < ROWNO + 2)
 111                 setclipped();
 112         if (!(CL = t_agetstr(info, "cl")))
 113                 error("Hack needs CL.");
 114         ND = t_agetstr(info, "nd");
 115         if (t_getflag(info, "os"))
 116                 error("Hack can't have OS.");
 117         CE = t_agetstr(info, "ce");
 118         UP = t_agetstr(info, "up");
 119         /*
 120          * It seems that xd is no longer supported, and we should use a
 121          * linefeed instead; unfortunately this requires resetting CRMOD, and
 122          * many output routines will have to be modified slightly. Let's
 123          * leave that till the next release.
 124          */
 125         XD = t_agetstr(info, "xd");
 126         /* not:                 XD = t_agetstr(info, "do"); */
 127         if (!(CM = t_agetstr(info, "cm"))) {
 128                 if (!UP && !HO)
 129                         error("Hack needs CM or UP or HO.");
 130                 printf("Playing hack on terminals without cm is suspect...\n");
 131                 getret();
 132         }
 133         SO = t_agetstr(info, "so");
 134         SE = t_agetstr(info, "se");
 135         SG = t_getnum(info, "sg");      /* -1: not fnd; else # of spaces left by so */
 136         if (!SO || !SE || (SG > 0))
 137                 SO = SE = 0;
 138         CD = t_agetstr(info, "cd");
 139         set_whole_screen();     /* uses LI and CD */
 140 }
 141
 142 void
 143 start_screen()
 144 {
 145         xputs(TI);
 146         xputs(VS);
 147 }
 148
 149 void
 150 end_screen()
 151 {
 152         xputs(VE);
 153         xputs(TE);
 154 }
 155
 156 /* Cursor movements */
 157 void
 158 curs(x, y)
 159         int             x, y;   /* not xchar: perhaps xchar is unsigned and
 160                                  * curx-x would be unsigned as well */
 161 {
 162
 163         if (y == cury && x == curx)
 164                 return;
 165         if (!ND && (curx != x || x <= 3)) {     /* Extremely primitive */
 166                 cmov(x, y);     /* bunker!wtm */
 167                 return;
 168         }
 169         if (abs(cury - y) <= 3 && abs(curx - x) <= 3)
 170                 nocmov(x, y);
 171         else if ((x <= 3 && abs(cury - y) <= 3) || (!CM && x < abs(curx - x))) {
 172                 (void) putchar('\r');
 173                 curx = 1;
 174                 nocmov(x, y);
 175         } else if (!CM) {
 176                 nocmov(x, y);
 177         } else
 178                 cmov(x, y);
 179 }
 180
 181 void
 182 nocmov(x, y)
 183         int x, y;
 184 {
 185         if (cury > y) {
 186                 if (UP) {
 187                         while (cury > y) {      /* Go up. */
 188                                 xputs(UP);
 189                                 cury--;
 190                         }
 191                 } else if (CM) {
 192                         cmov(x, y);
 193                 } else if (HO) {
 194                         home();
 195                         curs(x, y);
 196                 }               /* else impossible("..."); */
 197         } else if (cury < y) {
 198                 if (XD) {
 199                         while (cury < y) {
 200                                 xputs(XD);
 201                                 cury++;
 202                         }
 203                 } else if (CM) {
 204                         cmov(x, y);
 205                 } else {
 206                         while (cury < y) {
 207                                 xputc('\n');
 208                                 curx = 1;
 209                                 cury++;
 210                         }
 211                 }
 212         }
 213         if (curx < x) {         /* Go to the right. */
 214                 if (!ND)
 215                         cmov(x, y);
 216                 else            /* bah */
 217                         /* should instead print what is there already */
 218                         while (curx < x) {
 219                                 xputs(ND);
 220                                 curx++;
 221                         }
 222         } else if (curx > x) {
 223                 while (curx > x) {      /* Go to the left. */
 224                         xputs(BC);
 225                         curx--;
 226                 }
 227         }
 228 }
 229
 230 void
 231 cmov(x, y)
 232         int x, y;
 233 {
 234         char buf[256];
 235
 236         if (t_goto(info, CM, x - 1, y - 1, buf, 255) >= 0) {
 237                 xputs(buf);
 238                 cury = y;
 239                 curx = x;
 240         }
 241 }
 242
 243 int
 244 xputc(c)
 245         char            c;
 246 {
 247         return (fputc(c, stdout));
 248 }
 249
 250 void
 251 xputs(s)
 252         char           *s;
 253 {
 254         tputs(s, 1, xputc);
 255 }
 256
 257 void
 258 cl_end()
 259 {
 260         if (CE)
 261                 xputs(CE);
 262         else {                  /* no-CE fix - free after Harold Rynes */
 263                 /*
 264                  * this looks terrible, especially on a slow terminal but is
 265                  * better than nothing
 266                  */
 267                 int cx = curx, cy = cury;
 268
 269                 while (curx < COLNO) {
 270                         xputc(' ');
 271                         curx++;
 272                 }
 273                 curs(cx, cy);
 274         }
 275 }
 276
 277 void
 278 clear_screen()
 279 {
 280         xputs(CL);
 281         curx = cury = 1;
 282 }
 283
 284 void
 285 home()
 286 {
 287         char buf[256];
 288
 289         if (HO)
 290                 xputs(HO);
 291         else if ((CM) && (t_goto(info, CM, 0, 0, buf, 255) >= 0))
 292                 xputs(buf);
 293         else
 294                 curs(1, 1);     /* using UP ... */
 295         curx = cury = 1;
 296 }
 297
 298 void
 299 standoutbeg()
 300 {
 301         if (SO)
 302                 xputs(SO);
 303 }
 304
 305 void
 306 standoutend()
 307 {
 308         if (SE)
 309                 xputs(SE);
 310 }
 311
 312 void
 313 backsp()
 314 {
 315         xputs(BC);
 316         curx--;
 317 }
 318
 319 void
 320 bell()
 321 {
 322         (void) putchar('\007'); /* curx does not change */
 323         (void) fflush(stdout);
 324 }
 325
 326 void
 327 delay_output()
 328 {
 329
 330         /* delay 50 ms - could also use a 'nap'-system call */
 331           /* or the usleep call like this :-) */
 332         usleep(50000);
 333 }
 334
 335 void
 336 cl_eos()
 337 {                               /* free after Robert Viduya *//* must only be
 338                                  * called with curx = 1 */
 339
 340         if (CD)
 341                 xputs(CD);
 342         else {
 343                 int             cx = curx, cy = cury;
 344                 while (cury <= LI - 2) {
 345                         cl_end();
 346                         xputc('\n');
 347                         curx = 1;
 348                         cury++;
 349                 }
 350                 cl_end();
 351                 curs(cx, cy);
 352         }
 353 }