?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Pre-2.0 release, MFC some driver fixes related to interrupt management.
[dragonfly.git] / usr.bin / ee / new_curse.c
blob651ef1c947d43f90f6397d04b8b6b894b778ed9d
1 /*
2 | new_curse.c
3 |
4 | A subset of curses developed for use with ae.
5 |
6 | written by Hugh Mahon
7 |
8 | THIS MATERIAL IS PROVIDED "AS IS". THERE ARE
9 | NO WARRANTIES OF ANY KIND WITH REGARD TO THIS
10 | MATERIAL, INCLUDING, BUT NOT LIMITED TO, THE
11 | IMPLIED WARRANTIES OF MERCHANTABILITY AND
12 | FITNESS FOR A PARTICULAR PURPOSE. Neither
13 | Hewlett-Packard nor Hugh Mahon shall be liable
14 | for errors contained herein, nor for
15 | incidental or consequential damages in
16 | connection with the furnishing, performance or
17 | use of this material. Neither Hewlett-Packard
18 | nor Hugh Mahon assumes any responsibility for
19 | the use or reliability of this software or
20 | documentation. This software and
21 | documentation is totally UNSUPPORTED. There
22 | is no support contract available. Hewlett-
23 | Packard has done NO Quality Assurance on ANY
24 | of the program or documentation. You may find
25 | the quality of the materials inferior to
26 | supported materials.
27 |
28 | This software is not a product of Hewlett-Packard, Co., or any
29 | other company. No support is implied or offered with this software.
30 | You've got the source, and you're on your own.
31 |
32 | This software may be distributed under the terms of Larry Wall's
33 | Artistic license, a copy of which is included in this distribution.
34 |
35 | This notice must be included with this software and any derivatives.
36 |
37 | Copyright (c) 1986, 1987, 1988, 1991, 1992, 1993, 1994, 1995 Hugh Mahon
38 | All are rights reserved.
39 |
40 | $FreeBSD: src/usr.bin/ee/new_curse.c,v 1.4.2.1 2001/06/10 11:06:06 sobomax Exp $
41 | $DragonFly: src/usr.bin/ee/new_curse.c,v 1.4 2005/10/30 23:00:57 swildner Exp $
42 |
43 */
44
45 char *copyright_message[] = { "Copyright (c) 1986, 1987, 1988, 1991, 1992, 1993, 1994, 1995 Hugh Mahon",
46 "All rights are reserved."};
47
48 char * new_curse_name= "@(#) new_curse.c $FreeBSD: src/usr.bin/ee/new_curse.c,v 1.4.2.1 2001/06/10 11:06:06 sobomax Exp $";
49
50 #include "new_curse.h"
51 #include <signal.h>
52 #include <fcntl.h>
53
54 #ifdef SYS5
55 #include <string.h>
56 #else
57 #include <strings.h>
58 #endif
59
60 #ifdef BSD_SELECT
61 #include <sys/types.h>
62 #include <sys/time.h>
63
64 #ifdef SLCT_HDR
65 #include <sys/select.h> /* on AIX */
66 #endif /* SLCT_HDR */
67
68 #endif /* BSD_SELECT */
69
70 #ifdef HAS_STDLIB
71 #include <stdlib.h>
72 #endif
73
74 #if defined(__STDC__)
75 #include <stdarg.h>
76 #else
77 #include <varargs.h>
78 #endif
79
80 #ifdef HAS_UNISTD
81 #include <unistd.h>
82 #endif
83
84 #ifdef HAS_SYS_IOCTL
85 #include <sys/ioctl.h>
86 #endif
87
88
89 WINDOW *curscr;
90 static WINDOW *virtual_scr;
91 WINDOW *stdscr;
92 WINDOW *last_window_refreshed;
93
94 #ifdef TIOCGWINSZ
95 struct winsize ws;
96 #endif
97
98 #define min(a, b) (a < b ? a : b)
99 #define highbitset(a) ((a) & 0x80)
100
101 #ifndef CAP
102 #define String_Out(table, stack, place) Info_Out(table, stack, place)
103 #else
104 #define String_Out(table, stack, place) Cap_Out(table, stack, place)
105 #endif
106
107 #define bw__ 0 /* booleans */
108 #define am__ 1
109 #define xb__ 2
110 #define xs__ 3 /* hp glitch (standout not erased by overwrite) */
111 #define xn__ 4
112 #define eo__ 5
113 #define gn__ 6 /* generic type terminal */
114 #define hc__ 7 /* hardcopy terminal */
115 #define km__ 8
116 #define hs__ 9
117 #define in__ 10
118 #define da__ 11
119 #define db__ 12
120 #define mi__ 13 /* safe to move during insert mode */
121 #define ms__ 14 /* safe to move during standout mode */
122 #define os__ 15
123 #define es__ 16
124 #define xt__ 17
125 #define hz__ 18 /* hazeltine glitch */
126 #define ul__ 19
127 #define xo__ 20
128 #define chts__ 21
129 #define nxon__ 22
130 #define nrrmc__ 23
131 #define npc__ 24
132 #define mc5i__ 25
133
134 #define co__ 0 /* number of columns */ /* numbers */
135 #define it__ 1 /* spaces per tab */
136 #define li__ 2 /* number of lines */
137 #define lm__ 3
138 #define sg__ 4 /* magic cookie glitch */
139 #define pb__ 5
140 #define vt__ 6
141 #define ws__ 7
142
143 #define cols__ 0
144 #define lines__ 2
145 #define xmc__ 4
146 #define vt__ 6
147 #define wsl__ 7
148 #define nlab__ 8
149 #define lh__ 9
150 #define lw__ 10
151
152 #define bt__ 0 /* back tab */ /* strings */
153 #define bl__ 1 /* bell */
154 #define cr__ 2 /* carriage return */
155 #define cs__ 3 /* change scroll region */
156 #define ct__ 4 /* clear all tab stops */
157 #define cl__ 5 /* clear screen and home cursor */
158 #define ce__ 6 /* clear to end of line */
159 #define cd__ 7 /* clear to end of display */
160 #define ch__ 8 /* set cursor column */
161 #define CC__ 9 /* term, settable cmd char in */
162 #define cm__ 10 /* screen rel cursor motion, row, column */
163 #define do__ 11 /* down one line */
164 #define ho__ 12 /* home cursor */
165 #define vi__ 13 /* make cursor invisible */
166 #define le__ 14 /* move cursor left one space */
167 #define CM__ 15 /* memory rel cursor addressing */
168 #define ve__ 16 /* make cursor appear normal */
169 #define nd__ 17 /* non-destructive space (cursor right) */
170 #define ll__ 18 /* last line, first col */
171 #define up__ 19 /* cursor up */
172 #define vs__ 20
173 #define dc__ 21 /* delete character */
174 #define dl__ 22 /* delete line */
175 #define ds__ 23
176 #define hd__ 24
177 #define as__ 25
178 #define mb__ 26
179 #define md__ 27 /* turn on bold */
180 #define ti__ 28
181 #define dm__ 29 /* turn on delete mode */
182 #define mh__ 30 /* half bright mode */
183 #define im__ 31 /* insert mode */
184 #define mk__ 32
185 #define mp__ 33
186 #define mr__ 34
187 #define so__ 35 /* enter standout mode */
188 #define us__ 36
189 #define ec__ 37
190 #define ae__ 38
191 #define me__ 39
192 #define te__ 40
193 #define ed__ 41
194 #define ei__ 42 /* exit insert mode */
195 #define se__ 43 /* exit standout mode */
196 #define ue__ 44
197 #define vb__ 45
198 #define ff__ 46
199 #define fs__ 47
200 #define i1__ 48
201 #define i2__ 49
202 #define i3__ 50
203 #define if__ 51
204 #define ic__ 52
205 #define al__ 53
206 #define ip__ 54
207 #define kb__ 55 /* backspace key */
208 #define ka__ 56
209 #define kC__ 57
210 #define kt__ 58
211 #define kD__ 59
212 #define kL__ 60
213 #define kd__ 61
214 #define kM__ 62
215 #define kE__ 63
216 #define kS__ 64
217 #define k0__ 65
218 #define k1__ 66
219 #define kf10__ 67
220 #define k2__ 68
221 #define k3__ 69
222 #define k4__ 70
223 #define k5__ 71
224 #define k6__ 72
225 #define k7__ 73
226 #define k8__ 74
227 #define k9__ 75
228 #define kh__ 76
229 #define kI__ 77
230 #define kA__ 78
231 #define kl__ 79
232 #define kH__ 80
233 #define kN__ 81
234 #define kP__ 82
235 #define kr__ 83
236 #define kF__ 84
237 #define kR__ 85
238 #define kT__ 86
239 #define ku__ 87 /* key up */
240 #define ke__ 88
241 #define ks__ 89
242 #define l0__ 90
243 #define l1__ 91
244 #define la__ 92
245 #define l2__ 93
246 #define l3__ 94
247 #define l4__ 95
248 #define l5__ 96
249 #define l6__ 97
250 #define l7__ 98
251 #define l8__ 99
252 #define l9__ 100
253 #define mo__ 101
254 #define mm__ 102
255 #define nw__ 103
256 #define pc__ 104
257 #define DC__ 105
258 #define DL__ 106
259 #define DO__ 107
260 #define IC__ 118
261 #define SF__ 109
262 #define AL__ 110
263 #define LE__ 111
264 #define RI__ 112
265 #define SR__ 113
266 #define UP__ 114
267 #define pk__ 115
268 #define pl__ 116
269 #define px__ 117
270 #define ps__ 118
271 #define pf__ 119
272 #define po__ 120
273 #define rp__ 121
274 #define r1__ 122
275 #define r2__ 123
276 #define r3__ 124
277 #define rf__ 125
278 #define rc__ 126
279 #define cv__ 127
280 #define sc__ 128
281 #define sf__ 129
282 #define sr__ 130
283 #define sa__ 131 /* sgr */
284 #define st__ 132
285 #define wi__ 133
286 #define ta__ 134
287 #define ts__ 135
288 #define uc__ 136
289 #define hu__ 137
290 #define iP__ 138
291 #define K1__ 139
292 #define K2__ 140
293 #define K3__ 141
294 #define K4__ 142
295 #define K5__ 143
296 #define pO__ 144
297 #define ml__ 145
298 #define mu__ 146
299 #define rmp__ 145
300 #define acsc__ 146
301 #define pln__ 147
302 #define kcbt__ 148
303 #define smxon__ 149
304 #define rmxon__ 150
305 #define smam__ 151
306 #define rmam__ 152
307 #define xonc__ 153
308 #define xoffc__ 154
309 #define enacs__ 155
310 #define smln__ 156
311 #define rmln__ 157
312 #define kbeg__ 158
313 #define kcan__ 159
314 #define kclo__ 160
315 #define kcmd__ 161
316 #define kcpy__ 162
317 #define kcrt__ 163
318 #define kend__ 164
319 #define kent__ 165
320 #define kext__ 166
321 #define kfnd__ 167
322 #define khlp__ 168
323 #define kmrk__ 169
324 #define kmsg__ 170
325 #define kmov__ 171
326 #define knxt__ 172
327 #define kopn__ 173
328 #define kopt__ 174
329 #define kprv__ 175
330 #define kprt__ 176
331 #define krdo__ 177
332 #define kref__ 178
333 #define krfr__ 179
334 #define krpl__ 180
335 #define krst__ 181
336 #define kres__ 182
337 #define ksav__ 183
338 #define kspd__ 184
339 #define kund__ 185
340 #define kBEG__ 186
341 #define kCAN__ 187
342 #define kCMD__ 188
343 #define kCPY__ 189
344 #define kCRT__ 190
345 #define kDC__ 191
346 #define kDL__ 192
347 #define kslt__ 193
348 #define kEND__ 194
349 #define kEOL__ 195
350 #define kEXT__ 196
351 #define kFND__ 197
352 #define kHLP__ 198
353 #define kHOM__ 199
354 #define kIC__ 200
355 #define kLFT__ 201
356 #define kMSG__ 202
357 #define kMOV__ 203
358 #define kNXT__ 204
359 #define kOPT__ 205
360 #define kPRV__ 206
361 #define kPRT__ 207
362 #define kRDO__ 208
363 #define kRPL__ 209
364 #define kRIT__ 210
365 #define kRES__ 211
366 #define kSAV__ 212
367 #define kSPD__ 213
368 #define kUND__ 214
369 #define rfi__ 215
370 #define kf11__ 216
371 #define kf12__ 217
372 #define kf13__ 218
373 #define kf14__ 219
374 #define kf15__ 220
375 #define kf16__ 221
376 #define kf17__ 222
377 #define kf18__ 223
378 #define kf19__ 224
379 #define kf20__ 225
380 #define kf21__ 226
381 #define kf22__ 227
382 #define kf23__ 228
383 #define kf24__ 229
384 #define kf25__ 230
385 #define kf26__ 231
386 #define kf27__ 232
387 #define kf28__ 233
388 #define kf29__ 234
389 #define kf30__ 235
390 #define kf31__ 236
391 #define kf32__ 237
392 #define kf33__ 238
393 #define kf34__ 239
394 #define kf35__ 240
395 #define kf36__ 241
396 #define kf37__ 242
397 #define kf38__ 243
398 #define kf39__ 244
399 #define kf40__ 245
400 #define kf41__ 246
401 #define kf42__ 247
402 #define kf43__ 248
403 #define kf44__ 249
404 #define kf45__ 250
405 #define kf46__ 251
406 #define kf47__ 252
407 #define kf48__ 253
408 #define kf49__ 254
409 #define kf50__ 255
410 #define kf51__ 256
411 #define kf52__ 257
412 #define kf53__ 258
413 #define kf54__ 259
414 #define kf55__ 260
415 #define kf56__ 261
416 #define kf57__ 262
417 #define kf58__ 263
418 #define kf59__ 264
419 #define kf60__ 265
420 #define kf61__ 266
421 #define kf62__ 267
422 #define kf63__ 268
423 #define el1__ 269
424 #define mgc__ 270
425 #define smgl__ 271
426 #define smgr__ 272
427
428 #ifdef CAP
429 char *Boolean_names[] = {
430 "bw", "am", "xb", "xs", "xn", "eo", "gn", "hc", "km", "hs", "in", "da", "db",
431 "mi", "ms", "os", "es", "xt", "hz", "ul", "xo", "HC", "nx", "NR", "NP", "5i"
432 };
433
434 char *Number_names[] = {
435 "co#", "it#", "li#", "lm#", "sg#", "pb#", "vt#", "ws#", "Nl#", "lh#", "lw#"
436 };
437
438 char *String_names[] = {
439 "bt=", "bl=", "cr=", "cs=", "ct=", "cl=", "ce=", "cd=", "ch=", "CC=", "cm=",
440 "do=", "ho=", "vi=", "le=", "CM=", "ve=", "nd=", "ll=", "up=", "vs=", "dc=",
441 "dl=", "ds=", "hd=", "as=", "mb=", "md=", "ti=", "dm=", "mh=", "im=", "mk=",
442 "mp=", "mr=", "so=", "us=", "ec=", "ae=", "me=", "te=", "ed=", "ei=", "se=",
443 "ue=", "vb=", "ff=", "fs=", "i1=", "i2=", "i3=", "if=", "ic=", "al=", "ip=",
444 "kb=", "ka=", "kC=", "kt=", "kD=", "kL=", "kd=", "kM=", "kE=", "kS=", "k0=",
445 "k1=", "k;=", "k2=", "k3=", "k4=", "k5=", "k6=", "k7=", "k8=", "k9=", "kh=",
446 "kI=", "kA=", "kl=", "kH=", "kN=", "kP=", "kr=", "kF=", "kR=", "kT=", "ku=",
447 "ke=", "ks=", "l0=", "l1=", "la=", "l2=", "l3=", "l4=", "l5=", "l6=", "l7=",
448 "l8=", "l9=", "mo=", "mm=", "nw=", "pc=", "DC=", "DL=", "DO=", "IC=", "SF=",
449 "AL=", "LE=", "RI=", "SR=", "UP=", "pk=", "pl=", "px=", "ps=", "pf=", "po=",
450 "rp=", "r1=", "r2=", "r3=", "rf=", "rc=", "cv=", "sc=", "sf=", "sr=", "sa=",
451 "st=", "wi=", "ta=", "ts=", "uc=", "hu=", "iP=", "K1=", "K3=", "K2=", "K4=",
452 "K5=", "pO=", "rP=", "ac=", "pn=", "kB=", "SX=", "RX=", "SA=", "RA=", "XN=",
453 "XF=", "eA=", "LO=", "LF=", "@1=", "@2=", "@3=", "@4=", "@5=", "@6=", "@7=",
454 "@8=", "@9=", "@0=", "%1=", "%2=", "%3=", "%4=", "%5=", "%6=", "%7=", "%8=",
455 "%9=", "%0=", "&1=", "&2=", "&3=", "&4=", "&5=", "&6=", "&7=", "&8=", "&9=",
456 "&0=", "*1=", "*2=", "*3=", "*4=", "*5=", "*6=", "*7=", "*8=", "*9=", "*0=",
457 "#1=", "#2=", "#3=", "#4=", "%a=", "%b=", "%c=", "%d=", "%e=", "%f=", "%g=",
458 "%h=", "%i=", "%j=", "!1=", "!2=", "!3=", "RF=", "F1=", "F2=", "F3=", "F4=",
459 "F5=", "F6=", "F7=", "F8=", "F9=", "FA=", "FB=", "FC=", "FD=", "FE=", "FF=",
460 "FG=", "FH=", "FI=", "FJ=", "FK=", "FL=", "FM=", "FN=", "FO=", "FP=", "FQ=",
461 "FR=", "FS=", "FT=", "FU=", "FV=", "FW=", "FX=", "FY=", "FZ=", "Fa=", "Fb=",
462 "Fc=", "Fd=", "Fe=", "Ff=", "Fg=", "Fh=", "Fi=", "Fj=", "Fk=", "Fl=", "Fm=",
463 "Fn=", "Fo=", "Fp=", "Fq=", "Fr=", "cb=", "MC=", "ML=", "MR="
464 };
465 #endif
466
467 char *new_curse = "October 1987";
468
469 char in_buff[100]; /* buffer for ungetch */
470 int bufp; /* next free position in in_buff */
471
472 char *TERMINAL_TYPE = NULL; /* terminal type to be gotten from environment */
473 int CFOUND = FALSE;
474 int Data_Line_len = 0;
475 int Max_Key_len; /* max length of a sequence sent by a key */
476 char *Data_Line = NULL;
477 char *TERM_PATH = NULL;
478 char *TERM_data_ptr = NULL;
479 char *Term_File_name = NULL; /* name of file containing terminal description */
480 FILE *TFP; /* file pointer to file with terminal des. */
481 int Fildes; /* file descriptor for terminfo file */
482 int STAND = FALSE; /* is standout mode activated? */
483 int TERM_INFO = FALSE; /* is terminfo being used (TRUE), or termcap (FALSE) */
484 int Time_Out; /* set when time elapsed while trying to read function key */
485 int Curr_x; /* current x position on screen */
486 int Curr_y; /* current y position on the screen */
487 int LINES;
488 int COLS;
489 int Move_It; /* flag to move cursor if magic cookie glitch */
490 int initialized = FALSE; /* tells whether new_curse is initialized */
491 float speed;
492 float chars_per_millisecond;
493 int Repaint_screen; /* if an operation to change screen impossible, repaint screen */
494 int Intr; /* storeage for interrupt character */
495 int Parity; /* 0 = no parity, 1 = odd parity, 2 = even parity */
496 int Noblock; /* for BSD systems */
497 int Num_bits; /* number of bits per character */
498 int Flip_Bytes; /* some systems have byte order reversed */
499 int interrupt_flag = FALSE; /* set true if SIGWINCH received */
500
501 #ifndef CAP
502 char *Strings;
503 #endif
504
505 struct KEYS {
506 int length; /* length of string sent by key */
507 char *string; /* string sent by key */
508 int value; /* CURSES value of key (9-bit) */
509 };
510
511 struct KEY_STACK {
512 struct KEYS *element;
513 struct KEY_STACK *next;
514 };
515
516 struct KEY_STACK *KEY_TOS = NULL;
517 struct KEY_STACK *KEY_POINT;
518
519 /*
520 |
521 | Not all systems have good terminal information, so we will define
522 | keyboard information here for the most widely used terminal type,
523 | the VT100.
524 |
525 */
526
527 struct KEYS vt100[] =
528 {
529 { 3, "\033[A", 0403 }, /* key up */
530 { 3, "\033[C", 0405 }, /* key right */
531 { 3, "\033[D", 0404 }, /* key left */
532
533 { 4, "\033[6~", 0522 }, /* key next page */
534 { 4, "\033[5~", 0523 }, /* key prev page */
535 { 3, "\033[[", 0550 }, /* key end */
536 { 3, "\033[@", 0406 }, /* key home */
537 { 4, "\033[2~", 0513 }, /* key insert char */
538
539 { 3, "\033[y", 0410 }, /* key F0 */
540 { 3, "\033[P", 0411 }, /* key F1 */
541 { 3, "\033[Q", 0412 }, /* key F2 */
542 { 3, "\033[R", 0413 }, /* key F3 */
543 { 3, "\033[S", 0414 }, /* key F4 */
544 { 3, "\033[t", 0415 }, /* key F5 */
545 { 3, "\033[u", 0416 }, /* key F6 */
546 { 3, "\033[v", 0417 }, /* key F7 */
547 { 3, "\033[l", 0420 }, /* key F8 */
548 { 3, "\033[w", 0421 }, /* key F9 */
549 { 3, "\033[x", 0422 }, /* key F10 */
550
551 { 5, "\033[10~", 0410 }, /* key F0 */
552 { 5, "\033[11~", 0411 }, /* key F1 */
553 { 5, "\033[12~", 0412 }, /* key F2 */
554 { 5, "\033[13~", 0413 }, /* key F3 */
555 { 5, "\033[14~", 0414 }, /* key F4 */
556 { 5, "\033[15~", 0415 }, /* key F5 */
557 { 5, "\033[17~", 0416 }, /* key F6 */
558 { 5, "\033[18~", 0417 }, /* key F7 */
559 { 5, "\033[19~", 0420 }, /* key F8 */
560 { 5, "\033[20~", 0421 }, /* key F9 */
561 { 5, "\033[21~", 0422 }, /* key F10 */
562 { 5, "\033[23~", 0423 }, /* key F11 */
563 { 5, "\033[24~", 0424 }, /* key F12 */
564 { 3, "\033[q", 0534 }, /* ka1 upper-left of keypad */
565 { 3, "\033[s", 0535 }, /* ka3 upper-right of keypad */
566 { 3, "\033[r", 0536 }, /* kb2 center of keypad */
567 { 3, "\033[p", 0537 }, /* kc1 lower-left of keypad */
568 { 3, "\033[n", 0540 }, /* kc3 lower-right of keypad */
569
570 /*
571 | The following are the same keys as above, but with
572 | a different character following the escape char.
573 */
574
575 { 3, "\033OA", 0403 }, /* key up */
576 { 3, "\033OC", 0405 }, /* key right */
577 { 3, "\033OD", 0404 }, /* key left */
578 { 3, "\033OB", 0402 }, /* key down */
579 { 4, "\033O6~", 0522 }, /* key next page */
580 { 4, "\033O5~", 0523 }, /* key prev page */
581 { 3, "\033O[", 0550 }, /* key end */
582 { 3, "\033O@", 0406 }, /* key home */
583 { 4, "\033O2~", 0513 }, /* key insert char */
584
585 { 3, "\033Oy", 0410 }, /* key F0 */
586 { 3, "\033OP", 0411 }, /* key F1 */
587 { 3, "\033OQ", 0412 }, /* key F2 */
588 { 3, "\033OR", 0413 }, /* key F3 */
589 { 3, "\033OS", 0414 }, /* key F4 */
590 { 3, "\033Ot", 0415 }, /* key F5 */
591 { 3, "\033Ou", 0416 }, /* key F6 */
592 { 3, "\033Ov", 0417 }, /* key F7 */
593 { 3, "\033Ol", 0420 }, /* key F8 */
594 { 3, "\033Ow", 0421 }, /* key F9 */
595 { 3, "\033Ox", 0422 }, /* key F10 */
596
597 { 5, "\033O10~", 0410 }, /* key F0 */
598 { 5, "\033O11~", 0411 }, /* key F1 */
599 { 5, "\033O12~", 0412 }, /* key F2 */
600 { 5, "\033O13~", 0413 }, /* key F3 */
601 { 5, "\033O14~", 0414 }, /* key F4 */
602 { 5, "\033O15~", 0415 }, /* key F5 */
603 { 5, "\033O17~", 0416 }, /* key F6 */
604 { 5, "\033O18~", 0417 }, /* key F7 */
605 { 5, "\033O19~", 0420 }, /* key F8 */
606 { 5, "\033O20~", 0421 }, /* key F9 */
607 { 5, "\033O21~", 0422 }, /* key F10 */
608 { 5, "\033O23~", 0423 }, /* key F11 */
609 { 5, "\033O24~", 0424 }, /* key F12 */
610 { 3, "\033Oq", 0534 }, /* ka1 upper-left of keypad */
611 { 3, "\033Os", 0535 }, /* ka3 upper-right of keypad */
612 { 3, "\033Or", 0536 }, /* kb2 center of keypad */
613 { 3, "\033Op", 0537 }, /* kc1 lower-left of keypad */
614 { 3, "\033On", 0540 }, /* kc3 lower-right of keypad */
615
616 { 0, "", 0 } /* end */
617 };
618
619 struct Parameters {
620 int value;
621 struct Parameters *next;
622 };
623
624 int Key_vals[] = {
625 0407, 0526, 0515, 0525, 0512, 0510, 0402, 0514, 0517, 0516, 0410, 0411,
626 0422, 0412, 0413, 0414, 0415, 0416, 0417, 0420, 0421, 0406, 0513, 0511,
627 0404, 0533, 0522, 0523, 0405, 0520, 0521, 0524, 0403,
628 0534, 0535, 0536, 0537, 0540, 0541, 0542, 0543, 0544, 0545, 0546, 0547,
629 0550, 0527, 0551, 0552, 0553, 0554, 0555, 0556, 0557, 0560, 0561, 0562,
630 0532, 0563, 0564, 0565, 0566, 0567, 0570, 0571, 0627, 0630, 0572, 0573,
631 0574, 0575, 0576, 0577, 0600, 0601, 0602, 0603, 0604, 0605, 0606, 0607,
632 0610, 0611, 0612, 0613, 0614, 0615, 0616, 0617, 0620, 0621, 0622, 0623,
633 0624, 0625, 0626, 0423, 0424, 0425, 0426, 0427, 0430, 0431,
634 0432, 0433, 0434, 0435, 0436, 0437, 0440, 0441, 0442, 0443, 0444, 0445,
635 0446, 0447, 0450, 0451, 0452, 0453, 0454, 0455, 0456, 0457, 0460, 0461,
636 0462, 0463, 0464, 0465, 0466, 0467, 0470, 0471, 0472, 0473, 0474, 0475,
637 0476, 0477, 0500, 0501, 0502, 0503, 0504, 0505, 0506, 0507
638 };
639
640 int attributes_set[9];
641
642 static int nc_attributes = 0; /* global attributes for new_curse to observe */
643
644 #ifdef SYS5
645 struct termio Terminal;
646 struct termio Saved_tty;
647 #else
648 struct sgttyb Terminal;
649 struct sgttyb Saved_tty;
650 #endif
651
652 char *tc_;
653
654 int Booleans[128];
655 int Numbers[128];
656 char *String_table[1024];
657
658 int *virtual_lines;
659
660 static char nc_scrolling_ability = FALSE;
661
662 #ifdef CAP
663
664 #if __STDC__ || defined(__cplusplus)
665 #define P_(s) s
666 #else
667 #define P_(s) ()
668 #endif /* __STDC__ */
669
670 int tc_Get_int P_((int));
671 void CAP_PARSE P_((void));
672 void Find_term P_((void));
673
674 #undef P_
675
676 #endif /* CAP */
677
678
679 #ifndef __STDC__
680 #ifndef HAS_STDLIB
681 extern char *fgets();
682 extern char *malloc();
683 extern char *getenv();
684 FILE *fopen(); /* declaration for open function */
685 #endif /* HAS_STDLIB */
686 #endif /* __STDC__ */
687
688 #ifdef SIGWINCH
689
690 /*
691 | Copy the contents of one window to another.
692 */
693
694 void
695 copy_window(WINDOW *origin, WINDOW *destination)
696 {
697 int row, column;
698 struct _line *orig, *dest;
699
700 orig = origin->first_line;
701 dest = destination->first_line;
702
703 for (row = 0;
704 row < (min(origin->Num_lines, destination->Num_lines));
705 row++)
706 {
707 for (column = 0;
708 column < (min(origin->Num_cols, destination->Num_cols));
709 column++)
710 {
711 dest->row[column] = orig->row[column];
712 dest->attributes[column] = orig->attributes[column];
713 }
714 dest->changed = orig->changed;
715 dest->scroll = orig->scroll;
716 dest->last_char = min(orig->last_char, destination->Num_cols);
717 orig = orig->next_screen;
718 dest = dest->next_screen;
719 }
720 destination->LX = min((destination->Num_cols - 1), origin->LX);
721 destination->LY = min((destination->Num_lines - 1), origin->LY);
722 destination->Attrib = origin->Attrib;
723 destination->scroll_up = origin->scroll_up;
724 destination->scroll_down = origin->scroll_down;
725 destination->SCROLL_CLEAR = origin->SCROLL_CLEAR;
726 }
727
728 void
729 reinitscr(int foo)
730 {
731 WINDOW *local_virt;
732 WINDOW *local_std;
733 WINDOW *local_cur;
734
735 signal(SIGWINCH, reinitscr);
736 #ifdef TIOCGWINSZ
737 if (ioctl(0, TIOCGWINSZ, &ws) >= 0)
738 {
739 if (ws.ws_row == LINES && ws.ws_col == COLS)
740 return;
741 if (ws.ws_row > 0)
742 LINES = ws.ws_row;
743 if (ws.ws_col > 0)
744 COLS = ws.ws_col;
745 }
746 #endif /* TIOCGWINSZ */
747 local_virt = newwin(LINES, COLS, 0, 0);
748 local_std = newwin(LINES, COLS, 0, 0);
749 local_cur = newwin(LINES, COLS, 0, 0);
750 copy_window(virtual_scr, local_virt);
751 copy_window(stdscr, local_std);
752 copy_window(curscr, local_cur);
753 delwin(virtual_scr);
754 delwin(stdscr);
755 delwin(curscr);
756 virtual_scr = local_virt;
757 stdscr = local_std;
758 curscr = local_cur;
759 free(virtual_lines);
760 virtual_lines = (int *) malloc(LINES * (sizeof(int)));
761 interrupt_flag = TRUE;
762 }
763 #endif /* SIGWINCH */
764
765 void
766 initscr(void) /* initialize terminal for operations */
767 {
768 int value;
769 char *lines_string;
770 char *columns_string;
771 #ifdef CAP
772 char *pointer;
773 #endif /* CAP */
774
775 #ifdef DIAG
776 printf("starting initscr \n");fflush(stdout);
777 #endif
778 if (initialized)
779 return;
780 #ifdef BSD_SELECT
781 setbuf(stdin, NULL);
782 #endif /* BSD_SELECT */
783 Flip_Bytes = FALSE;
784 Parity = 0;
785 Time_Out = FALSE;
786 bufp = 0;
787 Move_It = FALSE;
788 Noblock = FALSE;
789 #ifdef SYS5
790 value = ioctl(0, TCGETA, &Terminal);
791 if (Terminal.c_cflag & PARENB)
792 {
793 if (Terminal.c_cflag & PARENB)
794 Parity = 1;
795 else
796 Parity = 2;
797 }
798 if ((Terminal.c_cflag & CS8) == CS8)
799 {
800 Num_bits = 8;
801 }
802 else if ((Terminal.c_cflag & CS7) == CS7)
803 Num_bits = 7;
804 else if ((Terminal.c_cflag & CS6) == CS6)
805 Num_bits = 6;
806 else
807 Num_bits = 5;
808 value = Terminal.c_cflag & 037;
809 switch (value) {
810 case 01: speed = 50.0;
811 break;
812 case 02: speed = 75.0;
813 break;
814 case 03: speed = 110.0;
815 break;
816 case 04: speed = 134.5;
817 break;
818 case 05: speed = 150.0;
819 break;
820 case 06: speed = 200.0;
821 break;
822 case 07: speed = 300.0;
823 break;
824 case 010: speed = 600.0;
825 break;
826 case 011: speed = 900.0;
827 break;
828 case 012: speed = 1200.0;
829 break;
830 case 013: speed = 1800.0;
831 break;
832 case 014: speed = 2400.0;
833 break;
834 case 015: speed = 3600.0;
835 break;
836 case 016: speed = 4800.0;
837 break;
838 case 017: speed = 7200.0;
839 break;
840 case 020: speed = 9600.0;
841 break;
842 case 021: speed = 19200.0;
843 break;
844 case 022: speed = 38400.0;
845 break;
846 default: speed = 0.0;
847 }
848 #else
849 value = ioctl(0, TIOCGETP, &Terminal);
850 if (Terminal.sg_flags & EVENP)
851 Parity = 2;
852 else if (Terminal.sg_flags & ODDP)
853 Parity = 1;
854 value = Terminal.sg_ospeed;
855 switch (value) {
856 case 01: speed = 50.0;
857 break;
858 case 02: speed = 75.0;
859 break;
860 case 03: speed = 110.0;
861 break;
862 case 04: speed = 134.5;
863 break;
864 case 05: speed = 150.0;
865 break;
866 case 06: speed = 200.0;
867 break;
868 case 07: speed = 300.0;
869 break;
870 case 010: speed = 600.0;
871 break;
872 case 011: speed = 1200.0;
873 break;
874 case 012: speed = 1800.0;
875 break;
876 case 013: speed = 2400.0;
877 break;
878 case 014: speed = 4800.0;
879 break;
880 case 015: speed = 9600.0;
881 break;
882 default: speed = 0.0;
883 }
884 #endif
885 chars_per_millisecond = (0.001 * speed) / 8.0;
886 TERMINAL_TYPE = getenv("TERM");
887 if (TERMINAL_TYPE == NULL)
888 {
889 printf("unknown terminal type\n");
890 exit(0);
891 }
892 #ifndef CAP
893 Fildes = -1;
894 TERM_PATH = getenv("TERMINFO");
895 if (TERM_PATH != NULL)
896 {
897 Data_Line_len = 23 + strlen(TERM_PATH) + strlen(TERMINAL_TYPE);
898 Term_File_name = malloc(Data_Line_len);
899 sprintf(Term_File_name, "%s/%c/%s", TERM_PATH, *TERMINAL_TYPE, TERMINAL_TYPE);
900 Fildes = open(Term_File_name, O_RDONLY);
901 }
902 if (Fildes == -1)
903 {
904 TERM_PATH = "/usr/lib/terminfo";
905 Data_Line_len = 23 + strlen(TERM_PATH) + strlen(TERMINAL_TYPE);
906 Term_File_name = malloc(Data_Line_len);
907 sprintf(Term_File_name, "%s/%c/%s", TERM_PATH, *TERMINAL_TYPE, TERMINAL_TYPE);
908 Fildes = open(Term_File_name, O_RDONLY);
909 }
910 if (Fildes == -1)
911 {
912 TERM_PATH = "/usr/share/lib/terminfo";
913 Data_Line_len = 23 + strlen(TERM_PATH) + strlen(TERMINAL_TYPE);
914 Term_File_name = malloc(Data_Line_len);
915 sprintf(Term_File_name, "%s/%c/%s", TERM_PATH, *TERMINAL_TYPE, TERMINAL_TYPE);
916 Fildes = open(Term_File_name, O_RDONLY);
917 }
918 if (Fildes == -1)
919 {
920 TERM_PATH = "/usr/share/terminfo";
921 Data_Line_len = 23 + strlen(TERM_PATH) + strlen(TERMINAL_TYPE);
922 Term_File_name = malloc(Data_Line_len);
923 sprintf(Term_File_name, "%s/%c/%s", TERM_PATH, *TERMINAL_TYPE, TERMINAL_TYPE);
924 Fildes = open(Term_File_name, O_RDONLY);
925 }
926 if (Fildes == -1)
927 {
928 free(Term_File_name);
929 Term_File_name = NULL;
930 }
931 else
932 TERM_INFO = INFO_PARSE();
933 #else
934 /*
935 | termcap information can be in the TERMCAP env variable, if so
936 | use that, otherwise check the /etc/termcap file
937 */
938 if ((pointer = Term_File_name = getenv("TERMCAP")) != NULL)
939 {
940 if (*Term_File_name != '/')
941 Term_File_name = "/etc/termcap";
942 }
943 else
944 {
945 Term_File_name = "/etc/termcap";
946 }
947 if ((TFP = fopen(Term_File_name, "r")) == NULL)
948 {
949 printf("unable to open /etc/termcap file \n");
950 exit(0);
951 }
952 for (value = 0; value < 1024; value++)
953 String_table[value] = NULL;
954 for (value = 0; value < 128; value++)
955 Booleans[value] = 0;
956 for (value = 0; value < 128; value++)
957 Numbers[value] = 0;
958 Data_Line = malloc(512);
959 if (pointer && *pointer != '/')
960 {
961 TERM_data_ptr = pointer;
962 CAP_PARSE();
963 }
964 else
965 {
966 Find_term();
967 CAP_PARSE();
968 }
969 #endif
970 if (String_table[pc__] == NULL)
971 String_table[pc__] = "\0";
972 if ((String_table[cm__] == NULL) || (Booleans[hc__]))
973 {
974 fprintf(stderr, "sorry, unable to use this terminal type for screen editing\n");
975 exit(0);
976 }
977 Key_Get();
978 keys_vt100();
979 LINES = Numbers[li__];
980 COLS = Numbers[co__];
981 if ((lines_string = getenv("LINES")) != NULL)
982 {
983 value = atoi(lines_string);
984 if (value > 0)
985 LINES = value;
986 }
987 if ((columns_string = getenv("COLUMNS")) != NULL)
988 {
989 value = atoi(columns_string);
990 if (value > 0)
991 COLS = value;
992 }
993 #ifdef TIOCGWINSZ
994 /*
995 | get the window size
996 */
997 if (ioctl(0, TIOCGWINSZ, &ws) >= 0)
998 {
999 if (ws.ws_row > 0)
1000 LINES = ws.ws_row;
1001 if (ws.ws_col > 0)
1002 COLS = ws.ws_col;
1003 }
1004 #endif
1005 virtual_scr = newwin(LINES, COLS, 0, 0);
1006 stdscr = newwin(LINES, COLS, 0, 0);
1007 curscr = newwin(LINES, COLS, 0, 0);
1008 wmove(stdscr, 0, 0);
1009 werase(stdscr);
1010 Repaint_screen = TRUE;
1011 initialized = TRUE;
1012 virtual_lines = (int *) malloc(LINES * (sizeof(int)));
1013
1014 #ifdef SIGWINCH
1015 /*
1016 | reset size of windows and LINES and COLS if term window
1017 | changes size
1018 */
1019 signal(SIGWINCH, reinitscr);
1020 #endif /* SIGWINCH */
1021
1022 /*
1023 | check if scrolling is available
1024 */
1025
1026 nc_scrolling_ability = ((String_table[al__] != NULL) &&
1027 (String_table[dl__])) || ((String_table[cs__])
1028 && (String_table[sr__]));
1029
1030 }
1031
1032 #ifndef CAP
1033 int
1034 Get_int(void) /* get a two-byte integer from the terminfo file */
1035 {
1036 int High_byte;
1037 int Low_byte;
1038 int temp;
1039
1040 Low_byte = *((unsigned char *) TERM_data_ptr++);
1041 High_byte = *((unsigned char *) TERM_data_ptr++);
1042 if (Flip_Bytes)
1043 {
1044 temp = Low_byte;
1045 Low_byte = High_byte;
1046 High_byte = temp;
1047 }
1048 if ((High_byte == 255) && (Low_byte == 255))
1049 return (-1);
1050 else
1051 return(Low_byte + (High_byte * 256));
1052 }
1053
1054 int
1055 INFO_PARSE(void) /* parse off the data in the terminfo data file */
1056 {
1057 int offset;
1058 int magic_number = 0;
1059 int counter = 0;
1060 int Num_names = 0;
1061 int Num_bools = 0;
1062 int Num_ints = 0;
1063 int Num_strings = 0;
1064 int string_table_len = 0;
1065 char *temp_ptr;
1066
1067 TERM_data_ptr = Data_Line = malloc((10240 * (sizeof(char))));
1068 Data_Line_len = read(Fildes, Data_Line, 10240);
1069 if ((Data_Line_len >= 10240) || (Data_Line_len < 0))
1070 return(0);
1071 /*
1072 | get magic number
1073 */
1074 magic_number = Get_int();
1075 /*
1076 | if magic number not right, reverse byte order and check again
1077 */
1078 if (magic_number != 282)
1079 {
1080 Flip_Bytes = TRUE;
1081 TERM_data_ptr--;
1082 TERM_data_ptr--;
1083 magic_number = Get_int();
1084 if (magic_number != 282)
1085 return(0);
1086 }
1087 /*
1088 | get the number of each type in the terminfo data file
1089 */
1090 Num_names = Get_int();
1091 Num_bools = Get_int();
1092 Num_ints = Get_int();
1093 Num_strings = Get_int();
1094 string_table_len = Get_int();
1095 Strings = malloc(string_table_len);
1096 while (Num_names > 0)
1097 {
1098 TERM_data_ptr++;
1099 Num_names--;
1100 }
1101 counter = 0;
1102 while (Num_bools)
1103 {
1104 Num_bools--;
1105 Booleans[counter++] = *TERM_data_ptr++;
1106 }
1107 if (((unsigned int) TERM_data_ptr) & 1) /* force alignment */
1108 TERM_data_ptr++;
1109 counter = 0;
1110 while (Num_ints)
1111 {
1112 Num_ints--;
1113 Numbers[counter] = Get_int();
1114 counter++;
1115 }
1116 temp_ptr = TERM_data_ptr + Num_strings + Num_strings;
1117 memcpy(Strings, temp_ptr, string_table_len);
1118 counter = bt__;
1119 while (Num_strings)
1120 {
1121 Num_strings--;
1122 if ((offset=Get_int()) != -1)
1123 {
1124 if (String_table[counter] == NULL)
1125 String_table[counter] = Strings + offset;
1126 }
1127 else
1128 String_table[counter] = NULL;
1129 counter++;
1130 }
1131 close(Fildes);
1132 free(Data_Line);
1133 return(TRUE);
1134 }
1135 #endif /* ifndef CAP */
1136
1137 int
1138 AtoI(void) /* convert ascii text to integers */
1139 {
1140 int Temp;
1141
1142 Temp = 0;
1143 while ((*TERM_data_ptr >= '0') && (*TERM_data_ptr <= '9'))
1144 {
1145 Temp = (Temp * 10) + (*TERM_data_ptr - '0');
1146 TERM_data_ptr++;
1147 }
1148 return(Temp);
1149 }
1150
1151 void
1152 Key_Get(void) /* create linked list with all key sequences obtained from terminal database */
1153 {
1154 int Counter;
1155 int Klen;
1156 int key_def;
1157 struct KEY_STACK *Spoint;
1158
1159 Max_Key_len = 0;
1160 Counter = 0;
1161 key_def = kb__;
1162 while (key_def <= kf63__)
1163 {
1164 if (key_def == ke__)
1165 key_def = K1__;
1166 else if (key_def == (K5__ + 1))
1167 key_def = kcbt__;
1168 else if (key_def == (kcbt__ + 1))
1169 key_def = kbeg__;
1170 else if (key_def == (kUND__ + 1))
1171 key_def = kf11__;
1172 if (String_table[key_def] != NULL)
1173 {
1174 if (KEY_TOS == NULL)
1175 Spoint = KEY_TOS = (struct KEY_STACK *) malloc(sizeof(struct KEY_STACK));
1176 else
1177 {
1178 Spoint = KEY_TOS;
1179 while (Spoint->next != NULL)
1180 Spoint = Spoint->next;
1181 Spoint->next = (struct KEY_STACK *) malloc(sizeof(struct KEY_STACK));
1182 Spoint = Spoint->next;
1183 }
1184 Spoint->next = NULL;
1185 Spoint->element = (struct KEYS *) malloc(sizeof(struct KEYS));
1186 Spoint->element->string = String_table[key_def];
1187 Spoint->element->length = strlen(String_table[key_def]);
1188 Spoint->element->value = Key_vals[Counter];
1189 Klen = strlen(Spoint->element->string);
1190 if (Klen > Max_Key_len)
1191 Max_Key_len = Klen;
1192 /*
1193 | Some terminal types accept keystrokes of the form
1194 | \E[A and \EOA, substituting '[' for 'O'. Make a
1195 | duplicate of such key strings (since the
1196 | database will only have one version) so new_curse
1197 | can understand both.
1198 */
1199 if ((Spoint->element->length > 1) &&
1200 ((String_table[key_def][1] == '[') ||
1201 (String_table[key_def][1] == 'O')))
1202 {
1203 Spoint->next = (struct KEY_STACK *) malloc(sizeof(struct KEY_STACK));
1204 Spoint = Spoint->next;
1205 Spoint->next = NULL;
1206 Spoint->element = (struct KEYS *) malloc(sizeof(struct KEYS));
1207 Spoint->element->length = strlen(String_table[key_def]);
1208 Spoint->element->string = malloc(Spoint->element->length + 1);
1209 strcpy(Spoint->element->string, String_table[key_def]);
1210 Spoint->element->value = Key_vals[Counter];
1211 Klen = strlen(Spoint->element->string);
1212 if (Klen > Max_Key_len)
1213 Max_Key_len = Klen;
1214
1215 if (String_table[key_def][1] == '[')
1216 Spoint->element->string[1] = 'O';
1217 else
1218 Spoint->element->string[1] = '[';
1219 }
1220 }
1221 key_def++;
1222 Counter++;
1223 }
1224 }
1225
1226 /*
1227 | insert information about keys for a vt100 terminal
1228 */
1229
1230 void
1231 keys_vt100(void)
1232 {
1233 int counter;
1234 int Klen;
1235 struct KEY_STACK *Spoint;
1236
1237 Spoint = KEY_TOS;
1238 while (Spoint->next != NULL)
1239 Spoint = Spoint->next;
1240 for (counter = 0; vt100[counter].length != 0; counter++)
1241 {
1242 Spoint->next = (struct KEY_STACK *) malloc(sizeof(struct KEY_STACK));
1243 Spoint = Spoint->next;
1244 Spoint->next = NULL;
1245 Spoint->element = &vt100[counter];
1246 Klen = strlen(Spoint->element->string);
1247 if (Klen > Max_Key_len)
1248 Max_Key_len = Klen;
1249 }
1250 }
1251
1252 #ifdef CAP
1253 char *
1254 String_Get(char *param) /* read the string */
1255 {
1256 char *String;
1257 char *Temp;
1258 int Counter;
1259
1260 if (param == NULL)
1261 {
1262 while (*TERM_data_ptr != '=')
1263 TERM_data_ptr++;
1264 Temp = ++TERM_data_ptr;
1265 Counter = 1;
1266 while ((*Temp != ':') && (*Temp != (char)NULL))
1267 {
1268 Counter++;
1269 Temp++;
1270 }
1271 if (Counter == 1) /* no data */
1272 return(NULL);
1273 String = Temp = malloc(Counter);
1274 while ((*TERM_data_ptr != ':') && (*TERM_data_ptr != (char)NULL))
1275 {
1276 if (*TERM_data_ptr == '\\')
1277 {
1278 TERM_data_ptr++;
1279 if (*TERM_data_ptr == 'n')
1280 *Temp = '\n';
1281 else if (*TERM_data_ptr == 't')
1282 *Temp = '\t';
1283 else if (*TERM_data_ptr == 'b')
1284 *Temp = '\b';
1285 else if (*TERM_data_ptr == 'r')
1286 *Temp = '\r';
1287 else if (*TERM_data_ptr == 'f')
1288 *Temp = '\f';
1289 else if ((*TERM_data_ptr == 'e') || (*TERM_data_ptr == 'E'))
1290 *Temp = '\033'; /* escape */
1291 else if (*TERM_data_ptr == '\\')
1292 *Temp = '\\';
1293 else if (*TERM_data_ptr == '\'')
1294 *Temp = '\'';
1295 else if ((*TERM_data_ptr >= '0') && (*TERM_data_ptr <= '9'))
1296 {
1297 Counter = 0;
1298 while ((*TERM_data_ptr >= '0') && (*TERM_data_ptr <= '9'))
1299 {
1300 Counter = (8 * Counter) + (*TERM_data_ptr - '0');
1301 TERM_data_ptr++; /* ? */
1302 }
1303 *Temp = Counter;
1304 TERM_data_ptr--;
1305 }
1306 TERM_data_ptr++;
1307 Temp++;
1308 }
1309 else if (*TERM_data_ptr == '^')
1310 {
1311 TERM_data_ptr++;
1312 if ((*TERM_data_ptr >= '@') && (*TERM_data_ptr <= '_'))
1313 *Temp = *TERM_data_ptr - '@';
1314 else if (*TERM_data_ptr == '?')
1315 *Temp = 127;
1316 TERM_data_ptr++;
1317 Temp++;
1318 }
1319 else
1320 *Temp++ = *TERM_data_ptr++;
1321 }
1322 *Temp = (char)NULL;
1323 param = String;
1324 }
1325 else
1326 {
1327 while ((*TERM_data_ptr != (char)NULL) && (*TERM_data_ptr != ':'))
1328 TERM_data_ptr++;
1329 }
1330 return(param);
1331 }
1332
1333 int
1334 tc_Get_int(int param) /* read the integer */
1335 {
1336 int Itemp;
1337
1338 if (param == 0)
1339 {
1340 while ((*TERM_data_ptr != (char)NULL) && (*TERM_data_ptr != '#'))
1341 TERM_data_ptr++;
1342 TERM_data_ptr++;
1343 Itemp = AtoI();
1344 param = Itemp;
1345 }
1346 else
1347 {
1348 while (*TERM_data_ptr != ':')
1349 TERM_data_ptr++;
1350 }
1351 return(param);
1352 }
1353
1354 void
1355 Find_term(void) /* find terminal description in termcap file */
1356 {
1357 char *Name;
1358 char *Ftemp;
1359
1360 Ftemp = Name = malloc(strlen(TERMINAL_TYPE + 1) + 1);
1361 strcpy(Name, TERMINAL_TYPE);
1362 while (*Ftemp != (char)NULL)
1363 Ftemp++;
1364 *Ftemp++ = '|';
1365 *Ftemp = (char)NULL;
1366 CFOUND = FALSE;
1367 Data_Line_len = strlen(TERMINAL_TYPE) + 1;
1368 while ((!CFOUND) && ((TERM_data_ptr=fgets(Data_Line, 512, TFP)) != NULL))
1369 {
1370 if ((*TERM_data_ptr != ' ') && (*TERM_data_ptr != '\t') && (*TERM_data_ptr != '#'))
1371 {
1372 while ((!CFOUND) && (*TERM_data_ptr != (char)NULL))
1373 {
1374 CFOUND = !strncmp(TERM_data_ptr, Name, Data_Line_len);
1375 while ((*TERM_data_ptr != (char)NULL) && (*TERM_data_ptr != '|') && (*TERM_data_ptr != '#') && (*TERM_data_ptr != ':'))
1376 TERM_data_ptr++;
1377 if (*TERM_data_ptr == '|')
1378 TERM_data_ptr++;
1379 else if (!CFOUND)
1380 *TERM_data_ptr = (char)NULL;
1381 }
1382 }
1383 }
1384 if (!CFOUND)
1385 {
1386 printf("terminal type %s not found\n", TERMINAL_TYPE);
1387 exit(0);
1388 }
1389 }
1390
1391 void
1392 CAP_PARSE(void) /* parse off the data in the termcap data file */
1393 {
1394 int offset;
1395 int found;
1396
1397 do
1398 {
1399 while (*TERM_data_ptr != (char)NULL)
1400 {
1401 for (found = FALSE, offset = 0; (!found) && (offset < 26); offset++)
1402 {
1403 if (!strncmp(TERM_data_ptr, Boolean_names[offset], 2))
1404 {
1405 found = TRUE;
1406 Booleans[offset] = TRUE;
1407 }
1408 }
1409 if (!found)
1410 {
1411 for (found = FALSE, offset = 0; (!found) && (offset < lw__); offset++)
1412 {
1413 if (!strncmp(TERM_data_ptr, Number_names[offset], 3))
1414 {
1415 found = TRUE;
1416 Numbers[offset] = tc_Get_int(Numbers[offset]);
1417 }
1418 }
1419 }
1420 if (!found)
1421 {
1422 for (found = FALSE, offset = 0; (!found) && (offset < smgr__); offset++)
1423 {
1424 if (!strncmp(TERM_data_ptr, String_names[offset], 3))
1425 {
1426 found = TRUE;
1427 String_table[offset] = String_Get(String_table[offset]);
1428 }
1429 }
1430 }
1431
1432 if (!strncmp(TERM_data_ptr, "tc=", 3))
1433 tc_ = String_Get(NULL);
1434 while ((*TERM_data_ptr != ':') && (*TERM_data_ptr != (char)NULL))
1435 TERM_data_ptr++;
1436 if (*TERM_data_ptr == ':')
1437 TERM_data_ptr++;
1438 }
1439 } while (((TERM_data_ptr = fgets(Data_Line, 512, TFP)) != NULL) && ((*TERM_data_ptr == ' ') || (*TERM_data_ptr == '\t')));
1440 if (tc_ != NULL)
1441 {
1442 TERMINAL_TYPE = tc_;
1443 rewind(TFP);
1444 Find_term();
1445 free(tc_);
1446 tc_ = NULL;
1447 CAP_PARSE();
1448 }
1449 else
1450 fclose(TFP);
1451 }
1452 #endif /* ifdef CAP */
1453
1454 struct _line *
1455 Screenalloc(int columns)
1456 {
1457 int i;
1458 struct _line *tmp;
1459
1460 tmp = (struct _line *) malloc(sizeof (struct _line));
1461 tmp->row = malloc(columns + 1);
1462 tmp->attributes = malloc(columns + 1);
1463 tmp->prev_screen = NULL;
1464 tmp->next_screen = NULL;
1465 for (i = 0; i < columns; i++)
1466 {
1467 tmp->row[i] = ' ';
1468 tmp->attributes[i] = (char) NULL;
1469 }
1470 tmp->scroll = tmp->changed = FALSE;
1471 tmp->row[0] = (char) NULL;
1472 tmp->attributes[0] = (char) NULL;
1473 tmp->row[columns] = (char) NULL;
1474 tmp->attributes[columns] = (char) NULL;
1475 tmp->last_char = 0;
1476 return(tmp);
1477 }
1478
1479 /*
1480 lines, cols: number of lines and columns to be in window
1481 start_l, start_c: starting line and column to be in window
1482 */
1483 WINDOW *
1484 newwin(int lines, int cols, int start_l, int start_c)
1485 {
1486 WINDOW *Ntemp;
1487 struct _line *temp_screen;
1488 int i;
1489
1490 Ntemp = (WINDOW *) malloc(sizeof(WINDOW));
1491 Ntemp->SR = start_l;
1492 Ntemp->SC = start_c;
1493 Ntemp->Num_lines = lines;
1494 Ntemp->Num_cols = cols;
1495 Ntemp->LX = 0;
1496 Ntemp->LY = 0;
1497 Ntemp->scroll_down = Ntemp->scroll_up = 0;
1498 Ntemp->SCROLL_CLEAR = FALSE;
1499 Ntemp->Attrib = FALSE;
1500 Ntemp->first_line = temp_screen = Screenalloc(cols);
1501 Ntemp->first_line->number = 0;
1502 for (i = 1; i < lines; i++)
1503 {
1504 temp_screen->next_screen = Screenalloc(cols);
1505 temp_screen->next_screen->number = i;
1506 temp_screen->next_screen->prev_screen = temp_screen;
1507 temp_screen = temp_screen->next_screen;
1508 }
1509 Ntemp->first_line->prev_screen = NULL;
1510 temp_screen->next_screen = NULL;
1511 return(Ntemp);
1512 }
1513
1514 #ifdef CAP
1515 /*
1516 p_list: stack of values
1517 place: place keeper of top of stack
1518 */
1519 void
1520 Cap_Out(char *string, int *p_list, int place)
1521 /* interpret the output string if necessary */
1522 {
1523 char *Otemp; /* temporary string pointer to parse output */
1524 int delay;
1525 int p1, p2, temp;
1526 float chars;
1527
1528 if (string == NULL)
1529 return;
1530
1531 if (p_list != NULL)
1532 {
1533 p1 = p_list[--place];
1534 p2 = p_list[--place];
1535 }
1536 delay = 0;
1537 Otemp = string;
1538 if ((*Otemp >= '0') && (*Otemp <= '9'))
1539 {
1540 delay = atoi(Otemp);
1541 while ((*Otemp >= '0') && (*Otemp <= '9'))
1542 Otemp++;
1543 if (*Otemp == '*')
1544 Otemp++;
1545 }
1546 while (*Otemp != (char)NULL)
1547 {
1548 if (*Otemp == '%')
1549 {
1550 Otemp++;
1551 if ((*Otemp == 'd') || (*Otemp == '2') || (*Otemp == '3') || (*Otemp == '.') || (*Otemp == '+'))
1552 {
1553 if (*Otemp == 'd')
1554 printf("%d", p1);
1555 else if (*Otemp == '2')
1556 printf("%02d", p1);
1557 else if (*Otemp == '3')
1558 printf("%03d", p1);
1559 else if (*Otemp == '+')
1560 {
1561 Otemp++;
1562 p1 += *Otemp;
1563 putchar(p1);
1564 }
1565 else if (*Otemp == '.')
1566 putchar(p1);
1567 p1 = p2;
1568 p2 = 0;
1569 }
1570 else if (*Otemp == '>')
1571 {
1572 Otemp++;
1573 if (p1 > *Otemp)
1574 {
1575 Otemp++;
1576 p1 += *Otemp;
1577 }
1578 else
1579 Otemp++;
1580 }
1581 else if (*Otemp == 'r')
1582 {
1583 temp = p1;
1584 p1 = p2;
1585 p2 = temp;
1586 }
1587 else if (*Otemp == 'i')
1588 {
1589 p1++;
1590 p2++;
1591 }
1592 else if (*Otemp == '%')
1593 putchar(*Otemp);
1594 else if (*Otemp == 'n')
1595 {
1596 p1 ^= 0140;
1597 p2 ^= 0140;
1598 }
1599 else if (*Otemp == 'B')
1600 {
1601 p1 = (16 * (p1/10)) + (p1 % 10);
1602 p2 = (16 * (p2/10)) + (p2 % 10);
1603 }
1604 else if (*Otemp == 'D')
1605 {
1606 p1 = (p1 - 2 * (p1 % 16));
1607 p2 = (p2 - 2 * (p2 % 16));
1608 }
1609 }
1610 else
1611 putchar (*Otemp);
1612 Otemp++;
1613 }
1614 if (delay != 0)
1615 {
1616 chars = delay * chars_per_millisecond;
1617 delay = chars;
1618 if ((chars - delay) > 0.0)
1619 delay++;
1620 for (; delay > 0; delay--)
1621 putchar(*String_table[pc__]);
1622 }
1623 fflush(stdout);
1624 }
1625
1626 #else
1627
1628 char *Otemp; /* temporary string pointer to parse output */
1629 float chars;
1630 int p[10];
1631 int variable[27];
1632
1633 int
1634 Operation(int *Temp_Stack, int place) /* handle conditional operations */
1635 {
1636 int temp;
1637
1638 if (*Otemp == 'd')
1639 {
1640 Otemp++;
1641 temp = Temp_Stack[--place];
1642 printf("%d", temp);
1643 }
1644 else if (!strncmp(Otemp, "2d", 2))
1645 {
1646 temp = Temp_Stack[--place];
1647 printf("%2d", temp);
1648 Otemp++;
1649 Otemp++;
1650 }
1651 else if (!strncmp(Otemp, "3d", 2))
1652 {
1653 temp = Temp_Stack[--place];
1654 printf("%0d", temp);
1655 Otemp++;
1656 Otemp++;
1657 }
1658 else if (!strncmp(Otemp, "02d", 3))
1659 {
1660 temp = Temp_Stack[--place];
1661 printf("%02d", temp);
1662 Otemp++;
1663 Otemp++;
1664 Otemp++;
1665 }
1666 else if (!strncmp(Otemp, "03d", 3))
1667 {
1668 temp = Temp_Stack[--place];
1669 printf("%03d", temp);
1670 Otemp++;
1671 Otemp++;
1672 Otemp++;
1673 }
1674 else if (*Otemp == '+')
1675 {
1676 Otemp++;
1677 temp = Temp_Stack[--place];
1678 temp += Temp_Stack[--place];
1679 Temp_Stack[place++] = temp;
1680 }
1681 else if (*Otemp == '-')
1682 {
1683 Otemp++;
1684 temp = Temp_Stack[--place];
1685 temp -= Temp_Stack[--place];
1686 Temp_Stack[place++] = temp;
1687 }
1688 else if (*Otemp == '*')
1689 {
1690 Otemp++;
1691 temp = Temp_Stack[--place];
1692 temp *= Temp_Stack[--place];
1693 Temp_Stack[place++] = temp;
1694 }
1695 else if (*Otemp == '/')
1696 {
1697 Otemp++;
1698 temp = Temp_Stack[--place];
1699 temp /= Temp_Stack[--place];
1700 Temp_Stack[place++] = temp;
1701 }
1702 else if (*Otemp == 'm')
1703 {
1704 Otemp++;
1705 temp = Temp_Stack[--place];
1706 temp %= Temp_Stack[--place];
1707 Temp_Stack[place++] = temp;
1708 }
1709 else if (*Otemp == '&')
1710 {
1711 Otemp++;
1712 temp = Temp_Stack[--place];
1713 temp &= Temp_Stack[--place];
1714 Temp_Stack[place++] = temp;
1715 }
1716 else if (*Otemp == '|')
1717 {
1718 Otemp++;
1719 temp = Temp_Stack[--place];
1720 temp |= Temp_Stack[--place];
1721 Temp_Stack[place++] = temp;
1722 }
1723 else if (*Otemp == '^')
1724 {
1725 Otemp++;
1726 temp = Temp_Stack[--place];
1727 temp ^= Temp_Stack[--place];
1728 Temp_Stack[place++] = temp;
1729 }
1730 else if (*Otemp == '=')
1731 {
1732 Otemp++;
1733 temp = Temp_Stack[--place];
1734 temp = (temp == Temp_Stack[--place]);
1735 Temp_Stack[place++] = temp;
1736 }
1737 else if (*Otemp == '>')
1738 {
1739 Otemp++;
1740 temp = Temp_Stack[--place];
1741 temp = temp > Temp_Stack[--place];
1742 Temp_Stack[place++] = temp;
1743 }
1744 else if (*Otemp == '<')
1745 {
1746 Otemp++;
1747 temp = Temp_Stack[--place];
1748 temp = temp < Temp_Stack[--place];
1749 Temp_Stack[place++] = temp;
1750 }
1751 else if (*Otemp == 'c')
1752 {
1753 Otemp++;
1754 putchar(Temp_Stack[--place]);
1755 }
1756 else if (*Otemp == 'i')
1757 {
1758 Otemp++;
1759 p[1]++;
1760 p[2]++;
1761 }
1762 else if (*Otemp == '%')
1763 {
1764 putchar(*Otemp);
1765 Otemp++;
1766 }
1767 else if (*Otemp == '!')
1768 {
1769 temp = ! Temp_Stack[--place];
1770 Temp_Stack[place++] = temp;
1771 Otemp++;
1772 }
1773 else if (*Otemp == '~')
1774 {
1775 temp = ~Temp_Stack[--place];
1776 Temp_Stack[place++] = temp;
1777 Otemp++;
1778 }
1779 else if (*Otemp == 'p')
1780 {
1781 Otemp++;
1782 Temp_Stack[place++] = p[*Otemp - '0'];
1783 Otemp++;
1784 }
1785 else if (*Otemp == 'P')
1786 {
1787 Otemp++;
1788 Temp_Stack[place++] = variable[*Otemp - 'a'];
1789 Otemp++;
1790 }
1791 else if (*Otemp == 'g')
1792 {
1793 Otemp++;
1794 variable[*Otemp - 'a'] = Temp_Stack[--place];
1795 Otemp++;
1796 }
1797 else if (*Otemp == '\'')
1798 {
1799 Otemp++;
1800 Temp_Stack[place++] = *Otemp;
1801 Otemp++;
1802 Otemp++;
1803 }
1804 else if (*Otemp == '{')
1805 {
1806 Otemp++;
1807 temp = atoi(Otemp);
1808 Temp_Stack[place++] = temp;
1809 while (*Otemp != '}')
1810 Otemp++;
1811 Otemp++;
1812 }
1813 return(place);
1814 }
1815
1816 void
1817 Info_Out(char *string, int *p_list, int place)
1818 /* interpret the output string if necessary */
1819 {
1820 char *tchar;
1821 int delay;
1822 int temp;
1823 int Cond_FLAG;
1824 int EVAL;
1825 int Cond_Stack[128];
1826 int Cond_place;
1827 int Stack[128];
1828 int Top_of_stack;
1829
1830 if (string == NULL)
1831 return;
1832
1833 Cond_FLAG = FALSE;
1834 Cond_place = 0;
1835 Top_of_stack = 0;
1836 p[0] = 0;
1837 p[1] = 0;
1838 p[2] = 0;
1839 p[3] = 0;
1840 p[4] = 0;
1841 p[5] = 0;
1842 p[6] = 0;
1843 p[7] = 0;
1844 p[8] = 0;
1845 p[9] = 0;
1846 if (p_list != NULL)
1847 {
1848 for (temp = 1; (place != 0); temp++)
1849 {
1850 p[temp] = p_list[--place];
1851 }
1852 }
1853 delay = 0;
1854 Otemp = string;
1855 while (*Otemp != (char) NULL)
1856 {
1857 if (*Otemp == '%')
1858 {
1859 Otemp++;
1860 if ((*Otemp == '?') || (*Otemp == 't') || (*Otemp == 'e') || (*Otemp == ';'))
1861 {
1862 if (*Otemp == '?')
1863 {
1864 Otemp++;
1865 Cond_FLAG = TRUE;
1866 EVAL = TRUE;
1867 while (EVAL)
1868 {
1869 /*
1870 | find the end of the
1871 | conditional statement
1872 */
1873 while ((strncmp(Otemp, "%t", 2)) && (*Otemp != (char) NULL))
1874 {
1875 /*
1876 | move past '%'
1877 */
1878 Otemp++;
1879 Cond_place = Operation(Cond_Stack, Cond_place);
1880 }
1881
1882 /*
1883 | if condition is true
1884 */
1885 if ((Cond_place > 0) && (Cond_Stack[Cond_place-1]))
1886 {
1887 /*
1888 | end conditional
1889 | parsing
1890 */
1891 EVAL = FALSE;
1892 Otemp++;
1893 Otemp++;
1894 }
1895 else /* condition is false */
1896 {
1897 /*
1898 | find 'else' or end
1899 | of if statement
1900 */
1901 while ((strncmp(Otemp, "%e", 2)) && (strncmp(Otemp, "%;", 2)) && (*Otemp != (char) NULL))
1902 Otemp++;
1903 /*
1904 | if an 'else' found
1905 */
1906 if ((*Otemp != (char) NULL) && (!strncmp(Otemp, "%e", 2)))
1907 {
1908 Otemp++;
1909 Otemp++;
1910 tchar = Otemp;
1911 /*
1912 | check for 'then' part
1913 */
1914 while ((*tchar != (char) NULL) && (strncmp(tchar, "%t", 2)) && (strncmp(tchar, "%;", 2)))
1915 tchar++;
1916 /*
1917 | if end of string
1918 */
1919 if (*tchar == (char) NULL)
1920 {
1921 EVAL = FALSE;
1922 Cond_FLAG = FALSE;
1923 Otemp = tchar;
1924 }
1925 /*
1926 | if end of if found,
1927 | set up to parse
1928 | info
1929 */
1930 else if (!strncmp(tchar, "%;", 2))
1931 EVAL = FALSE;
1932 /*
1933 | otherwise, check
1934 | conditional in
1935 | 'else'
1936 */
1937 }
1938 /*
1939 | if end of if found,
1940 | get out of if
1941 | statement
1942 */
1943 else if ((*Otemp != (char) NULL) && (!strncmp(Otemp, "%;", 2)))
1944 {
1945 EVAL = FALSE;
1946 Otemp++;
1947 Otemp++;
1948 }
1949 else /* Otemp == NULL */
1950 {
1951 EVAL = FALSE;
1952 Cond_FLAG = FALSE;
1953 }
1954 }
1955 }
1956 }
1957 else
1958 {
1959 Otemp++;
1960 Cond_FLAG = FALSE;
1961 if (*Otemp != ';')
1962 {
1963 while ((*Otemp != (char) NULL) && (strncmp(Otemp, "%;", 2)))
1964 Otemp++;
1965 if (*Otemp != (char) NULL)
1966 {
1967 Otemp++;
1968 Otemp++;
1969 }
1970 }
1971 else
1972 Otemp++;
1973 }
1974 }
1975 else
1976 {
1977 Top_of_stack = Operation(Stack, Top_of_stack);
1978 }
1979 }
1980 else if (!strncmp(Otemp, "$<", 2))
1981 {
1982 Otemp++;
1983 Otemp++;
1984 delay = atoi(Otemp);
1985 while (*Otemp != '>')
1986 Otemp++;
1987 Otemp++;
1988 chars = delay * chars_per_millisecond;
1989 delay = chars;
1990 if ((chars - delay) > 0.0)
1991 delay++;
1992 if (String_table[pc__] == NULL)
1993 temp = 0;
1994 else
1995 temp = *String_table[pc__];
1996 for (; delay > 0; delay--)
1997 putc(temp, stdout);
1998 }
1999 else
2000 {
2001 putchar(*Otemp);
2002 Otemp++;
2003 }
2004 }
2005 fflush(stdout);
2006 }
2007 #endif
2008
2009 void
2010 wmove(WINDOW *window, int row, int column)
2011 /* move cursor to indicated position in window */
2012 {
2013 if ((row < window->Num_lines) && (column < window->Num_cols))
2014 {
2015 window->LX = column;
2016 window->LY = row;
2017 }
2018 }
2019
2020 void
2021 clear_line(struct _line *line, int column, int cols)
2022 {
2023 int j;
2024
2025 if (column > line->last_char)
2026 line->row[line->last_char] = ' ';
2027 line->last_char = column;
2028 line->row[column] = (char) NULL;
2029 line->attributes[column] = (char) NULL;
2030 line->changed = TRUE;
2031 for (j = column + 1; j < cols; j++)
2032 {
2033 line->row[j] = ' ';
2034 line->attributes[j] = (char) NULL;
2035 }
2036 }
2037
2038 void
2039 werase(WINDOW *window) /* clear the specified window */
2040 {
2041 int i;
2042 struct _line *tmp;
2043
2044 window->SCROLL_CLEAR = CLEAR;
2045 window->scroll_up = window->scroll_down = 0;
2046 for (i = 0, tmp = window->first_line; i < window->Num_lines; i++, tmp = tmp->next_screen)
2047 clear_line(tmp, 0, window->Num_cols);
2048 }
2049
2050 void
2051 wclrtoeol(WINDOW *window)
2052 /* erase from current cursor position to end of line */
2053 {
2054 int column, row;
2055 struct _line *tmp;
2056
2057 window->SCROLL_CLEAR = CHANGE;
2058 column = window->LX;
2059 row = window->LY;
2060 for (row = 0, tmp = window->first_line; row < window->LY; row++)
2061 tmp = tmp->next_screen;
2062 clear_line(tmp, column, window->Num_cols);
2063 }
2064
2065 void
2066 wrefresh(WINDOW *window) /* flush all previous output */
2067 {
2068 wnoutrefresh(window);
2069 #ifdef DIAG
2070 {
2071 struct _line *temp;
2072 int value;
2073 fprintf(stderr, "columns=%d, lines=%d, SC=%d, SR=%d\n",window->Num_cols, window->Num_lines, window->SC, window->SR);
2074 for (value = 0, temp = window->first_line; value < window->Num_lines; value++, temp = temp->next_screen)
2075 {
2076 if (temp->number == -1)
2077 fprintf(stderr, "line moved ");
2078 if (temp->scroll)
2079 fprintf(stderr, "scroll_x is set: ");
2080 fprintf(stderr, "lc%d=%s|\n", temp->last_char, temp->row);
2081 }
2082 fprintf(stderr, "+-------------------- virtual screen ----------------------------------------+\n");
2083 fprintf(stderr, "columns=%d, lines=%d \n",virtual_scr->Num_cols, virtual_scr->Num_lines);
2084 for (value = 0, temp = virtual_scr->first_line; value < virtual_scr->Num_lines; value++, temp = temp->next_screen)
2085 {
2086 if (temp->number == -1)
2087 fprintf(stderr, "line moved ");
2088 if (temp->scroll)
2089 fprintf(stderr, "scroll_x is set: ");
2090 fprintf(stderr, "lc%d=%s|\n", temp->last_char, temp->row);
2091 }
2092 fprintf(stderr, "columns=%d, lines=%d \n",curscr->Num_cols, curscr->Num_lines);
2093 for (value = 0, temp = curscr->first_line; value < curscr->Num_lines; value++, temp = temp->next_screen)
2094 fprintf(stderr, "line=%s|\n", temp->row);
2095 }
2096 #endif
2097 doupdate();
2098 virtual_scr->SCROLL_CLEAR = FALSE;
2099 virtual_scr->scroll_down = virtual_scr->scroll_up = 0;
2100 fflush(stdout);
2101 }
2102
2103 void
2104 touchwin(WINDOW *window)
2105 {
2106 struct _line *user_line;
2107 int line_counter = 0;
2108
2109 for (line_counter = 0, user_line = window->first_line;
2110 line_counter < window->Num_lines; line_counter++)
2111 {
2112 user_line->changed = TRUE;
2113 }
2114 window->SCROLL_CLEAR = TRUE;
2115 }
2116
2117 void
2118 wnoutrefresh(WINDOW *window)
2119 {
2120 struct _line *user_line;
2121 struct _line *virtual_line;
2122 int line_counter = 0;
2123 int user_col = 0;
2124 int virt_col = 0;
2125
2126 if (window->SR >= virtual_scr->Num_lines)
2127 return;
2128 user_line = window->first_line;
2129 virtual_line = virtual_scr->first_line;
2130 virtual_scr->SCROLL_CLEAR = window->SCROLL_CLEAR;
2131 virtual_scr->LX = window->LX + window->SC;
2132 virtual_scr->LY = window->LY + window->SR;
2133 virtual_scr->scroll_up = window->scroll_up;
2134 virtual_scr->scroll_down = window->scroll_down;
2135 if ((last_window_refreshed == window) && (!window->SCROLL_CLEAR))
2136 return;
2137 for (line_counter = 0; line_counter < window->SR; line_counter++)
2138 {
2139 virtual_line = virtual_line->next_screen;
2140 }
2141 for (line_counter = 0; (line_counter < window->Num_lines)
2142 && ((line_counter + window->SR) < virtual_scr->Num_lines);
2143 line_counter++)
2144 {
2145 if ((last_window_refreshed != window) || (user_line->changed) || ((SCROLL | CLEAR) & window->SCROLL_CLEAR))
2146 {
2147 for (user_col = 0, virt_col = window->SC;
2148 (virt_col < virtual_scr->Num_cols)
2149 && (user_col < window->Num_cols);
2150 virt_col++, user_col++)
2151 {
2152 virtual_line->row[virt_col] = user_line->row[user_col];
2153 virtual_line->attributes[virt_col] = user_line->attributes[user_col];
2154 }
2155 }
2156 if (virtual_scr->Num_cols != window->Num_cols)
2157 {
2158 if (virtual_line->last_char < (user_line->last_char + window->SC))
2159 {
2160 if (virtual_line->row[virtual_line->last_char] == (char) NULL)
2161 virtual_line->row[virtual_line->last_char] = ' ';
2162 virtual_line->last_char =
2163 min(virtual_scr->Num_cols,
2164 (user_line->last_char + window->SC));
2165 }
2166 else if (virtual_line->last_char > (user_line->last_char + window->SC))
2167 {
2168 virtual_line->row[min(virtual_scr->Num_cols,
2169 (user_line->last_char + window->SC))] = ' ';
2170 }
2171 }
2172 else
2173 virtual_line->last_char = user_line->last_char;
2174 virtual_line->row[virtual_line->last_char] = (char) NULL;
2175 virtual_line->changed = user_line->changed;
2176 virtual_line = virtual_line->next_screen;
2177 user_line = user_line->next_screen;
2178 }
2179 window->SCROLL_CLEAR = FALSE;
2180 window->scroll_up = window->scroll_down = 0;
2181 last_window_refreshed = window;
2182 }
2183
2184 void
2185 flushinp(void) /* flush input */
2186 {
2187 }
2188
2189 void
2190 ungetch(int c) /* push a character back on input */
2191 {
2192 if (bufp < 100)
2193 in_buff[bufp++] = c;
2194 }
2195
2196 #ifdef BSD_SELECT
2197 int
2198 timed_getchar(void)
2199 {
2200 struct timeval tv;
2201 fd_set fds;
2202 int ret_val;
2203 int nfds = 1;
2204 char temp;
2205
2206 FD_ZERO(&fds);
2207 tv.tv_sec = 0;
2208 tv.tv_usec = 500000; /* half a second */
2209 FD_SET(0, &fds);
2210 Time_Out = FALSE; /* just in case */
2211
2212 ret_val = select(nfds, &fds, 0, 0, &tv);
2213
2214 /*
2215 | if ret_val is less than zero, there was no input
2216 | otherwise, get a character and return it
2217 */
2218
2219 if (ret_val <= 0)
2220 {
2221 Time_Out = TRUE;
2222 return(-1);
2223 }
2224
2225 return(read(0, &temp, 1)? temp : -1);
2226 }
2227 #endif
2228
2229 int
2230 wgetch(WINDOW *window) /* get character from specified window */
2231 {
2232 int in_value;
2233 char temp;
2234 #ifndef SYS5
2235 int old_arg;
2236 #endif /* SYS5 */
2237
2238 #ifdef BSD_SELECT
2239 if (Noblock)
2240 in_value = ((bufp > 0) ? in_buff[--bufp] : timed_getchar());
2241 else
2242 in_value = ((bufp > 0) ? in_buff[--bufp] : read(0, &temp, 1)? temp : -1);
2243 #else /* BSD_SELECT */
2244 #ifdef SYS5
2245 in_value = ((bufp > 0) ? in_buff[--bufp] :
2246 (read(0, &temp, 1)> 0) ? temp : -1);
2247 #else /* SYS5 */
2248 if (Noblock)
2249 {
2250 Time_Out = FALSE;
2251 old_arg = fcntl(0, F_GETFL, 0);
2252 in_value = fcntl(0, F_SETFL, old_arg | FNDELAY);
2253 }
2254 in_value = ((bufp > 0) ? in_buff[--bufp] : read(0, &temp, 1)? temp : -1);
2255 if (Noblock)
2256 {
2257 fcntl(0, F_SETFL, old_arg);
2258 if (Time_Out)
2259 in_value = -1;
2260 }
2261 #endif /* SYS5 */
2262 #endif /* BSD_SELECT */
2263
2264 if (in_value != -1)
2265 {
2266 in_value &= 0xff;
2267 if ((Parity) && (Num_bits < 8))
2268 /* strip eighth bit if parity in use */
2269 in_value &= 0177;
2270 }
2271 else if (interrupt_flag)
2272 {
2273 interrupt_flag = FALSE;
2274 in_value = wgetch(window);
2275 }
2276
2277 if ((in_value == '\033') || (in_value == '\037'))/* escape character */
2278 in_value = Get_key(in_value);
2279 return(in_value);
2280 }
2281
2282 #ifndef BSD_SELECT
2283 void
2284 Clear(int arg) /* notify that time out has occurred */
2285 {
2286 Time_Out = TRUE;
2287 #ifdef DEBUG
2288 fprintf(stderr, "inside Clear()\n");
2289 fflush(stderr);
2290 #endif /* DEBUG */
2291 }
2292 #endif /* BSD_SELECT */
2293
2294 /* first_char: first character of sequence */
2295 int
2296 Get_key(int first_char) /* try to decode key sequence */
2297 {
2298 int in_char;
2299 int Count;
2300 char string[128];
2301 char *Gtemp;
2302 int Found;
2303 #ifdef SYS5
2304 struct termio Gterminal;
2305 #else
2306 struct sgttyb Gterminal;
2307 #endif
2308 struct KEY_STACK *St_point;
2309 #if (!defined( BSD_SELECT)) || (!defined(SYS5))
2310 int value;
2311 #endif /* BSD_SELECT */
2312
2313 Count = 0;
2314 Gtemp = string;
2315 string[Count++] = first_char;
2316 string[Count] = (char) NULL;
2317 Time_Out = FALSE;
2318 #ifndef BSD_SELECT
2319 signal(SIGALRM, Clear);
2320 value = alarm(1);
2321 #endif /* BSD_SELECT */
2322 Noblock = TRUE;
2323 #ifdef SYS5
2324 Gterminal.c_cc[VTIME] = 0; /* timeout value */
2325 Gterminal.c_lflag &= ~ICANON; /* disable canonical operation */
2326 Gterminal.c_lflag &= ~ECHO; /* disable echo */
2327 #endif
2328 Count = 1;
2329 Found = FALSE;
2330 while ((Count < Max_Key_len) && (!Time_Out) && (!Found))
2331 {
2332 in_char = wgetch(stdscr);
2333 #ifdef DEBUG
2334 fprintf(stderr, "back in GetKey()\n");
2335 fflush(stderr);
2336 #endif /* DEBUG */
2337 if (in_char != -1)
2338 {
2339 string[Count++] = in_char;
2340 string[Count] = (char) NULL;
2341 St_point = KEY_TOS;
2342 while ((St_point != NULL) && (!Found))
2343 {
2344 if (!strcmp(string, St_point->element->string))
2345 Found = TRUE;
2346 else
2347 St_point = St_point->next;
2348 }
2349 }
2350 }
2351 #ifndef BSD_SELECT
2352 if (!Time_Out)
2353 value = alarm(0);
2354 #endif /* BSD_SELECT */
2355 #ifdef SYS5
2356 /* value = ioctl(0, TCSETA, &Terminal);*/
2357 #else
2358 value = ioctl(0, TIOCSETP, &Terminal);
2359 /* value = fcntl(0, F_SETFL, old_arg);*/
2360 #endif
2361 Noblock = FALSE;
2362 if (Found)
2363 {
2364 return(St_point->element->value);
2365 }
2366 else
2367 {
2368 while (Count > 1)
2369 {
2370 if ((string[--Count] != -1) &&
2371 ((unsigned char) (string[Count]) != 255))
2372 {
2373 #ifdef DIAG
2374 fprintf(stderr, "ungetting character %d\n", string[Count]);fflush(stdout);
2375 #endif
2376 ungetch(string[Count]);
2377 }
2378 }
2379 return(first_char);
2380 }
2381 }
2382
2383 void
2384 waddch(WINDOW *window, int c) /* output the character in the specified window */
2385 {
2386 int row, column;
2387 int shift; /* number of spaces to shift if a tab */
2388 struct _line *tmpline;
2389
2390 #ifdef DIAG
2391 /*printf("starting waddch \n");fflush(stdout);*/
2392 #endif
2393 row = window->LY;
2394 column = window->LX;
2395 if (c == '\t')
2396 {
2397 shift = (column + 1) % 8;
2398 if (shift == 0)
2399 shift++;
2400 else
2401 shift = 9 - shift;
2402 while (shift > 0)
2403 {
2404 shift--;
2405 waddch(window, ' ');
2406 }
2407 }
2408 else if ((column < window->Num_cols) && (row < window->Num_lines))
2409 {
2410 if ((c == '~') && (Booleans[hz__]))
2411 c = '@';
2412
2413 if (( c != '\b') && (c != '\n') && (c != '\r'))
2414 {
2415 row = 0;
2416 tmpline = window->first_line;
2417 while (row < window->LY)
2418 {
2419 row++;
2420 tmpline = tmpline->next_screen;
2421 }
2422 tmpline->row[column] = c;
2423 tmpline->attributes[column] = window->Attrib;
2424 tmpline->changed = TRUE;
2425 if (column >= tmpline->last_char)
2426 {
2427 if (column > tmpline->last_char)
2428 tmpline->row[tmpline->last_char] = ' ';
2429 tmpline->row[column + 1] = (char) NULL;
2430 tmpline->attributes[column + 1] = (char) NULL;
2431 tmpline->last_char = column + 1;
2432 }
2433 }
2434 if (c == '\n')
2435 {
2436 wclrtoeol(window);
2437 window->LX = window->Num_cols;
2438 }
2439 else if (c == '\r')
2440 window->LX = 0;
2441 else if (c == '\b')
2442 window->LX--;
2443 else
2444 window->LX++;
2445 }
2446 if (window->LX >= window->Num_cols)
2447 {
2448 window->LX = 0;
2449 window->LY++;
2450 if (window->LY >= window->Num_lines)
2451 {
2452 window->LY = window->Num_lines - 1;
2453 /* window->LY = row;
2454 wmove(window, 0, 0);
2455 wdeleteln(window);
2456 wmove(window, row, 0);*/
2457 }
2458 }
2459 window->SCROLL_CLEAR = CHANGE;
2460 }
2461
2462 void
2463 winsertln(WINDOW *window) /* insert a blank line into the specified window */
2464 {
2465 int row, column;
2466 struct _line *tmp;
2467 struct _line *tmp1;
2468
2469 window->scroll_down += 1;
2470 window->SCROLL_CLEAR = SCROLL;
2471 column = window->LX;
2472 row = window->LY;
2473 for (row = 0, tmp = window->first_line; (row < window->Num_lines) && (tmp->next_screen != NULL); row++)
2474 tmp = tmp->next_screen;
2475 if (tmp->prev_screen != NULL)
2476 tmp->prev_screen->next_screen = NULL;
2477 tmp1 = tmp;
2478 clear_line(tmp1, 0, window->Num_cols);
2479 tmp1->number = -1;
2480 for (row = 0, tmp = window->first_line; (row < window->LY) && (tmp->next_screen != NULL); row++)
2481 tmp = tmp->next_screen;
2482 if ((window->LY == (window->Num_lines - 1)) && (window->Num_lines > 1))
2483 {
2484 tmp1->next_screen = tmp->next_screen;
2485 tmp->next_screen = tmp1;
2486 tmp->changed = TRUE;
2487 tmp->next_screen->prev_screen = tmp;
2488 }
2489 else if (window->Num_lines > 1)
2490 {
2491 if (tmp->prev_screen != NULL)
2492 tmp->prev_screen->next_screen = tmp1;
2493 tmp1->prev_screen = tmp->prev_screen;
2494 tmp->prev_screen = tmp1;
2495 tmp1->next_screen = tmp;
2496 tmp->changed = TRUE;
2497 tmp->scroll = DOWN;
2498 }
2499 if (window->LY == 0)
2500 window->first_line = tmp1;
2501 }
2502
2503 void
2504 wdeleteln(WINDOW *window) /* delete a line in the specified window */
2505 {
2506 int row, column;
2507 struct _line *tmp;
2508 struct _line *tmpline;
2509
2510 if (window->Num_lines > 1)
2511 {
2512 window->scroll_up += 1;
2513 window->SCROLL_CLEAR = SCROLL;
2514 column = window->LX;
2515 row = window->LY;
2516 for (row = 0, tmp = window->first_line; row < window->LY; row++)
2517 tmp = tmp->next_screen;
2518 if (window->LY == 0)
2519 window->first_line = tmp->next_screen;
2520 if (tmp->prev_screen != NULL)
2521 tmp->prev_screen->next_screen = tmp->next_screen;
2522 if (tmp->next_screen != NULL)
2523 {
2524 tmp->next_screen->changed = TRUE;
2525 tmp->next_screen->scroll = UP;
2526 tmp->next_screen->prev_screen = tmp->prev_screen;
2527 }
2528 tmpline = tmp;
2529 clear_line(tmpline, 0, window->Num_cols);
2530 tmpline->number = -1;
2531 for (row = 0, tmp = window->first_line; tmp->next_screen != NULL; row++)
2532 tmp = tmp->next_screen;
2533 if (tmp != NULL)
2534 {
2535 tmp->next_screen = tmpline;
2536 tmp->next_screen->prev_screen = tmp;
2537 tmp->changed = TRUE;
2538 tmp = tmp->next_screen;
2539 }
2540 else
2541 tmp = tmpline;
2542 tmp->next_screen = NULL;
2543 }
2544 else
2545 {
2546 clear_line(window->first_line, 0, window->Num_cols);
2547 }
2548 }
2549
2550 void
2551 wclrtobot(WINDOW *window)
2552 /* delete from current position to end of the window */
2553 {
2554 int row, column;
2555 struct _line *tmp;
2556
2557 window->SCROLL_CLEAR |= CLEAR;
2558 column = window->LX;
2559 row = window->LY;
2560 for (row = 0, tmp = window->first_line; row < window->LY; row++)
2561 tmp = tmp->next_screen;
2562 clear_line(tmp, column, window->Num_cols);
2563 for (row = (window->LY + 1); row < window->Num_lines; row++)
2564 {
2565 tmp = tmp->next_screen;
2566 clear_line(tmp, 0, window->Num_cols);
2567 }
2568 wmove(window, row, column);
2569 }
2570
2571 void
2572 wstandout(WINDOW *window) /* begin standout mode in window */
2573 {
2574 if (Numbers[sg__] < 1) /* if not magic cookie glitch */
2575 window->Attrib |= A_STANDOUT;
2576 }
2577
2578 void
2579 wstandend(WINDOW *window) /* end standout mode in window */
2580 {
2581 window->Attrib &= ~A_STANDOUT;
2582 }
2583
2584 void
2585 waddstr(WINDOW *window, char *string) /* write 'string' in window */
2586 {
2587 char *wstring;
2588
2589 for (wstring = string; *wstring != (char) NULL; wstring++)
2590 waddch(window, *wstring);
2591 }
2592
2593 void
2594 clearok(WINDOW *window, int flag) /* erase screen and redraw at next refresh */
2595 {
2596 Repaint_screen = TRUE;
2597 }
2598
2599
2600 void
2601 echo(void) /* turn on echoing */
2602 {
2603 int value;
2604
2605 #ifdef SYS5
2606 Terminal.c_lflag |= ECHO; /* enable echo */
2607 value = ioctl(0, TCSETA, &Terminal); /* set characteristics */
2608 #else
2609 Terminal.sg_flags |= ECHO; /* enable echo */
2610 value = ioctl(0, TIOCSETP, &Terminal); /* set characteristics */
2611 #endif
2612 }
2613
2614 void
2615 noecho(void) /* turn off echoing */
2616 {
2617 int value;
2618
2619 #ifdef SYS5
2620 Terminal.c_lflag &= ~ECHO; /* disable echo */
2621 value = ioctl(0, TCSETA, &Terminal); /* set characteristics */
2622 #else
2623 Terminal.sg_flags &= ~ECHO; /* disable echo */
2624 value = ioctl(0, TIOCSETP, &Terminal); /* set characteristics */
2625 #endif
2626 }
2627
2628 void
2629 raw(void) /* set to read characters immediately */
2630 {
2631 int value;
2632
2633 #ifdef SYS5
2634 Intr = Terminal.c_cc[VINTR]; /* get the interrupt character */
2635 Terminal.c_lflag &= ~ICANON; /* disable canonical operation */
2636 Terminal.c_lflag &= ~ISIG; /* disable signal checking */
2637 #ifdef FLUSHO
2638 Terminal.c_lflag &= ~FLUSHO;
2639 #endif
2640 #ifdef PENDIN
2641 Terminal.c_lflag &= ~PENDIN;
2642 #endif
2643 #ifdef IEXTEN
2644 Terminal.c_lflag &= ~IEXTEN;
2645 #endif
2646 Terminal.c_cc[VMIN] = 1; /* minimum of one character */
2647 Terminal.c_cc[VTIME] = 255; /* timeout value */
2648 Terminal.c_cc[VINTR] = 0; /* eliminate interrupt */
2649 value = ioctl(0, TCSETA, &Terminal); /* set characteristics */
2650 #else
2651 Terminal.sg_flags |= RAW; /* enable raw mode */
2652 value = ioctl(0, TIOCSETP, &Terminal); /* set characteristics */
2653 #endif
2654 }
2655
2656 void
2657 noraw(void) /* set to normal character read mode */
2658 {
2659 int value;
2660
2661 #ifdef SYS5
2662 Terminal.c_lflag |= ICANON; /* enable canonical operation */
2663 Terminal.c_lflag |= ISIG; /* enable signal checking */
2664 Terminal.c_cc[VEOF] = 4; /* EOF character = 4 */
2665 Terminal.c_cc[VEOL] = (char) NULL; /* EOL = 0 */
2666 Terminal.c_cc[VINTR] = Intr; /* reset interrupt char */
2667 value = ioctl(0, TCSETA, &Terminal); /* set characteristics */
2668 #else
2669 Terminal.sg_flags &= ~RAW; /* disable raw mode */
2670 value = ioctl(0, TIOCSETP, &Terminal); /* set characteristics */
2671 /* old_arg = fcntl(0, F_GETFL, 0);
2672 value = fcntl(0, F_SETFL, old_arg & ~FNDELAY);*/
2673 #endif
2674 }
2675
2676 void
2677 nl(void)
2678 {
2679 int value;
2680
2681 #ifdef SYS5
2682 Terminal.c_iflag |= ICRNL; /* enable carriage-return to line-feed mapping */
2683 value = ioctl(0, TCSETA, &Terminal); /* set characteristics */
2684 #endif
2685 }
2686
2687 void
2688 nonl(void)
2689 {
2690 int value;
2691
2692 #ifdef SYS5
2693 Terminal.c_iflag &= ~ICRNL; /* disable carriage-return to line-feed mapping */
2694 Terminal.c_iflag &= ~IGNCR; /* do not ignore carriage-return */
2695 value = ioctl(0, TCSETA, &Terminal); /* set characteristics */
2696 #endif
2697 }
2698
2699 void
2700 saveterm(void)
2701 {
2702 }
2703
2704 void
2705 fixterm(void)
2706 {
2707 }
2708
2709 void
2710 resetterm(void)
2711 {
2712 }
2713
2714 void
2715 nodelay(WINDOW *window, int flag)
2716 {
2717 }
2718
2719 void
2720 idlok(WINDOW *window, int flag)
2721 {
2722 }
2723
2724 void
2725 keypad(WINDOW *window, int flag)
2726 {
2727 if (flag)
2728 String_Out(String_table[ks__], NULL, 0);
2729 else
2730 String_Out(String_table[ke__], NULL, 0);
2731 }
2732
2733 void
2734 savetty(void) /* save current tty stats */
2735 {
2736 int value;
2737
2738 #ifdef SYS5
2739 value = ioctl(0, TCGETA, &Saved_tty); /* set characteristics */
2740 #else
2741 value = ioctl(0, TIOCGETP, &Saved_tty); /* set characteristics */
2742 #endif
2743 }
2744
2745 void
2746 resetty(void) /* restore previous tty stats */
2747 {
2748 int value;
2749
2750 #ifdef SYS5
2751 value = ioctl(0, TCSETA, &Saved_tty); /* set characteristics */
2752 #else
2753 value = ioctl(0, TIOCSETP, &Saved_tty); /* set characteristics */
2754 #endif
2755 }
2756
2757 void
2758 endwin(void) /* end windows */
2759 {
2760 keypad(stdscr, FALSE);
2761 initialized = FALSE;
2762 delwin(curscr);
2763 delwin(virtual_scr);
2764 delwin(stdscr);
2765 #ifndef SYS5
2766 {
2767 int old_arg, value;
2768 /* old_arg = fcntl(0, F_GETFL, 0);
2769 value = fcntl(0, F_SETFL, old_arg & ~FNDELAY);*/
2770 }
2771 #endif
2772 }
2773
2774 void
2775 delwin(WINDOW *window) /* delete the window structure */
2776 {
2777 int i;
2778
2779 for (i = 1; (i < window->Num_lines) && (window->first_line->next_screen != NULL); i++)
2780 {
2781 window->first_line = window->first_line->next_screen;
2782 free(window->first_line->prev_screen->row);
2783 free(window->first_line->prev_screen->attributes);
2784 free(window->first_line->prev_screen);
2785 }
2786 if (window == last_window_refreshed)
2787 last_window_refreshed = 0;
2788 if (window->first_line != NULL)
2789 {
2790 free(window->first_line->row);
2791 free(window->first_line->attributes);
2792 free(window->first_line);
2793 free(window);
2794 }
2795 }
2796
2797 void
2798 wprintw(WINDOW *window, const char *format, ...)
2799 {
2800 va_list ap;
2801 int value;
2802 char *fpoint;
2803 char *wtemp;
2804
2805 va_start(ap, format);
2806
2807 fpoint = (char *) format;
2808 while (*fpoint != (char) NULL)
2809 {
2810 if (*fpoint == '%')
2811 {
2812 fpoint++;
2813 if (*fpoint == 'd')
2814 {
2815 value = va_arg(ap, int);
2816 iout(window, value);
2817 }
2818 else if (*fpoint == 'c')
2819 {
2820 value = va_arg(ap, int);
2821 waddch(window, value);
2822 }
2823 else if (*fpoint == 's')
2824 {
2825 wtemp = va_arg(ap, char *);
2826 waddstr(window, wtemp);
2827 }
2828 fpoint++;
2829 }
2830 else if (*fpoint == '\\')
2831 {
2832 fpoint++;
2833 if (*fpoint == 'n')
2834 waddch(window, '\n');
2835 else if ((*fpoint >= '0') && (*fpoint <= '9'))
2836 {
2837 value = 0;
2838 while ((*fpoint >= '0') && (*fpoint <= '9'))
2839 {
2840 value = (value * 8) + (*fpoint - '0');
2841 fpoint++;
2842 }
2843 waddch(window, value);
2844 }
2845 fpoint++;
2846 }
2847 else
2848 waddch(window, *fpoint++);
2849 }
2850 va_end(ap);
2851 }
2852
2853 void
2854 iout(WINDOW *window, int value) /* output characters */
2855 {
2856 int i;
2857
2858 if ((i = value / 10) != 0)
2859 iout(window, i);
2860 waddch(window, ((value % 10) + '0'));
2861 }
2862
2863 int
2864 Comp_line(struct _line *line1, struct _line *line2) /* compare lines */
2865 {
2866 int count1, count2;
2867 int i;
2868 char *att1, *att2;
2869 char *c1, *c2;
2870
2871 c1 = line1->row;
2872 c2 = line2->row;
2873 att1 = line1->attributes;
2874 att2 = line2->attributes;
2875 count2 = strlen(c1) + 1;
2876 count1 = strlen(c2) + 1;
2877 if (count1 > count2)
2878 {
2879 i = count2;
2880 count2 = count1;
2881 count1 = i;
2882 }
2883 if (count2 > (count1 + count1))
2884 return(2);
2885 i = 0;
2886 while ((c1[i] != (char) NULL) && (c2[i] != (char) NULL) && (c1[i] == c2[i]) && (att1[i] == att2[i]))
2887 i++;
2888 count1 = i + 1;
2889 if ((count1 == 1) && (count2 == 1))
2890 count1 = 0; /* both lines blank */
2891 else if (count2 == count1)
2892 count1 = -1; /* equal */
2893 else
2894 count1 = count2 / count1; /* lines unequal */
2895 return(count1);
2896 }
2897
2898 struct _line *
2899 Insert_line(int row, int end_row, WINDOW *window) /* insert line into screen */
2900 {
2901 int i;
2902 struct _line *tmp;
2903 struct _line *tmp1;
2904
2905 for (i = 0, tmp = curscr->first_line; i < window->SR; i++)
2906 tmp = tmp->next_screen;
2907 if ((end_row + window->SR) == 0)
2908 curscr->first_line = curscr->first_line->next_screen;
2909 top_of_win = tmp;
2910 /*
2911 | find bottom line to delete
2912 */
2913 for (i = 0, tmp = top_of_win; (tmp->next_screen != NULL) && (i < end_row); i++)
2914 tmp = tmp->next_screen;
2915 if (tmp->prev_screen != NULL)
2916 tmp->prev_screen->next_screen = tmp->next_screen;
2917 if (tmp->next_screen != NULL)
2918 tmp->next_screen->prev_screen = tmp->prev_screen;
2919 tmp1 = tmp;
2920 /*
2921 | clear deleted line
2922 */
2923 clear_line(tmp, 0, window->Num_cols);
2924 tmp1->number = -1;
2925 for (i = 0, tmp = curscr->first_line; (tmp->next_screen != NULL) && (i < window->SR); i++)
2926 tmp = tmp->next_screen;
2927 top_of_win = tmp;
2928 for (i = 0, tmp = top_of_win; i < row; i++)
2929 tmp = tmp->next_screen;
2930 if ((tmp->prev_screen != NULL) && (window->Num_lines > 0))
2931 tmp->prev_screen->next_screen = tmp1;
2932 tmp1->prev_screen = tmp->prev_screen;
2933 tmp->prev_screen = tmp1;
2934 tmp1->next_screen = tmp;
2935 if ((row + window->SR) == 0)
2936 curscr->first_line = tmp1;
2937 if (tmp1->next_screen != NULL)
2938 tmp1 = tmp1->next_screen;
2939
2940 if ((!String_table[cs__]) && (end_row < window->Num_lines))
2941 {
2942 Position(window, (window->SR + end_row), 0);
2943 String_Out(String_table[dl__], NULL, 0);
2944 }
2945 Position(window, (window->SR + row), 0);
2946 if (String_table[al__] != NULL)
2947 String_Out(String_table[al__], NULL, 0);
2948 else
2949 String_Out(String_table[sr__], NULL, 0);
2950
2951 for (i = 0, top_of_win = curscr->first_line; (top_of_win->next_screen != NULL) && (i < window->SR); i++)
2952 top_of_win = top_of_win->next_screen;
2953 return(tmp1);
2954 }
2955
2956
2957 struct _line *
2958 Delete_line(int row, int end_row, struct _line *window)
2959 /* delete a line on screen */
2960 {
2961 int i;
2962 struct _line *tmp;
2963 struct _line *tmp1;
2964 struct _line *tmp2;
2965
2966 i = 0;
2967 tmp = curscr->first_line;
2968 while (i < window->SR)
2969 {
2970 i++;
2971 tmp = tmp->next_screen;
2972 }
2973 /*
2974 | find line to delete
2975 */
2976 top_of_win = tmp;
2977 if ((row + window->SR) == 0)
2978 curscr->first_line = top_of_win->next_screen;
2979 for (i = 0, tmp = top_of_win; i < row; i++)
2980 tmp = tmp->next_screen;
2981 if (tmp->prev_screen != NULL)
2982 tmp->prev_screen->next_screen = tmp->next_screen;
2983 if (tmp->next_screen != NULL)
2984 tmp->next_screen->prev_screen = tmp->prev_screen;
2985 tmp2 = tmp->next_screen;
2986 tmp1 = tmp;
2987 /*
2988 | clear deleted line
2989 */
2990 clear_line(tmp1, 0, window->Num_cols);
2991 tmp1->number = -1;
2992 /*
2993 | find location to insert deleted line
2994 */
2995 for (i = 0, tmp = curscr->first_line; (tmp->next_screen != NULL) && (i < window->SR); i++)
2996 tmp = tmp->next_screen;
2997 top_of_win = tmp;
2998 for (i = 0, tmp = top_of_win; (i < end_row) && (tmp->next_screen != NULL); i++)
2999 tmp = tmp->next_screen;
3000 tmp1->next_screen = tmp;
3001 tmp1->prev_screen = tmp->prev_screen;
3002 if (tmp1->prev_screen != NULL)
3003 tmp1->prev_screen->next_screen = tmp1;
3004 tmp->prev_screen = tmp1;
3005
3006 Position(window, (window->SR + row), 0);
3007 String_Out(String_table[dl__], NULL, 0);
3008 if ((!String_table[cs__]) && (end_row < window->Num_lines))
3009 {
3010 Position(window, (window->SR + end_row), 0);
3011 String_Out(String_table[al__], NULL, 0);
3012 }
3013 else if ((String_table[cs__] != NULL) && (String_table[dl__] == NULL))
3014 {
3015 Position(window, (window->SR + end_row), 0);
3016 putchar('\n');
3017 }
3018
3019 if (row == (window->Num_lines-1))
3020 tmp2 = tmp1;
3021 if ((row + window->SR) == 0)
3022 curscr->first_line = top_of_win = tmp2;
3023 return(tmp2);
3024 }
3025
3026 void
3027 CLEAR_TO_EOL(WINDOW *window, int row, int column)
3028 {
3029 int x, y;
3030 struct _line *tmp1;
3031
3032 for (y = 0, tmp1 = curscr->first_line; (y < (window->SR+row)) && (tmp1->next_screen != NULL); y++)
3033 tmp1 = tmp1->next_screen;
3034 for (x = column; x<window->Num_cols; x++)
3035 {
3036 tmp1->row[x] = ' ';
3037 tmp1->attributes[x] = (char) NULL;
3038 }
3039 tmp1->row[column] = (char) NULL;
3040 tmp1->last_char = column;
3041 if (column < COLS)
3042 {
3043 if (STAND)
3044 {
3045 STAND = FALSE;
3046 Position(window, row, column);
3047 attribute_off();
3048 }
3049 if (String_table[ce__] != NULL)
3050 String_Out(String_table[ce__], NULL, 0);
3051 else
3052 {
3053 for (x = column; x < window->Num_cols; x++)
3054 putchar(' ');
3055 Curr_x = x;
3056 }
3057 }
3058 }
3059
3060 int
3061 check_delete(WINDOW *window, int line, int offset, struct _line *pointer_new,
3062 struct _line *pointer_old)
3063 {
3064 int end_old;
3065 int end_new;
3066 int k;
3067 int changed;
3068 char *old_lin;
3069 char *new_lin;
3070 char *old_att;
3071 char *new_att;
3072
3073 changed = FALSE;
3074 new_lin = pointer_new->row;
3075 new_att = pointer_new->attributes;
3076 old_lin = pointer_old->row;
3077 old_att = pointer_old->attributes;
3078 end_old = end_new = offset;
3079 while (((new_lin[end_new] != old_lin[end_old]) || (new_att[end_new] != old_att[end_old])) && (old_lin[end_old] != (char) NULL) && (new_lin[end_old] != (char) NULL))
3080 end_old++;
3081 if (old_lin[end_old] != (char) NULL)
3082 {
3083 k = 0;
3084 while ((old_lin[end_old+k] == new_lin[end_new+k]) && (new_att[end_new+k] == old_att[end_old+k]) && (new_lin[end_new+k] != (char) NULL) && (old_lin[end_old+k] != (char) NULL) && (k < 10))
3085 k++;
3086 if ((k > 8) || ((new_lin[end_new+k] == (char) NULL) && (k != 0)))
3087 {
3088 if (new_lin[end_new+k] == (char) NULL)
3089 {
3090 Position(window, line, (end_new+k));
3091 CLEAR_TO_EOL(window, line, (end_new+k));
3092 }
3093 Position(window, line, offset);
3094 for (k = offset; k < end_old; k++)
3095 Char_del(old_lin, old_att, offset, window->Num_cols);
3096 while ((old_lin[offset] != (char) NULL) && (offset < COLS))
3097 offset++;
3098 pointer_old->last_char = offset;
3099 changed = TRUE;
3100 }
3101 }
3102 return(changed);
3103 }
3104
3105 /*
3106 | Check if characters were inserted in the middle of a line, and if
3107 | so, insert them.
3108 */
3109
3110 int
3111 check_insert(WINDOW *window, int line, int offset, struct _line *pointer_new,
3112 struct _line *pointer_old)
3113 {
3114 int changed;
3115 int end_old, end_new;
3116 int k;
3117 int same = FALSE;
3118 int old_off;
3119 int insert;
3120 char *old_lin;
3121 char *new_lin;
3122 char *old_att;
3123 char *new_att;
3124
3125 changed = FALSE;
3126 new_lin = pointer_new->row;
3127 new_att = pointer_new->attributes;
3128 old_lin = pointer_old->row;
3129 old_att = pointer_old->attributes;
3130 end_old = end_new = offset;
3131 while (((new_lin[end_new] != old_lin[end_old]) || (new_att[end_new] != old_att[end_old])) && (new_lin[end_new] != (char) NULL) && (old_lin[end_new] != (char) NULL))
3132 end_new++;
3133 if (new_lin[end_new] != (char) NULL)
3134 {
3135 k = 0;
3136 while ((old_lin[end_old+k] == new_lin[end_new+k]) && (old_att[end_old+k] == new_att[end_new+k]) && (new_lin[end_new+k] != (char) NULL) && (old_lin[end_old+k] != (char) NULL) && (k < 10))
3137 k++;
3138 /*
3139 | check for commonality between rest of lines (are the old
3140 | and new lines the same, except for a chunk in the middle?)
3141 | if the rest of the lines are common, do not insert text
3142 */
3143 old_off = end_new;
3144 while ((old_lin[old_off] != (char) NULL) && (new_lin[old_off] != (char) NULL) && (old_lin[old_off] == new_lin[old_off]) && (old_att[old_off] == new_att[old_off]))
3145 old_off++;
3146 if ((old_lin[old_off] == new_lin[old_off]) && (old_att[old_off] == new_att[old_off]))
3147 same = TRUE;
3148 if ((!same) && ((k > 8) || ((new_lin[end_new+k] == (char) NULL) && (k != 0))))
3149 {
3150 Position(window, line, offset);
3151 insert = FALSE;
3152 if (String_table[ic__] == NULL)
3153 {
3154 String_Out(String_table[im__], NULL, 0);
3155 insert = TRUE;
3156 }
3157 for (k = offset; k < end_new; k++)
3158 {
3159 if (!insert)
3160 String_Out(String_table[ic__], NULL, 0);
3161 Char_ins(old_lin, old_att, new_lin[k], new_att[k], k, window->Num_cols);
3162 }
3163 if (insert)
3164 String_Out(String_table[ei__], NULL, 0);
3165 while ((old_lin[offset] != (char) NULL) && (offset < COLS))
3166 offset++;
3167 pointer_old->last_char = offset;
3168 changed = TRUE;
3169 }
3170 }
3171 return(changed);
3172 }
3173
3174 void
3175 doupdate(void)
3176 {
3177 WINDOW *window;
3178 int similar;
3179 int diff;
3180 int begin_old, begin_new;
3181 int end_old, end_new;
3182 int count1, j;
3183 int from_top, tmp_ft, offset;
3184 int changed;
3185 int first_time;
3186 int first_same;
3187 int last_same;
3188 int list[10];
3189
3190 struct _line *curr;
3191 struct _line *virt;
3192 struct _line *old;
3193
3194 struct _line *new;
3195
3196 char *cur_lin;
3197 char *vrt_lin;
3198 char *cur_att;
3199 char *vrt_att;
3200 char *att1, *att2;
3201 char *c1, *c2;
3202
3203 char NC_chinese = FALSE; /* flag to indicate handling Chinese */
3204
3205 window = virtual_scr;
3206
3207 if ((nc_attributes & A_NC_BIG5) != 0)
3208 NC_chinese = TRUE;
3209
3210 if (Repaint_screen)
3211 {
3212 if (String_table[cl__])
3213 String_Out(String_table[cl__], NULL, 0);
3214 else
3215 {
3216 from_top = 0;
3217 while (from_top < LINES)
3218 {
3219 Position(curscr, from_top, 0);
3220 if (String_table[ce__] != NULL)
3221 String_Out(String_table[ce__], NULL, 0);
3222 else
3223 {
3224 for (j = 0; j < window->Num_cols; j++)
3225 putchar(' ');
3226 }
3227 from_top++;
3228 }
3229 }
3230 for (from_top = 0, curr = curscr->first_line; from_top < curscr->Num_lines; from_top++, curr = curr->next_screen)
3231 {
3232 Position(curscr, from_top, 0);
3233 for (j = 0; (curr->row[j] != (char) NULL) && (j < curscr->Num_cols); j++)
3234 {
3235 Char_out(curr->row[j], curr->attributes[j], curr->row, curr->attributes, j);
3236 }
3237 if (STAND)
3238 {
3239 STAND = FALSE;
3240 Position(curscr, from_top, j);
3241 attribute_off();
3242 }
3243 }
3244 Repaint_screen = FALSE;
3245 }
3246
3247 similar = 0;
3248 diff = FALSE;
3249 top_of_win = curscr->first_line;
3250
3251 for (from_top = 0, curr = top_of_win, virt = window->first_line;
3252 from_top < window->Num_lines; from_top++)
3253 {
3254 virtual_lines[from_top] = TRUE;
3255 if ((similar = Comp_line(curr, virt)) > 0)
3256 {
3257 virtual_lines[from_top] = FALSE;
3258 diff = TRUE;
3259 }
3260 curr = curr->next_screen;
3261 virt = virt->next_screen;
3262 }
3263
3264 from_top = 0;
3265 virt = window->first_line;
3266 curr = top_of_win;
3267 similar = 0;
3268 /*
3269 | if the window has lines that are different, check for scrolling
3270 */
3271 if (diff)
3272 {
3273 last_same = -1;
3274 changed = FALSE;
3275 for (first_same = window->Num_lines;
3276 (first_same > from_top) && (virtual_lines[first_same - 1]);
3277 first_same--)
3278 ;
3279 count1 = first_same - 1;
3280 for (last_same = 0;
3281 (last_same < window->Num_lines) && (virtual_lines[last_same]== FALSE);
3282 last_same++)
3283 ;
3284 while ((from_top < first_same) && nc_scrolling_ability)
3285 /* check entire lines for diffs */
3286 {
3287
3288
3289 if (from_top >= last_same)
3290 {
3291 for (last_same = from_top;
3292 (last_same < window->Num_lines) &&
3293 (virtual_lines[last_same] == FALSE);
3294 last_same++)
3295 ;
3296 }
3297 if (!virtual_lines[from_top])
3298 {
3299 diff = TRUE;
3300 /*
3301 | check for lines deleted (scroll up)
3302 */
3303 for (tmp_ft = from_top+1, old = curr->next_screen;
3304 ((window->scroll_up) && (diff) &&
3305 (tmp_ft < last_same) &&
3306 (!virtual_lines[tmp_ft]));
3307 tmp_ft++)
3308 {
3309 if ((Comp_line(old, virt) == -1) && (!virtual_lines[from_top]))
3310 {
3311 if (String_table[cs__]) /* scrolling region */
3312 {
3313 list[1] = from_top;
3314 list[0] = min((last_same - 1), (window->Num_lines - 1));
3315 String_Out(String_table[cs__], list, 2);
3316 Curr_y = Curr_x = -1;
3317 }
3318
3319 for (offset = (tmp_ft - from_top); (offset > 0); offset--)
3320 {
3321 old = Delete_line(from_top, min((last_same - 1), (window->Num_lines - 1)), window);
3322 diff = FALSE;
3323 }
3324
3325 if (String_table[cs__]) /* scrolling region */
3326 {
3327 list[1] = 0;
3328 list[0] = LINES - 1;
3329 String_Out(String_table[cs__], list, 2);
3330 Curr_y = Curr_x = -1;
3331 }
3332
3333 top_of_win = curscr->first_line;
3334 curr = top_of_win;
3335 for (offset = 0; offset < from_top; offset++)
3336 curr = curr->next_screen;
3337 for (offset = from_top, old=curr, new=virt;
3338 offset < window->Num_lines;
3339 old=old->next_screen, new=new->next_screen,
3340 offset++)
3341 {
3342 similar = Comp_line(old, new);
3343 virtual_lines[offset] = (similar > 0 ? FALSE : TRUE);
3344 }
3345 }
3346 else
3347 old = old->next_screen;
3348 }
3349 /*
3350 | check for lines inserted (scroll down)
3351 */
3352 for (tmp_ft = from_top-1, old = curr->prev_screen;
3353 ((window->scroll_down) && (tmp_ft >= 0) &&
3354 (diff) &&
3355 (!virtual_lines[tmp_ft]));
3356 tmp_ft--)
3357 {
3358 if (Comp_line(old, virt) == -1)
3359 {
3360 if (String_table[cs__]) /* scrolling region */
3361 {
3362 list[1] = tmp_ft;
3363 list[0] = min((last_same - 1), (window->Num_lines - 1));
3364 String_Out(String_table[cs__], list, 2);
3365 Curr_y = Curr_x = -1;
3366 }
3367
3368 for (offset = (from_top - tmp_ft); (offset > 0); offset--)
3369 {
3370 old = Insert_line(tmp_ft, min((last_same - 1), (window->Num_lines -1)), window);
3371 diff = FALSE;
3372 }
3373
3374 if (String_table[cs__]) /* scrolling region */
3375 {
3376 list[1] = 0;
3377 list[0] = LINES - 1;
3378 String_Out(String_table[cs__], list, 2);
3379 Curr_y = Curr_x = -1;
3380 }
3381
3382 top_of_win = curscr->first_line;
3383 curr = top_of_win;
3384 for (offset = 0; offset < from_top; offset++)
3385 curr = curr->next_screen;
3386 for (offset = from_top, old=curr, new=virt;
3387 offset < window->Num_lines;
3388 old=old->next_screen, new=new->next_screen,
3389 offset++)
3390 {
3391 similar = Comp_line(old, new);
3392 virtual_lines[offset] = (similar > 0 ? FALSE : TRUE);
3393 }
3394 }
3395 else
3396 old = old->prev_screen;
3397 }
3398 }
3399 from_top++;
3400 curr = curr->next_screen;
3401 virt = virt->next_screen;
3402 }
3403 }
3404
3405
3406 /*
3407 | Scrolling done, now need to insert, delete, or modify text
3408 | within lines.
3409 */
3410
3411 for (from_top = 0, curr = curscr->first_line; from_top < window->SR; from_top++)
3412 curr = curr->next_screen;
3413 top_of_win = curr;
3414 for (from_top = 0, curr = top_of_win, virt = window->first_line; from_top < window->Num_lines; from_top++, curr = curr->next_screen, virt = virt->next_screen)
3415 {
3416
3417 /*
3418 | If either 'insert mode' or 'insert char' are
3419 | available, enter the following 'if' statement,
3420 | else, need to simply rewrite the contents of the line
3421 | at the point where the contents of the line change.
3422 */
3423
3424 if (((String_table[ic__]) || (String_table[im__])) &&
3425 (String_table[dc__]) && (curr->row[0] != (char) NULL) &&
3426 (!NC_chinese))
3427 {
3428 j = 0;
3429 first_time = TRUE;
3430 vrt_lin = virt->row;
3431 vrt_att = virt->attributes;
3432 cur_lin = curr->row;
3433 cur_att = curr->attributes;
3434 while ((vrt_lin[j] != (char) NULL) && (j < window->Num_cols))
3435 {
3436 if ((STAND) && (Booleans[xs__]))
3437 {
3438 while ((vrt_lin[j] == cur_lin[j]) && (vrt_att[j] == cur_att[j]) && (vrt_lin[j] != (char) NULL) && (vrt_att[j]))
3439 j++;
3440 if ((STAND) && (!vrt_att[j]))
3441 {
3442 STAND = FALSE;
3443 Position(window, from_top, j);
3444 attribute_off();
3445 attribute_off();
3446 }
3447 }
3448 else
3449 {
3450 while ((vrt_lin[j] == cur_lin[j]) && (vrt_att[j] == cur_att[j]) && (vrt_lin[j] != (char) NULL))
3451 j++;
3452 }
3453 if ((vrt_att[j] != cur_att[j]) && (cur_att[j]) && (Booleans[xs__]))
3454 {
3455 Position(window, from_top, j);
3456 /* CLEAR_TO_EOL(window, from_top, j);*/
3457 attribute_off();
3458 attribute_off();
3459 }
3460 if (vrt_lin[j] != (char) NULL)
3461 {
3462 begin_new = j;
3463 begin_old = j;
3464 end_old = j;
3465 end_new = j;
3466 if ((first_time) && (virt->changed))
3467 {
3468 if (curr->last_char <= virt->last_char)
3469 changed = check_insert(window, from_top, j, virt, curr);
3470 }
3471 changed = check_delete(window, from_top, j, virt, curr);
3472 first_time = FALSE;
3473 virt->changed = FALSE;
3474 if (!changed)
3475 changed = check_insert(window, from_top, j, virt, curr);
3476 if (((!changed) || (cur_lin[j] != vrt_lin[j]) || (cur_att[j] != vrt_att[j])) && (j < window->Num_cols))
3477 {
3478 if ((vrt_lin[j] == ' ') && (cur_lin[j] == (char) NULL) && (vrt_att[j] == cur_att[j]))
3479 cur_lin[j] = ' ';
3480 else
3481 {
3482 Position(window, from_top, j);
3483 Char_out(vrt_lin[j], vrt_att[j], cur_lin, cur_att, j);
3484 }
3485 }
3486 if ((vrt_lin[j] != (char) NULL))
3487 j++;
3488 }
3489 if ((STAND) && (!vrt_att[j]))
3490 {
3491 STAND = FALSE;
3492 Position(window, from_top, j);
3493 attribute_off();
3494 }
3495 }
3496 if ((vrt_lin[j] == (char) NULL) && (cur_lin[j] != (char) NULL))
3497 {
3498 Position(window, from_top, j);
3499 CLEAR_TO_EOL(window, from_top, j);
3500 }
3501 }
3502 else /*if ((similar != -1) && (similar != 0))*/
3503 {
3504 j = 0;
3505 c1 = curr->row;
3506 att1 = curr->attributes;
3507 c2 = virt->row;
3508 att2 = virt->attributes;
3509 while ((j < window->Num_cols) && (c2[j] != (char) NULL))
3510 {
3511 while ((c1[j] == c2[j]) && (att1[j] == att2[j]) && (j < window->Num_cols) && (c2[j] != (char) NULL))
3512 j++;
3513
3514 /*
3515 | if previous character is an eight bit
3516 | char, start redraw from that character
3517 */
3518
3519 if ((NC_chinese) && (highbitset(c1[j - 1])))
3520 j--;
3521 begin_old = j;
3522 begin_new = j;
3523 if ((j < window->Num_cols) && (c2[j] != (char) NULL))
3524 {
3525 Position(window, from_top, begin_old);
3526 CLEAR_TO_EOL(window, from_top, j);
3527 Position(window, from_top, begin_old);
3528 for (j = begin_old; (c2[j] != (char) NULL) && (j < window->Num_cols); j++)
3529 Char_out(c2[j], att2[j], c1, att1, j);
3530 }
3531 }
3532 if ((c2[j] == (char) NULL) && (c1[j] != (char) NULL))
3533 {
3534 Position(window, from_top, j);
3535 CLEAR_TO_EOL(window, from_top, j);
3536 }
3537 }
3538 if (STAND)
3539 {
3540 STAND = FALSE;
3541 Position(window, from_top, j);
3542 attribute_off();
3543 }
3544 virt->number = from_top;
3545 }
3546 Position(window, window->LY, window->LX);
3547 }
3548
3549 void
3550 Position(WINDOW *window, int row, int col)
3551 /* position the cursor for output on the screen */
3552 {
3553 int list[10];
3554 int place;
3555
3556 int pos_row;
3557 int pos_column;
3558
3559 pos_row = row + window->SR;
3560 pos_column = col + window->SC;
3561 if ((pos_row != Curr_y) || (pos_column != Curr_x))
3562 {
3563 if (String_table[cm__] != NULL) /* && (row < window->Num_lines) && (column < window->Num_cols))*/
3564 {
3565 place = 0;
3566 list[place++] = pos_column;
3567 list[place++] = pos_row;
3568 String_Out(String_table[cm__], list, place);
3569 if ((STAND) && (!Booleans[ms__]))
3570 attribute_on();
3571 }
3572 Curr_x = pos_column;
3573 Curr_y = pos_row;
3574 }
3575 }
3576
3577 void
3578 Char_del(char *line, char *attrib, int offset, int maxlen)
3579 /* delete chars from line */
3580 {
3581 int one, two;
3582
3583 for (one = offset, two = offset+1; (line[one] != (char) NULL) && (one < maxlen); one++, two++)
3584 {
3585 line[one] = line[two];
3586 attrib[one] = attrib[two];
3587 }
3588 String_Out(String_table[dc__], NULL, 0);
3589 }
3590
3591 void
3592 Char_ins(char *line, char *attrib, char newc, char newatt, int offset,
3593 int maxlen) /* insert chars in line */
3594 {
3595 int one, two;
3596
3597 one = 0;
3598 while ((line[one] != (char) NULL) && (one < (maxlen - 2)))
3599 one++;
3600 for (two = one + 1; (two > offset); one--, two--)
3601 {
3602 line[two] = line[one];
3603 attrib[two] = attrib[one];
3604 }
3605 line[offset] = newc;
3606 attrib[offset] = newatt;
3607 Char_out(newc, newatt, line, attrib, offset);
3608 }
3609
3610 void
3611 attribute_on(void)
3612 {
3613 if (String_table[sa__])
3614 {
3615 attributes_set[0] = 1;
3616 String_Out(String_table[sa__], attributes_set, 1);
3617 }
3618 else if (String_table[so__])
3619 String_Out(String_table[so__], NULL, 0);
3620 }
3621
3622 void
3623 attribute_off(void)
3624 {
3625 if (String_table[me__])
3626 String_Out(String_table[me__], NULL, 0);
3627 else if (String_table[sa__])
3628 {
3629 attributes_set[0] = 0;
3630 String_Out(String_table[sa__], attributes_set, 1);
3631 }
3632 else if (String_table[se__])
3633 String_Out(String_table[se__], NULL, 0);
3634 }
3635
3636 void
3637 Char_out(char newc, char newatt, char *line, char *attrib, int offset)
3638 /* output character with proper attribute */
3639 {
3640
3641
3642 if ((newatt) && (!STAND))
3643 {
3644 STAND = TRUE;
3645 attribute_on();
3646 }
3647 else if ((STAND) && (!newatt))
3648 {
3649 STAND = FALSE;
3650 attribute_off();
3651 }
3652
3653 if ((newatt) && (STAND) && (Booleans[xs__]))
3654 {
3655 attribute_on();
3656 }
3657
3658 if (!((Curr_y >= (LINES - 1)) && (Curr_x >= (COLS - 1))))
3659 {
3660 putchar(newc);
3661 line[offset] = newc;
3662 attrib[offset] = newatt;
3663 }
3664 Curr_x++;
3665 }
3666
3667 /*
3668 |
3669 | The two routines that follow, nc_setattrib(), nc_clearattrib(), are
3670 | hacks that notify new_curse to handle characters that have the high
3671 | bit set as the first of two bytes of a multi-byte string.
3672 |
3673 */
3674
3675 void
3676 nc_setattrib(int flag)
3677 {
3678 nc_attributes |= flag;
3679 }
3680
3681 void
3682 nc_clearattrib(int flag)
3683 {
3684 nc_attributes &= ~flag;
3685 }
3686
DragonFly BSD