Commit | Line | Data |
---|---|---|
15637ed4 RG |
1 | /* |
2 | * Copyright (c) 1988 The Regents of the University of California. | |
3 | * All rights reserved. | |
4 | * | |
5 | * This code is derived from software contributed to Berkeley by | |
6 | * Timothy C. Stoehr. | |
7 | * | |
8 | * Redistribution and use in source and binary forms, with or without | |
9 | * modification, are permitted provided that the following conditions | |
10 | * are met: | |
11 | * 1. Redistributions of source code must retain the above copyright | |
12 | * notice, this list of conditions and the following disclaimer. | |
13 | * 2. Redistributions in binary form must reproduce the above copyright | |
14 | * notice, this list of conditions and the following disclaimer in the | |
15 | * documentation and/or other materials provided with the distribution. | |
16 | * 3. All advertising materials mentioning features or use of this software | |
17 | * must display the following acknowledgement: | |
18 | * This product includes software developed by the University of | |
19 | * California, Berkeley and its contributors. | |
20 | * 4. Neither the name of the University nor the names of its contributors | |
21 | * may be used to endorse or promote products derived from this software | |
22 | * without specific prior written permission. | |
23 | * | |
24 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | |
25 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
26 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | |
27 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | |
28 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | |
29 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | |
30 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | |
31 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | |
32 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | |
33 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | |
34 | * SUCH DAMAGE. | |
35 | */ | |
36 | ||
37 | #ifndef lint | |
38 | static char sccsid[] = "@(#)machdep.c 5.7 (Berkeley) 2/28/91"; | |
39 | #endif /* not lint */ | |
40 | ||
41 | /* | |
42 | * machdep.c | |
43 | * | |
44 | * This source herein may be modified and/or distributed by anybody who | |
45 | * so desires, with the following restrictions: | |
46 | * 1.) No portion of this notice shall be removed. | |
47 | * 2.) Credit shall not be taken for the creation of this source. | |
48 | * 3.) This code is not to be traded, sold, or used for personal | |
49 | * gain or profit. | |
50 | * | |
51 | */ | |
52 | ||
53 | /* Included in this file are all system dependent routines. Extensive use | |
54 | * of #ifdef's will be used to compile the appropriate code on each system: | |
55 | * | |
56 | * UNIX: all UNIX systems. | |
57 | * UNIX_BSD4_2: UNIX BSD 4.2 and later, UTEK, (4.1 BSD too?) | |
58 | * UNIX_SYSV: UNIX system V | |
59 | * UNIX_V7: UNIX version 7 | |
60 | * | |
61 | * All UNIX code should be included between the single "#ifdef UNIX" at the | |
62 | * top of this file, and the "#endif" at the bottom. | |
63 | * | |
64 | * To change a routine to include a new UNIX system, simply #ifdef the | |
65 | * existing routine, as in the following example: | |
66 | * | |
67 | * To make a routine compatible with UNIX system 5, change the first | |
68 | * function to the second: | |
69 | * | |
70 | * md_function() | |
71 | * { | |
72 | * code; | |
73 | * } | |
74 | * | |
75 | * md_function() | |
76 | * { | |
77 | * #ifdef UNIX_SYSV | |
78 | * sys5code; | |
79 | * #else | |
80 | * code; | |
81 | * #endif | |
82 | * } | |
83 | * | |
84 | * Appropriate variations of this are of course acceptible. | |
85 | * The use of "#elseif" is discouraged because of non-portability. | |
86 | * If the correct #define doesn't exist, "UNIX_SYSV" in this case, make it up | |
87 | * and insert it in the list at the top of the file. Alter the CFLAGS | |
88 | * in you Makefile appropriately. | |
89 | * | |
90 | */ | |
91 | ||
92 | #ifdef UNIX | |
93 | ||
94 | #include <stdio.h> | |
95 | #include <sys/types.h> | |
96 | #include <sys/file.h> | |
97 | #include <sys/stat.h> | |
98 | #include <pwd.h> | |
99 | ||
100 | #ifdef UNIX_BSD4_2 | |
101 | #include <sys/time.h> | |
102 | #include <sgtty.h> | |
103 | #endif | |
104 | ||
105 | #ifdef UNIX_SYSV | |
106 | #include <time.h> | |
107 | #include <termio.h> | |
108 | #endif | |
109 | ||
110 | #include <signal.h> | |
111 | #include "rogue.h" | |
112 | #include "pathnames.h" | |
113 | ||
114 | /* md_slurp: | |
115 | * | |
116 | * This routine throws away all keyboard input that has not | |
117 | * yet been read. It is used to get rid of input that the user may have | |
118 | * typed-ahead. | |
119 | * | |
120 | * This function is not necessary, so it may be stubbed. The might cause | |
121 | * message-line output to flash by because the game has continued to read | |
122 | * input without waiting for the user to read the message. Not such a | |
123 | * big deal. | |
124 | */ | |
125 | ||
126 | md_slurp() | |
127 | { | |
128 | (void)fpurge(stdin); | |
129 | } | |
130 | ||
131 | /* md_control_keyboard(): | |
132 | * | |
133 | * This routine is much like md_cbreak_no_echo_nonl() below. It sets up the | |
134 | * keyboard for appropriate input. Specifically, it prevents the tty driver | |
135 | * from stealing characters. For example, ^Y is needed as a command | |
136 | * character, but the tty driver intercepts it for another purpose. Any | |
137 | * such behavior should be stopped. This routine could be avoided if | |
138 | * we used RAW mode instead of CBREAK. But RAW mode does not allow the | |
139 | * generation of keyboard signals, which the program uses. | |
140 | * | |
141 | * The parameter 'mode' when true, indicates that the keyboard should | |
142 | * be set up to play rogue. When false, it should be restored if | |
143 | * necessary. | |
144 | * | |
145 | * This routine is not strictly necessary and may be stubbed. This may | |
146 | * cause certain command characters to be unavailable. | |
147 | */ | |
148 | ||
149 | md_control_keybord(mode) | |
150 | boolean mode; | |
151 | { | |
152 | static boolean called_before = 0; | |
153 | #ifdef UNIX_BSD4_2 | |
154 | static struct ltchars ltc_orig; | |
155 | static struct tchars tc_orig; | |
156 | struct ltchars ltc_temp; | |
157 | struct tchars tc_temp; | |
158 | #endif | |
159 | #ifdef UNIX_SYSV | |
160 | static struct termio _oldtty; | |
161 | struct termio _tty; | |
162 | #endif | |
163 | ||
164 | if (!called_before) { | |
165 | called_before = 1; | |
166 | #ifdef UNIX_BSD4_2 | |
167 | ioctl(0, TIOCGETC, &tc_orig); | |
168 | ioctl(0, TIOCGLTC, <c_orig); | |
169 | #endif | |
170 | #ifdef UNIX_SYSV | |
171 | ioctl(0, TCGETA, &_oldtty); | |
172 | #endif | |
173 | } | |
174 | #ifdef UNIX_BSD4_2 | |
175 | ltc_temp = ltc_orig; | |
176 | tc_temp = tc_orig; | |
177 | #endif | |
178 | #ifdef UNIX_SYSV | |
179 | _tty = _oldtty; | |
180 | #endif | |
181 | ||
182 | if (!mode) { | |
183 | #ifdef UNIX_BSD4_2 | |
184 | ltc_temp.t_suspc = ltc_temp.t_dsuspc = -1; | |
185 | ltc_temp.t_rprntc = ltc_temp.t_flushc = -1; | |
186 | ltc_temp.t_werasc = ltc_temp.t_lnextc = -1; | |
187 | tc_temp.t_startc = tc_temp.t_stopc = -1; | |
188 | #endif | |
189 | #ifdef UNIX_SYSV | |
190 | _tty.c_cc[VSWTCH] = CNSWTCH; | |
191 | #endif | |
192 | } | |
193 | #ifdef UNIX_BSD4_2 | |
194 | ioctl(0, TIOCSETC, &tc_temp); | |
195 | ioctl(0, TIOCSLTC, <c_temp); | |
196 | #endif | |
197 | #ifdef UNIX_SYSV | |
198 | ioctl(0, TCSETA, &_tty); | |
199 | #endif | |
200 | } | |
201 | ||
202 | /* md_heed_signals(): | |
203 | * | |
204 | * This routine tells the program to call particular routines when | |
205 | * certain interrupts/events occur: | |
206 | * | |
207 | * SIGINT: call onintr() to interrupt fight with monster or long rest. | |
208 | * SIGQUIT: call byebye() to check for game termination. | |
209 | * SIGHUP: call error_save() to save game when terminal hangs up. | |
210 | * | |
211 | * On VMS, SIGINT and SIGQUIT correspond to ^C and ^Y. | |
212 | * | |
213 | * This routine is not strictly necessary and can be stubbed. This will | |
214 | * mean that the game cannot be interrupted properly with keyboard | |
215 | * input, this is not usually critical. | |
216 | */ | |
217 | ||
218 | md_heed_signals() | |
219 | { | |
220 | signal(SIGINT, onintr); | |
221 | signal(SIGQUIT, byebye); | |
222 | signal(SIGHUP, error_save); | |
223 | } | |
224 | ||
225 | /* md_ignore_signals(): | |
226 | * | |
227 | * This routine tells the program to completely ignore the events mentioned | |
228 | * in md_heed_signals() above. The event handlers will later be turned on | |
229 | * by a future call to md_heed_signals(), so md_heed_signals() and | |
230 | * md_ignore_signals() need to work together. | |
231 | * | |
232 | * This function should be implemented or the user risks interrupting | |
233 | * critical sections of code, which could cause score file, or saved-game | |
234 | * file, corruption. | |
235 | */ | |
236 | ||
237 | md_ignore_signals() | |
238 | { | |
239 | signal(SIGQUIT, SIG_IGN); | |
240 | signal(SIGINT, SIG_IGN); | |
241 | signal(SIGHUP, SIG_IGN); | |
242 | } | |
243 | ||
244 | /* md_get_file_id(): | |
245 | * | |
246 | * This function returns an integer that uniquely identifies the specified | |
247 | * file. It need not check for the file's existence. In UNIX, the inode | |
248 | * number is used. | |
249 | * | |
250 | * This function is used to identify saved-game files. | |
251 | */ | |
252 | ||
253 | int | |
254 | md_get_file_id(fname) | |
255 | char *fname; | |
256 | { | |
257 | struct stat sbuf; | |
258 | ||
259 | if (stat(fname, &sbuf)) { | |
260 | return(-1); | |
261 | } | |
262 | return((int) sbuf.st_ino); | |
263 | } | |
264 | ||
265 | /* md_link_count(): | |
266 | * | |
267 | * This routine returns the number of hard links to the specified file. | |
268 | * | |
269 | * This function is not strictly necessary. On systems without hard links | |
270 | * this routine can be stubbed by just returning 1. | |
271 | */ | |
272 | ||
273 | int | |
274 | md_link_count(fname) | |
275 | char *fname; | |
276 | { | |
277 | struct stat sbuf; | |
278 | ||
279 | stat(fname, &sbuf); | |
280 | return((int) sbuf.st_nlink); | |
281 | } | |
282 | ||
283 | /* md_gct(): (Get Current Time) | |
284 | * | |
285 | * This function returns the current year, month(1-12), day(1-31), hour(0-23), | |
286 | * minute(0-59), and second(0-59). This is used for identifying the time | |
287 | * at which a game is saved. | |
288 | * | |
289 | * This function is not strictly necessary. It can be stubbed by returning | |
290 | * zeros instead of the correct year, month, etc. If your operating | |
291 | * system doesn't provide all of the time units requested here, then you | |
292 | * can provide only those that it does, and return zeros for the others. | |
293 | * If you cannot provide good time values, then users may be able to copy | |
294 | * saved-game files and play them. | |
295 | */ | |
296 | ||
297 | md_gct(rt_buf) | |
298 | struct rogue_time *rt_buf; | |
299 | { | |
300 | struct tm *t, *localtime(); | |
301 | long seconds; | |
302 | ||
303 | time(&seconds); | |
304 | t = localtime(&seconds); | |
305 | ||
306 | rt_buf->year = t->tm_year; | |
307 | rt_buf->month = t->tm_mon + 1; | |
308 | rt_buf->day = t->tm_mday; | |
309 | rt_buf->hour = t->tm_hour; | |
310 | rt_buf->minute = t->tm_min; | |
311 | rt_buf->second = t->tm_sec; | |
312 | } | |
313 | ||
314 | /* md_gfmt: (Get File Modification Time) | |
315 | * | |
316 | * This routine returns a file's date of last modification in the same format | |
317 | * as md_gct() above. | |
318 | * | |
319 | * This function is not strictly necessary. It is used to see if saved-game | |
320 | * files have been modified since they were saved. If you have stubbed the | |
321 | * routine md_gct() above by returning constant values, then you may do | |
322 | * exactly the same here. | |
323 | * Or if md_gct() is implemented correctly, but your system does not provide | |
324 | * file modification dates, you may return some date far in the past so | |
325 | * that the program will never know that a saved-game file being modified. | |
326 | * You may also do this if you wish to be able to restore games from | |
327 | * saved-games that have been modified. | |
328 | */ | |
329 | ||
330 | md_gfmt(fname, rt_buf) | |
331 | char *fname; | |
332 | struct rogue_time *rt_buf; | |
333 | { | |
334 | struct stat sbuf; | |
335 | long seconds; | |
336 | struct tm *t; | |
337 | ||
338 | stat(fname, &sbuf); | |
339 | seconds = (long) sbuf.st_mtime; | |
340 | t = localtime(&seconds); | |
341 | ||
342 | rt_buf->year = t->tm_year; | |
343 | rt_buf->month = t->tm_mon + 1; | |
344 | rt_buf->day = t->tm_mday; | |
345 | rt_buf->hour = t->tm_hour; | |
346 | rt_buf->minute = t->tm_min; | |
347 | rt_buf->second = t->tm_sec; | |
348 | } | |
349 | ||
350 | /* md_df: (Delete File) | |
351 | * | |
352 | * This function deletes the specified file, and returns true (1) if the | |
353 | * operation was successful. This is used to delete saved-game files | |
354 | * after restoring games from them. | |
355 | * | |
356 | * Again, this function is not strictly necessary, and can be stubbed | |
357 | * by simply returning 1. In this case, saved-game files will not be | |
358 | * deleted and can be replayed. | |
359 | */ | |
360 | ||
361 | boolean | |
362 | md_df(fname) | |
363 | char *fname; | |
364 | { | |
365 | if (unlink(fname)) { | |
366 | return(0); | |
367 | } | |
368 | return(1); | |
369 | } | |
370 | ||
371 | /* md_gln: (Get login name) | |
372 | * | |
373 | * This routine returns the login name of the user. This string is | |
374 | * used mainly for identifying users in score files. | |
375 | * | |
376 | * A dummy string may be returned if you are unable to implement this | |
377 | * function, but then the score file would only have one name in it. | |
378 | */ | |
379 | ||
380 | char * | |
381 | md_gln() | |
382 | { | |
383 | struct passwd *p; | |
384 | ||
385 | if (!(p = getpwuid(getuid()))) | |
386 | return((char *)NULL); | |
387 | return(p->pw_name); | |
388 | } | |
389 | ||
390 | /* md_sleep: | |
391 | * | |
392 | * This routine causes the game to pause for the specified number of | |
393 | * seconds. | |
394 | * | |
395 | * This routine is not particularly necessary at all. It is used for | |
396 | * delaying execution, which is useful to this program at some times. | |
397 | */ | |
398 | ||
399 | md_sleep(nsecs) | |
400 | int nsecs; | |
401 | { | |
402 | (void) sleep(nsecs); | |
403 | } | |
404 | ||
405 | /* md_getenv() | |
406 | * | |
407 | * This routine gets certain values from the user's environment. These | |
408 | * values are strings, and each string is identified by a name. The names | |
409 | * of the values needed, and their use, is as follows: | |
410 | * | |
411 | * TERMCAP | |
412 | * The name of the users's termcap file, NOT the termcap entries | |
413 | * themselves. This is used ONLY if the program is compiled with | |
414 | * CURSES defined (-DCURSES). Even in this case, the program need | |
415 | * not find a string for TERMCAP. If it does not, it will use the | |
416 | * default termcap file as returned by md_gdtcf(); | |
417 | * TERM | |
418 | * The name of the users's terminal. This is used ONLY if the program | |
419 | * is compiled with CURSES defined (-DCURSES). In this case, the string | |
420 | * value for TERM must be found, or the routines in curses.c cannot | |
421 | * function, and the program will quit. | |
422 | * ROGUEOPTS | |
423 | * A string containing the various game options. This need not be | |
424 | * defined. | |
425 | * HOME | |
426 | * The user's home directory. This is only used when the user specifies | |
427 | * '~' as the first character of a saved-game file. This string need | |
428 | * not be defined. | |
429 | * SHELL | |
430 | * The user's favorite shell. If not found, "/bin/sh" is assumed. | |
431 | * | |
432 | * If your system does not provide a means of searching for these values, | |
433 | * you will have to do it yourself. None of the values above really need | |
434 | * to be defined except TERM when the program is compiled with CURSES | |
435 | * defined. In this case, as a bare minimum, you can check the 'name' | |
436 | * parameter, and if it is "TERM" find the terminal name and return that, | |
437 | * else return zero. If the program is not compiled with CURSES, you can | |
438 | * get by with simply always returning zero. Returning zero indicates | |
439 | * that their is no defined value for the given string. | |
440 | */ | |
441 | ||
442 | char * | |
443 | md_getenv(name) | |
444 | char *name; | |
445 | { | |
446 | char *value; | |
447 | char *getenv(); | |
448 | ||
449 | value = getenv(name); | |
450 | ||
451 | return(value); | |
452 | } | |
453 | ||
454 | /* md_malloc() | |
455 | * | |
456 | * This routine allocates, and returns a pointer to, the specified number | |
457 | * of bytes. This routines absolutely MUST be implemented for your | |
458 | * particular system or the program will not run at all. Return zero | |
459 | * when no more memory can be allocated. | |
460 | */ | |
461 | ||
462 | char * | |
463 | md_malloc(n) | |
464 | int n; | |
465 | { | |
466 | char *malloc(); | |
467 | char *t; | |
468 | ||
469 | t = malloc(n); | |
470 | return(t); | |
471 | } | |
472 | ||
473 | /* md_gseed() (Get Seed) | |
474 | * | |
475 | * This function returns a seed for the random number generator (RNG). This | |
476 | * seed causes the RNG to begin generating numbers at some point in it's | |
477 | * sequence. Without a random seed, the RNG will generate the same set | |
478 | * of numbers, and every game will start out exactly the same way. A good | |
479 | * number to use is the process id, given by getpid() on most UNIX systems. | |
480 | * | |
481 | * You need to find some single random integer, such as: | |
482 | * process id. | |
483 | * current time (minutes + seconds) returned from md_gct(), if implemented. | |
484 | * | |
485 | * It will not help to return "get_rand()" or "rand()" or the return value of | |
486 | * any pseudo-RNG. If you don't have a random number, you can just return 1, | |
487 | * but this means your games will ALWAYS start the same way, and will play | |
488 | * exactly the same way given the same input. | |
489 | */ | |
490 | ||
491 | md_gseed() | |
492 | { | |
493 | return(getpid()); | |
494 | } | |
495 | ||
496 | /* md_exit(): | |
497 | * | |
498 | * This function causes the program to discontinue execution and exit. | |
499 | * This function must be implemented or the program will continue to | |
500 | * hang when it should quit. | |
501 | */ | |
502 | ||
503 | md_exit(status) | |
504 | int status; | |
505 | { | |
506 | exit(status); | |
507 | } | |
508 | ||
509 | /* md_lock(): | |
510 | * | |
511 | * This function is intended to give the user exclusive access to the score | |
512 | * file. It does so by "creat"ing a lock file, which can only be created | |
513 | * if it does not already exist. The file is deleted when score file | |
514 | * processing is finished. The lock file should be located in the same | |
515 | * directory as the score file. These full path names should be defined for | |
516 | * any particular site in rogue.h. The constants _PATH_SCOREFILE and | |
517 | * _PATH_LOCKFILE define these file names. | |
518 | * | |
519 | * When the parameter 'l' is non-zero (true), a lock is requested. Otherwise | |
520 | * the lock is released by removing the lock file. | |
521 | */ | |
522 | ||
523 | md_lock(l) | |
524 | boolean l; | |
525 | { | |
526 | short tries; | |
527 | char *lock_file = _PATH_LOCKFILE; | |
528 | ||
529 | if (l) { | |
530 | for (tries = 0; tries < 5; tries++) { | |
531 | if (md_get_file_id(lock_file) == -1) { | |
532 | if (creat(lock_file, 0444) != -1) { | |
533 | break; | |
534 | } else { | |
535 | message("cannot lock score file", 0); | |
536 | } | |
537 | } else { | |
538 | message("waiting to lock score file", 0); | |
539 | } | |
540 | sleep(2); | |
541 | } | |
542 | } else { | |
543 | (void) unlink(lock_file); | |
544 | } | |
545 | } | |
546 | ||
547 | /* md_shell(): | |
548 | * | |
549 | * This function spawns a shell for the user to use. When this shell is | |
550 | * terminated, the game continues. Since this program may often be run | |
551 | * setuid to gain access to privileged files, care is taken that the shell | |
552 | * is run with the user's REAL user id, and not the effective user id. | |
553 | * The effective user id is restored after the shell completes. | |
554 | */ | |
555 | ||
556 | md_shell(shell) | |
557 | char *shell; | |
558 | { | |
559 | long w[2]; | |
560 | ||
561 | if (!fork()) { | |
562 | int uid; | |
563 | ||
564 | uid = getuid(); | |
565 | setuid(uid); | |
566 | execl(shell, shell, 0); | |
567 | } | |
568 | wait(w); | |
569 | } | |
570 | ||
571 | /* If you have a viable curses/termlib library, then use it and don't bother | |
572 | * implementing the routines below. And don't compile with -DCURSES. | |
573 | */ | |
574 | ||
575 | #ifdef CURSES | |
576 | ||
577 | /* md_cbreak_no_echo_nonl: | |
578 | * | |
579 | * This routine sets up some terminal characteristics. The tty-driver | |
580 | * must be told to: | |
581 | * 1.) Not echo input. | |
582 | * 2.) Transmit input characters immediately upon typing. (cbreak mode) | |
583 | * 3.) Move the cursor down one line, without changing column, and | |
584 | * without generating a carriage-return, when it | |
585 | * sees a line-feed. This is only necessary if line-feed is ever | |
586 | * used in the termcap 'do' (cursor down) entry, in which case, | |
587 | * your system should must have a way of accomplishing this. | |
588 | * | |
589 | * When the parameter 'on' is true, the terminal is set up as specified | |
590 | * above. When this parameter is false, the terminal is restored to the | |
591 | * original state. | |
592 | * | |
593 | * Raw mode should not to be used. Keyboard signals/events/interrupts should | |
594 | * be sent, although they are not strictly necessary. See notes in | |
595 | * md_heed_signals(). | |
596 | * | |
597 | * This function must be implemented for rogue to run properly if the | |
598 | * program is compiled with CURSES defined to use the enclosed curses | |
599 | * emulation package. If you are not using this, then this routine is | |
600 | * totally unnecessary. | |
601 | * | |
602 | * Notice that information is saved between calls. This is used to | |
603 | * restore the terminal to an initial saved state. | |
604 | * | |
605 | */ | |
606 | ||
607 | md_cbreak_no_echo_nonl(on) | |
608 | boolean on; | |
609 | { | |
610 | #ifdef UNIX_BSD4_2 | |
611 | static struct sgttyb tty_buf; | |
612 | static int tsave_flags; | |
613 | ||
614 | if (on) { | |
615 | ioctl(0, TIOCGETP, &tty_buf); | |
616 | tsave_flags = tty_buf.sg_flags; | |
617 | tty_buf.sg_flags |= CBREAK; | |
618 | tty_buf.sg_flags &= ~(ECHO | CRMOD); /* CRMOD: see note 3 above */ | |
619 | ioctl(0, TIOCSETP, &tty_buf); | |
620 | } else { | |
621 | tty_buf.sg_flags = tsave_flags; | |
622 | ioctl(0, TIOCSETP, &tty_buf); | |
623 | } | |
624 | #endif | |
625 | #ifdef UNIX_SYSV | |
626 | struct termio tty_buf; | |
627 | static struct termio tty_save; | |
628 | ||
629 | if (on) { | |
630 | ioctl(0, TCGETA, &tty_buf); | |
631 | tty_save = tty_buf; | |
632 | tty_buf.c_lflag &= ~(ICANON | ECHO); | |
633 | tty_buf.c_oflag &= ~ONLCR; | |
634 | tty_buf.c_cc[4] = 1; /* MIN */ | |
635 | tty_buf.c_cc[5] = 2; /* TIME */ | |
636 | ioctl(0, TCSETAF, &tty_buf); | |
637 | } else { | |
638 | ioctl(0, TCSETAF, &tty_save); | |
639 | } | |
640 | #endif | |
641 | } | |
642 | ||
643 | /* md_gdtcf(): (Get Default Termcap File) | |
644 | * | |
645 | * This function is called ONLY when the program is compiled with CURSES | |
646 | * defined. If you use your system's curses/termlib library, this function | |
647 | * won't be called. On most UNIX systems, "/etc/termcap" suffices. | |
648 | * | |
649 | * If their is no such termcap file, then return 0, but in that case, you | |
650 | * must have a TERMCAP file returned from md_getenv("TERMCAP"). The latter | |
651 | * will override the value returned from md_gdtcf(). If the program is | |
652 | * compiled with CURSES defined, and md_gdtcf() returns 0, and | |
653 | * md_getenv("TERMCAP") returns 0, the program will have no terminal | |
654 | * capability information and will quit. | |
655 | */ | |
656 | ||
657 | char * | |
658 | md_gdtcf() | |
659 | { | |
660 | return("/etc/termcap"); | |
661 | } | |
662 | ||
663 | /* md_tstp(): | |
664 | * | |
665 | * This function puts the game to sleep and returns to the shell. This | |
666 | * only applies to UNIX 4.2 and 4.3. For other systems, the routine should | |
667 | * be provided as a do-nothing routine. md_tstp() will only be referenced | |
668 | * in the code when compiled with CURSES defined. | |
669 | * | |
670 | */ | |
671 | ||
672 | md_tstp() | |
673 | { | |
674 | #ifdef UNIX_BSD4_2 | |
675 | kill(0, SIGTSTP); | |
676 | #endif | |
677 | } | |
678 | ||
679 | #endif | |
680 | ||
681 | #endif |