a1ced1e4496e487fdc9a72d565db7269472e4ae0
[dragonfly.git] / games / hack / hack.tty.c
1 /*-
2  * Copyright (c) 1988, 1993
3  *      The Regents of the University of California.  All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  * 3. All advertising materials mentioning features or use of this software
14  *    must display the following acknowledgement:
15  *      This product includes software developed by the University of
16  *      California, Berkeley and its contributors.
17  * 4. Neither the name of the University nor the names of its contributors
18  *    may be used to endorse or promote products derived from this software
19  *    without specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31  * SUCH DAMAGE.
32  *
33  * @(#)hack.tty.c       8.1 (Berkeley) 5/31/93
34  * $FreeBSD: src/games/hack/hack.tty.c,v 1.6.2.1 2000/07/20 10:35:07 kris Exp $
35  * $DragonFly: src/games/hack/hack.tty.c,v 1.4 2006/08/21 19:45:32 pavalos Exp $
36  */
37
38 /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
39 /* hack.tty.c - version 1.0.3 */
40 /* With thanks to the people who sent code for SYSV - hpscdi!jon,
41    arnold@ucsf-cgl, wcs@bo95b, cbcephus!pds and others. */
42
43 #include        "hack.h"
44
45 /*
46  * The distinctions here are not BSD - rest but rather USG - rest, as
47  * BSD still has the old sgttyb structure, but SYSV has termio. Thus:
48  */
49 #ifdef BSD
50 #define V7
51 #else
52 #define USG
53 #endif /* BSD */
54
55 /*
56  * Some systems may have getchar() return EOF for various reasons, and
57  * we should not quit before seeing at least NR_OF_EOFS consecutive EOFs.
58  */
59 #ifndef BSD
60 #define NR_OF_EOFS      20
61 #endif /* BSD */
62
63
64 #ifdef USG
65
66 #include        <termio.h>
67 #define termstruct      termio
68 #define kill_sym        c_cc[VKILL]
69 #define erase_sym       c_cc[VERASE]
70 #define EXTABS          TAB3
71 #define tabflgs         c_oflag
72 #define echoflgs        c_lflag
73 #define cbrkflgs        c_lflag
74 #define CBRKMASK        ICANON
75 #define CBRKON          ! /* reverse condition */
76 #define OSPEED(x)       ((x).c_cflag & CBAUD)
77 #define GTTY(x)         (ioctl(0, TCGETA, x))
78 #define STTY(x)         (ioctl(0, TCSETA, x))   /* TCSETAF? TCSETAW? */
79
80 #else   /* V7 */
81
82 #include        <sgtty.h>
83 #define termstruct      sgttyb
84 #define kill_sym        sg_kill
85 #define erase_sym       sg_erase
86 #define EXTABS          XTABS
87 #define tabflgs         sg_flags
88 #define echoflgs        sg_flags
89 #define cbrkflgs        sg_flags
90 #define CBRKMASK        CBREAK
91 #define CBRKON          /* empty */
92 #define OSPEED(x)       (x).sg_ospeed
93 #define GTTY(x)         (ioctl(0, TIOCGETP, x))
94 #define STTY(x)         (ioctl(0, TIOCSETP, x))
95
96 #endif /* USG */
97
98 static char erase_char, kill_char;
99 static boolean settty_needed = FALSE;
100 struct termstruct inittyb, curttyb;
101
102 static void     setctty(void);
103
104 /*
105  * Get initial state of terminal, set ospeed (for termcap routines)
106  * and switch off tab expansion if necessary.
107  * Called by startup() in termcap.c and after returning from ! or ^Z
108  */
109 void
110 gettty(void)
111 {
112         if(GTTY(&inittyb) < 0)
113                 perror("Hack (gettty)");
114         curttyb = inittyb;
115         erase_char = inittyb.erase_sym;
116         kill_char = inittyb.kill_sym;
117         getioctls();
118
119         /* do not expand tabs - they might be needed inside a cm sequence */
120         if(curttyb.tabflgs & EXTABS) {
121                 curttyb.tabflgs &= ~EXTABS;
122                 setctty();
123         }
124         settty_needed = TRUE;
125 }
126
127 /* reset terminal to original state */
128 void
129 settty(const char *s)
130 {
131         clear_screen();
132         end_screen();
133         if(s) printf("%s", s);
134         fflush(stdout);
135         if(STTY(&inittyb) < 0)
136                 perror("Hack (settty)");
137         flags.echo = (inittyb.echoflgs & ECHO) ? ON : OFF;
138         flags.cbreak = (CBRKON(inittyb.cbrkflgs & CBRKMASK)) ? ON : OFF;
139         setioctls();
140 }
141
142 static void
143 setctty(void)
144 {
145         if(STTY(&curttyb) < 0)
146                 perror("Hack (setctty)");
147 }
148
149 void
150 setftty(void)
151 {
152 int ef = 0;                     /* desired value of flags & ECHO */
153 int cf = CBRKON(CBRKMASK);      /* desired value of flags & CBREAK */
154 int change = 0;
155         flags.cbreak = ON;
156         flags.echo = OFF;
157         /* Should use (ECHO|CRMOD) here instead of ECHO */
158         if((curttyb.echoflgs & ECHO) != ef){
159                 curttyb.echoflgs &= ~ECHO;
160                 change++;
161         }
162         if((curttyb.cbrkflgs & CBRKMASK) != cf){
163                 curttyb.cbrkflgs &= ~CBRKMASK;
164                 curttyb.cbrkflgs |= cf;
165 #ifdef USG
166                 /* be satisfied with one character; no timeout */
167                 curttyb.c_cc[VMIN] = 1;         /* was VEOF */
168                 curttyb.c_cc[VTIME] = 0;        /* was VEOL */
169 #endif /* USG */
170                 change++;
171         }
172         if(change){
173                 setctty();
174         }
175         start_screen();
176 }
177
178
179 /* fatal error */
180 /*VARARGS1*/
181 void
182 error(const char *s, ...)
183 {
184         va_list ap;
185         if(settty_needed)
186                 settty(NULL);
187         va_start(ap, s);
188         vprintf(s, ap);
189         va_end(ap);
190         putchar('\n');
191         exit(1);
192 }
193
194 /*
195  * Read a line closed with '\n' into the array char bufp[BUFSZ].
196  * (The '\n' is not stored. The string is closed with a '\0'.)
197  * Reading can be interrupted by an escape ('\033') - now the
198  * resulting string is "\033".
199  */
200 void
201 getlin(char *bufp)
202 {
203         char *obufp = bufp;
204         int c;
205
206         flags.toplin = 2;               /* nonempty, no --More-- required */
207         for(;;) {
208                 fflush(stdout);
209                 if((c = getchar()) == EOF) {
210                         *bufp = 0;
211                         return;
212                 }
213                 if(c == '\033') {
214                         *obufp = c;
215                         obufp[1] = 0;
216                         return;
217                 }
218                 if(c == erase_char || c == '\b') {
219                         if(bufp != obufp) {
220                                 bufp--;
221                                 putstr("\b \b"); /* putsym converts \b */
222                         } else  bell();
223                 } else if(c == '\n') {
224                         *bufp = 0;
225                         return;
226                 } else if(' ' <= c && c < '\177') {
227                                 /* avoid isprint() - some people don't have it
228                                    ' ' is not always a printing char */
229                         *bufp = c;
230                         bufp[1] = 0;
231                         putstr(bufp);
232                         if(bufp-obufp < BUFSZ-1 && bufp-obufp < COLNO)
233                                 bufp++;
234                 } else if(c == kill_char || c == '\177') { /* Robert Viduya */
235                                 /* this test last - @ might be the kill_char */
236                         while(bufp != obufp) {
237                                 bufp--;
238                                 putstr("\b \b");
239                         }
240                 } else
241                         bell();
242         }
243 }
244
245 void
246 getret(void)
247 {
248         cgetret("");
249 }
250
251 void
252 cgetret(const char *s)
253 {
254         putsym('\n');
255         if(flags.standout)
256                 standoutbeg();
257         putstr("Hit ");
258         putstr(flags.cbreak ? "space" : "return");
259         putstr(" to continue: ");
260         if(flags.standout)
261                 standoutend();
262         xwaitforspace(s);
263 }
264
265 char morc;      /* tell the outside world what char he used */
266
267 void
268 xwaitforspace(const char *s)    /* chars allowed besides space or return */
269 {
270 int c;
271
272         morc = 0;
273
274         while((c = readchar()) != '\n') {
275             if(flags.cbreak) {
276                 if(c == ' ') break;
277                 if(s && index(s,c)) {
278                         morc = c;
279                         break;
280                 }
281                 bell();
282             }
283         }
284 }
285
286 char *
287 parse(void)
288 {
289         static char inputline[COLNO];
290         int foo;
291
292         flags.move = 1;
293         if(!Invisible) curs_on_u(); else home();
294         while((foo = readchar()) >= '0' && foo <= '9')
295                 multi = 10*multi+foo-'0';
296         if(multi) {
297                 multi--;
298                 save_cm = inputline;
299         }
300         inputline[0] = foo;
301         inputline[1] = 0;
302         if(foo == 'f' || foo == 'F'){
303                 inputline[1] = getchar();
304 #ifdef QUEST
305                 if(inputline[1] == foo) inputline[2] = getchar(); else
306 #endif /* QUEST */
307                 inputline[2] = 0;
308         }
309         if(foo == 'm' || foo == 'M'){
310                 inputline[1] = getchar();
311                 inputline[2] = 0;
312         }
313         clrlin();
314         return(inputline);
315 }
316
317 char
318 readchar(void)
319 {
320         int sym;
321
322         fflush(stdout);
323         if((sym = getchar()) == EOF)
324 #ifdef NR_OF_EOFS
325         { /*
326            * Some SYSV systems seem to return EOFs for various reasons
327            * (?like when one hits break or for interrupted systemcalls?),
328            * and we must see several before we quit.
329            */
330                 int cnt = NR_OF_EOFS;
331                 while (cnt--) {
332                     clearerr(stdin);    /* omit if clearerr is undefined */
333                     if((sym = getchar()) != EOF) goto noteof;
334                 }
335                 end_of_input();
336              noteof:    ;
337         }
338 #else
339                 end_of_input();
340 #endif /* NR_OF_EOFS */
341         if(flags.toplin == 1)
342                 flags.toplin = 2;
343         return((char) sym);
344 }
345
346 void
347 end_of_input(void)
348 {
349         settty("End of input?\n");
350         clearlocks();
351         exit(0);
352 }