| 1 | /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */ |
| 2 | /* hack.termcap.c - version 1.0.3 */ |
| 3 | |
| 4 | #include <stdio.h> |
| 5 | #include "config.h" /* for ROWNO and COLNO */ |
| 6 | #include "def.flag.h" /* for flags.nonull */ |
| 7 | extern char *tgetstr(), *tgoto(), *getenv(); |
| 8 | extern long *alloc(); |
| 9 | |
| 10 | #ifndef lint |
| 11 | extern /* it is defined in libtermlib (libtermcap) */ |
| 12 | #endif lint |
| 13 | short ospeed; /* terminal baudrate; used by tputs */ |
| 14 | static char tbuf[512]; |
| 15 | static char *HO, *CL, *CE, *UP, *CM, *ND, *XD, *BC, *SO, *SE, *TI, *TE; |
| 16 | static char *VS, *VE; |
| 17 | static int SG; |
| 18 | static char PC = '\0'; |
| 19 | char *CD; /* tested in pri.c: docorner() */ |
| 20 | int CO, LI; /* used in pri.c and whatis.c */ |
| 21 | |
| 22 | startup() |
| 23 | { |
| 24 | register char *term; |
| 25 | register char *tptr; |
| 26 | char *tbufptr, *pc; |
| 27 | |
| 28 | tptr = (char *) alloc(1024); |
| 29 | |
| 30 | tbufptr = tbuf; |
| 31 | if(!(term = getenv("TERM"))) |
| 32 | error("Can't get TERM."); |
| 33 | if(!strncmp(term, "5620", 4)) |
| 34 | flags.nonull = 1; /* this should be a termcap flag */ |
| 35 | if(tgetent(tptr, term) < 1) |
| 36 | error("Unknown terminal type: %s.", term); |
| 37 | if(pc = tgetstr("pc", &tbufptr)) |
| 38 | PC = *pc; |
| 39 | if(!(BC = tgetstr("bc", &tbufptr))) { |
| 40 | if(!tgetflag("bs")) |
| 41 | error("Terminal must backspace."); |
| 42 | BC = tbufptr; |
| 43 | tbufptr += 2; |
| 44 | *BC = '\b'; |
| 45 | } |
| 46 | HO = tgetstr("ho", &tbufptr); |
| 47 | CO = tgetnum("co"); |
| 48 | LI = tgetnum("li"); |
| 49 | if(CO < COLNO || LI < ROWNO+2) |
| 50 | setclipped(); |
| 51 | if(!(CL = tgetstr("cl", &tbufptr))) |
| 52 | error("Hack needs CL."); |
| 53 | ND = tgetstr("nd", &tbufptr); |
| 54 | if(tgetflag("os")) |
| 55 | error("Hack can't have OS."); |
| 56 | CE = tgetstr("ce", &tbufptr); |
| 57 | UP = tgetstr("up", &tbufptr); |
| 58 | /* It seems that xd is no longer supported, and we should use |
| 59 | a linefeed instead; unfortunately this requires resetting |
| 60 | CRMOD, and many output routines will have to be modified |
| 61 | slightly. Let's leave that till the next release. */ |
| 62 | XD = tgetstr("xd", &tbufptr); |
| 63 | /* not: XD = tgetstr("do", &tbufptr); */ |
| 64 | if(!(CM = tgetstr("cm", &tbufptr))) { |
| 65 | if(!UP && !HO) |
| 66 | error("Hack needs CM or UP or HO."); |
| 67 | printf("Playing hack on terminals without cm is suspect...\n"); |
| 68 | getret(); |
| 69 | } |
| 70 | SO = tgetstr("so", &tbufptr); |
| 71 | SE = tgetstr("se", &tbufptr); |
| 72 | SG = tgetnum("sg"); /* -1: not fnd; else # of spaces left by so */ |
| 73 | if(!SO || !SE || (SG > 0)) SO = SE = 0; |
| 74 | CD = tgetstr("cd", &tbufptr); |
| 75 | set_whole_screen(); /* uses LI and CD */ |
| 76 | if(tbufptr-tbuf > sizeof(tbuf)) error("TERMCAP entry too big...\n"); |
| 77 | free(tptr); |
| 78 | } |
| 79 | |
| 80 | start_screen() |
| 81 | { |
| 82 | xputs(TI); |
| 83 | xputs(VS); |
| 84 | } |
| 85 | |
| 86 | end_screen() |
| 87 | { |
| 88 | xputs(VE); |
| 89 | xputs(TE); |
| 90 | } |
| 91 | |
| 92 | /* Cursor movements */ |
| 93 | extern xchar curx, cury; |
| 94 | |
| 95 | curs(x, y) |
| 96 | register int x, y; /* not xchar: perhaps xchar is unsigned and |
| 97 | curx-x would be unsigned as well */ |
| 98 | { |
| 99 | |
| 100 | if (y == cury && x == curx) |
| 101 | return; |
| 102 | if(!ND && (curx != x || x <= 3)) { /* Extremely primitive */ |
| 103 | cmov(x, y); /* bunker!wtm */ |
| 104 | return; |
| 105 | } |
| 106 | if(abs(cury-y) <= 3 && abs(curx-x) <= 3) |
| 107 | nocmov(x, y); |
| 108 | else if((x <= 3 && abs(cury-y)<= 3) || (!CM && x<abs(curx-x))) { |
| 109 | (void) putchar('\r'); |
| 110 | curx = 1; |
| 111 | nocmov(x, y); |
| 112 | } else if(!CM) { |
| 113 | nocmov(x, y); |
| 114 | } else |
| 115 | cmov(x, y); |
| 116 | } |
| 117 | |
| 118 | nocmov(x, y) |
| 119 | { |
| 120 | if (cury > y) { |
| 121 | if(UP) { |
| 122 | while (cury > y) { /* Go up. */ |
| 123 | xputs(UP); |
| 124 | cury--; |
| 125 | } |
| 126 | } else if(CM) { |
| 127 | cmov(x, y); |
| 128 | } else if(HO) { |
| 129 | home(); |
| 130 | curs(x, y); |
| 131 | } /* else impossible("..."); */ |
| 132 | } else if (cury < y) { |
| 133 | if(XD) { |
| 134 | while(cury < y) { |
| 135 | xputs(XD); |
| 136 | cury++; |
| 137 | } |
| 138 | } else if(CM) { |
| 139 | cmov(x, y); |
| 140 | } else { |
| 141 | while(cury < y) { |
| 142 | xputc('\n'); |
| 143 | curx = 1; |
| 144 | cury++; |
| 145 | } |
| 146 | } |
| 147 | } |
| 148 | if (curx < x) { /* Go to the right. */ |
| 149 | if(!ND) cmov(x, y); else /* bah */ |
| 150 | /* should instead print what is there already */ |
| 151 | while (curx < x) { |
| 152 | xputs(ND); |
| 153 | curx++; |
| 154 | } |
| 155 | } else if (curx > x) { |
| 156 | while (curx > x) { /* Go to the left. */ |
| 157 | xputs(BC); |
| 158 | curx--; |
| 159 | } |
| 160 | } |
| 161 | } |
| 162 | |
| 163 | cmov(x, y) |
| 164 | register x, y; |
| 165 | { |
| 166 | xputs(tgoto(CM, x-1, y-1)); |
| 167 | cury = y; |
| 168 | curx = x; |
| 169 | } |
| 170 | |
| 171 | xputc(c) char c; { |
| 172 | (void) fputc(c, stdout); |
| 173 | } |
| 174 | |
| 175 | xputs(s) char *s; { |
| 176 | tputs(s, 1, xputc); |
| 177 | } |
| 178 | |
| 179 | cl_end() { |
| 180 | if(CE) |
| 181 | xputs(CE); |
| 182 | else { /* no-CE fix - free after Harold Rynes */ |
| 183 | /* this looks terrible, especially on a slow terminal |
| 184 | but is better than nothing */ |
| 185 | register cx = curx, cy = cury; |
| 186 | |
| 187 | while(curx < COLNO) { |
| 188 | xputc(' '); |
| 189 | curx++; |
| 190 | } |
| 191 | curs(cx, cy); |
| 192 | } |
| 193 | } |
| 194 | |
| 195 | clear_screen() { |
| 196 | xputs(CL); |
| 197 | curx = cury = 1; |
| 198 | } |
| 199 | |
| 200 | home() |
| 201 | { |
| 202 | if(HO) |
| 203 | xputs(HO); |
| 204 | else if(CM) |
| 205 | xputs(tgoto(CM, 0, 0)); |
| 206 | else |
| 207 | curs(1, 1); /* using UP ... */ |
| 208 | curx = cury = 1; |
| 209 | } |
| 210 | |
| 211 | standoutbeg() |
| 212 | { |
| 213 | if(SO) xputs(SO); |
| 214 | } |
| 215 | |
| 216 | standoutend() |
| 217 | { |
| 218 | if(SE) xputs(SE); |
| 219 | } |
| 220 | |
| 221 | backsp() |
| 222 | { |
| 223 | xputs(BC); |
| 224 | curx--; |
| 225 | } |
| 226 | |
| 227 | bell() |
| 228 | { |
| 229 | (void) putchar('\007'); /* curx does not change */ |
| 230 | (void) fflush(stdout); |
| 231 | } |
| 232 | |
| 233 | static short tmspc10[] = { /* from termcap */ |
| 234 | 0, 2000, 1333, 909, 743, 666, 500, 333, 166, 83, 55, 41, 20, 10, 5 |
| 235 | }; |
| 236 | |
| 237 | delay_output() { |
| 238 | /* delay 50 ms - could also use a 'nap'-system call */ |
| 239 | /* BUG: if the padding character is visible, as it is on the 5620 |
| 240 | then this looks terrible. */ |
| 241 | if(!flags.nonull) |
| 242 | tputs("50", 1, xputc); |
| 243 | |
| 244 | /* cbosgd!cbcephus!pds for SYS V R2 */ |
| 245 | /* is this terminfo, or what? */ |
| 246 | /* tputs("$<50>", 1, xputc); */ |
| 247 | |
| 248 | else if(ospeed > 0 || ospeed < SIZE(tmspc10)) if(CM) { |
| 249 | /* delay by sending cm(here) an appropriate number of times */ |
| 250 | register int cmlen = strlen(tgoto(CM, curx-1, cury-1)); |
| 251 | register int i = 500 + tmspc10[ospeed]/2; |
| 252 | |
| 253 | while(i > 0) { |
| 254 | cmov(curx, cury); |
| 255 | i -= cmlen*tmspc10[ospeed]; |
| 256 | } |
| 257 | } |
| 258 | } |
| 259 | |
| 260 | cl_eos() /* free after Robert Viduya */ |
| 261 | { /* must only be called with curx = 1 */ |
| 262 | |
| 263 | if(CD) |
| 264 | xputs(CD); |
| 265 | else { |
| 266 | register int cx = curx, cy = cury; |
| 267 | while(cury <= LI-2) { |
| 268 | cl_end(); |
| 269 | xputc('\n'); |
| 270 | curx = 1; |
| 271 | cury++; |
| 272 | } |
| 273 | cl_end(); |
| 274 | curs(cx, cy); |
| 275 | } |
| 276 | } |