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