![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sysdep.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / emacs / src|
Return to sysdep.c CVS log | Up to [Apple XNU] / GNUtools / emacs / src |
1.1 root 1: /* Interfaces to system-dependent kernel and library entries.
2: Copyright (C) 1985, 1986, 1987, 1988, 1990 Free Software Foundation, Inc.
3:
4: This file is part of GNU Emacs.
5:
6: GNU Emacs is free software; you can redistribute it and/or modify
7: it under the terms of the GNU General Public License as published by
8: the Free Software Foundation; either version 1, or (at your option)
9: any later version.
10:
11: GNU Emacs is distributed in the hope that it will be useful,
12: but WITHOUT ANY WARRANTY; without even the implied warranty of
13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14: GNU General Public License for more details.
15:
16: You should have received a copy of the GNU General Public License
17: along with GNU Emacs; see the file COPYING. If not, write to
18: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
19:
20:
21: /* This must precede sys/signal.h on certain machines. */
22: #include <sys/types.h>
23: #include <signal.h>
24: #include <setjmp.h>
25:
26: #include "config.h"
27: #include "lisp.h"
28: #undef NULL
29:
30: #define min(x,y) ((x) > (y) ? (y) : (x))
31:
32: /* In this file, open, read and write refer to the system calls,
33: not our sugared interfaces sys_open, sys_read and sys_write.
34: Contrariwise, for systems where we use the system calls directly,
35: define sys_read, etc. here as aliases for them. */
36: #ifndef read
37: #define sys_read read
38: #define sys_write write
39: #endif /* `read' is not a macro */
40:
41: #undef read
42: #undef write
43:
44: #ifndef close
45: #define sys_close close
46: #else
47: #undef close
48: #endif
49:
50: #ifndef open
51: #define sys_open open
52: #else /* `open' is a macro */
53: #undef open
54: #endif /* `open' is a macro */
55:
56: #include <stdio.h>
57: #include <sys/stat.h>
58: #include <errno.h>
59:
60: extern int errno;
61: #ifndef VMS
62: extern char *sys_errlist[];
63: #endif
64:
65: #ifdef VMS
66: #include <rms.h>
67: #include <ttdef.h>
68: #include <tt2def.h>
69: #include <iodef.h>
70: #include <ssdef.h>
71: #include <descrip.h>
72: #include <fibdef.h>
73: #include <atrdef.h>
74: #include <ctype.h>
75: #include <string.h>
76: #ifdef __GNUC__
77: #include <sys/file.h>
78: #else
79: #include <file.h>
80: #endif
81: #undef F_SETFL
82: #ifndef RAB$C_BID
83: #include <rab.h>
84: #endif
85: #define MAXIOSIZE ( 32 * PAGESIZE ) /* Don't I/O more than 32 blocks at a time */
86: #endif /* VMS */
87:
88: #ifndef BSD4_1
89: #ifdef BSD /* this is done this way to avoid defined (BSD) || defined (USG)
90: because the vms compiler doesn't grok `defined' */
91: #include <fcntl.h>
92: #endif
93: #ifdef USG
94: #include <fcntl.h>
95: #endif
96: #endif /* not 4.1 bsd */
97:
98: /* Get DGUX definition for FASYNC - DJB */
99: #ifdef DGUX
100: #include <sys/file.h>
101: #endif /* DGUX */
102:
103: #ifdef BSD
104: #include <sys/ioctl.h>
105: #ifdef BSD4_1
106: #include <wait.h>
107: #else /* not 4.1 */
108: #include <sys/wait.h>
109: #endif /* not 4.1 */
110: #endif /* BSD */
111:
112: #ifdef STRIDE
113: #include <sys/ioctl.h>
114: #endif
115:
116: #ifdef NEED_TERMIOS
117: #include <sys/termios.h>
118: #endif
119:
120: #ifdef mips
121: #include <sys/ioctl.h>
122: #endif
123:
124: #ifdef _SEQUENT_
125: #include <sys/stropts.h>
126: #endif /* _SEQUENT_ */
127:
128: #ifdef AIX
129: /* Get files for keyboard remapping */
130: #define HFNKEYS 2
131: #include <sys/hft.h>
132: #include <sys/devinfo.h>
133: #endif
134:
135: /* Get rid of LLITOUT in 4.1, since it is said to stimulate kernel bugs. */
136: #ifdef BSD4_1
137: #undef LLITOUT
138: #define LLITOUT 0
139: #endif /* 4.1 */
140:
141: #ifdef HAVE_TERMIO
142: #if defined(AIX) && defined(i386)
143: #include <termios.h> /* needs to be before termio.h for aix ps/2 */
144: #endif
145: #ifndef NO_TERMIO
146: #include <termio.h>
147: #endif
148: #ifdef HAVE_TCATTR
149: #define TERMINAL struct termios
150: #else /* not HAVE_TCATTR */
151: #define TERMINAL struct termio
152: #endif /* not HAVE_TCATTR */
153:
154: #ifdef IBMR2AIX
155: #include <termios.h>
156: #ifdef TIOCGETP
157: #undef TIOCGETP
158: #endif /* no TIOCGETP */
159: #define TIOCGETP TCGETS
160: #undef TIOCSETN
161: #define TIOCSETN TCSETSW
162: #undef TIOCSETP
163: #define TIOCSETP TCSETSF
164: #undef TCSETAW
165: #define TCSETAW TCSETS
166: #else /* not IBMR2AIX */
167: #ifdef HAVE_TCATTR
168: #include <termios.h>
169: #endif /* HAVE_TCATTR */
170: #undef TIOCGETP
171: #define TIOCGETP TCGETA
172: #undef TIOCSETN
173: #define TIOCSETN TCSETAW
174: #undef TIOCSETP
175: #define TIOCSETP TCSETAF
176: #endif /* not IBMR2AIX */
177:
178: /* Try to establish the correct character to disable terminal functions
179: in a system-independent manner. Note that USG (at least) define
180: _POSIX_VDISABLE as 0! */
181: #ifdef _POSIX_VDISABLE
182: #define CDISABLE _POSIX_VDISABLE
183: #else /* not _POSIX_VDISABLE */
184: #ifdef CDEL
185: #define CDISABLE CDEL
186: #else /* not CDEL */
187: #define CDISABLE 255
188: #endif /* not CDEL */
189: #endif /* not _POSIX_VDISABLE */
190:
191: #ifndef OSPEED
192: #define OSPEED(str) (str.c_cflag & CBAUD)
193: #endif
194: #ifndef SETOSPEED
195: #define SETOSPEED(str,new) (str.c_cflag = (str.c_cflag & ~CBAUD) | (new))
196: #endif
197: #define TABS_OK(str) ((str.c_oflag & TABDLY) != TAB3)
198: #endif /* HAVE_TERMIO */
199:
200: #ifndef HAVE_TCATTR /* If HAVE_TCATTR, this is a primitive. */
201: #define tcgetattr(fd, addr) ioctl (fd, TIOCGETP, addr)
202: #endif
203:
204: #ifdef XENIX
205: #undef TIOCGETC /* Avoid confusing some conditionals that test this. */
206: #endif
207:
208: #ifdef BROKEN_TIOCGETC
209: #undef TIOCGETC
210: #endif
211:
212: #ifdef BROKEN_TIOCGWINSZ
213: #undef TIOCGWINSZ
214: #endif
215:
216: #ifndef HAVE_TERMIO
217: #ifndef VMS
218: #if defined(DGUX) && defined(_BSD_TTY_FLAVOR)
219: #undef _BSD_TTY_FLAVOR
220: /* DGUX 4.3 has it's own definition in sgtty.h, and it's different
221: than the one in s-dgux.h */
222: #endif
223: #include <sgtty.h>
224: #define TERMINAL struct sgttyb
225: #ifndef OSPEED
226: #define OSPEED(str) str.sg_ospeed
227: #endif
228: #ifndef SETOSPEED
229: #define SETOSPEED(str,new) (str.sg_ospeed = (new))
230: #endif
231: #define TABS_OK(str) ((str.sg_flags & XTABS) != XTABS)
232: #undef TCSETAW
233: #define TCSETAW TIOCSETN
234: #endif /* not VMS */
235: #endif /* not HAVE_TERMIO */
236:
237: #ifdef USG
238: #include <sys/utsname.h>
239: #include <string.h>
240: #ifndef MEMORY_IN_STRING_H
241: #include <memory.h>
242: #endif
243: #ifdef TIOCGWINSZ
244: #ifndef IRIS_4D
245: #ifndef mips
246: #ifndef aix386
247: #ifndef NO_SIOCTL_H
248: /* Some USG systems with TIOCGWINSZ need this file; some don't have it.
249: We don't know how to distinguish them.
250: If this #include gets an error, just delete it. */
251: #include <sys/sioctl.h>
252: #endif
253: #ifdef NEED_PTEM_H
254: #include <sys/stream.h>
255: #include <sys/ptem.h>
256: #endif
257: #endif /* not aix386 */
258: #endif /* not mips */
259: #endif /* not IRIS_4D */
260: #endif /* TIOCGWINSZ */
261: #ifdef HAVE_TIMEVAL
262: #ifdef HPUX
263: #include <time.h>
264: #else
265: #include <sys/time.h>
266: #endif
267: #endif /* HAVE_TIMEVAL */
268: #endif /* USG */
269:
270: #ifdef VMS
271: #include "window.h"
272: #endif
273:
274: #ifdef NEED_BSDTTY
275: #include <sys/bsdtty.h>
276: #endif
277:
278: #if defined (HPUX) && defined (HAVE_PTYS)
279: #include <sys/ptyio.h>
280: #endif
281:
282: #ifdef AIX
283: #include <sys/pty.h>
284: #include <unistd.h>
285: #endif /* AIX */
286:
287: #ifdef SYSV_PTYS
288: #include <sys/tty.h>
289: #include <sys/pty.h>
290: #endif
291:
292: #include "filetypes.h"
293:
294: /* FASYNC defined in this file. But, FASYNC don't working.
295: so no problem, because unrequest_sigio only need. */
296: #if defined (pfa)
297: #include <sys/file.h>
298: #endif
299:
300: #ifdef BROKEN_FIONREAD
301: #undef FIONREAD
302: #undef FASYNC
303: #endif
304:
305: extern int quit_char;
306:
307: #include "termhooks.h"
308: #include "termchar.h"
309: #include "termopts.h"
310: #include "dispextern.h"
311:
312: #ifdef NONSYSTEM_DIR_LIBRARY
313: #include "ndir.h"
314: #endif /* NONSYSTEM_DIR_LIBRARY */
315:
316: #include "emacssignal.h"
317:
318: /* Define SIGCHLD as an alias for SIGCLD. There are many conditionals
319: testing SIGCHLD. */
320:
321: #ifndef VMS
322: #ifdef SIGCLD
323: #ifndef SIGCHLD
324: #define SIGCHLD SIGCLD
325: #endif /* not SIGCHLD */
326: #endif /* SIGCLD */
327: #endif /* not VMS */
328:
329: static int baud_convert[] =
330: #ifdef BAUD_CONVERT
331: BAUD_CONVERT;
332: #else
333: {
334: 0, 50, 75, 110, 135, 150, 200, 300, 600, 1200,
335: 1800, 2400, 4800, 9600, 19200, 38400
336: };
337: #endif
338:
339: extern short ospeed;
340:
341: #ifdef VMS
342: static struct iosb
343: {
344: short status;
345: short offset;
346: short termlen;
347: short term;
348: } input_iosb;
349:
350: int kbd_input_ast ();
351:
352: int waiting_for_ast;
353: int stop_input;
354: int input_ef = 0;
355: int timer_ef = 0;
356: int process_ef = 0;
357: int input_eflist;
358: int timer_eflist;
359:
360: static int input_chan;
361: static $DESCRIPTOR (input_dsc, "TT");
362: static int terminator_mask[2] = { 0, 0 };
363:
364: static struct sensemode {
365: short status;
366: unsigned char xmit_baud;
367: unsigned char rcv_baud;
368: unsigned char crfill;
369: unsigned char lffill;
370: unsigned char parity;
371: unsigned char unused;
372: char class;
373: char type;
374: short scr_wid;
375: unsigned long tt_char : 24, scr_len : 8;
376: unsigned long tt2_char;
377: } sensemode_iosb;
378: #define TERMINAL struct sensemode
379: #define OSPEED(str) (str.xmit_baud)
380: #define TABS_OK(str) ((str.tt_char & TT$M_MECHTAB) != 0)
381: #endif /* VMS */
382:
383: discard_tty_input ()
384: {
385: TERMINAL buf;
386:
387: if (noninteractive)
388: return;
389:
390: /* Discarding input is not safe when the input could contain
391: replies from the X server. So don't do it. */
392: if (read_socket_hook)
393: return;
394:
395: #ifdef VMS
396: end_kbd_input ();
397: SYS$QIOW (0, input_chan, IO$_READVBLK|IO$M_PURGE, input_iosb, 0, 0,
398: &buf, 0, 0, terminator_mask, 0, 0);
399: queue_kbd_input ();
400: #else /* not VMS */
401: #ifdef APOLLO
402: {
403: int zero = 0;
404: ioctl (0, TIOCFLUSH, &zero);
405: }
406: #else /* not Apollo */
407: tcgetattr (0, &buf);
408: #ifndef HAVE_TCATTR
409: ioctl (0, TIOCSETP, &buf);
410: #else
411: tcsetattr (0, TCSAFLUSH, &buf);
412: #endif
413: #endif /* not Apollo */
414: #endif /* not VMS */
415: }
416:
417: #ifdef SIGTSTP
418:
419: stuff_char (c)
420: char c;
421: {
422: /* Should perhaps error if in batch mode */
423: #ifdef TIOCSTI
424: ioctl (0, TIOCSTI, &c);
425: #else /* no TIOCSTI */
426: error ("Cannot stuff terminal input characters in this version of Unix.");
427: #endif /* no TIOCSTI */
428: }
429:
430: #endif /* SIGTSTP */
431:
432: init_baud_rate ()
433: {
434: TERMINAL sg;
435:
436: if (noninteractive)
437: ospeed = 0;
438: else
439: {
440: #ifdef VMS
441: SYS$QIOW (0, input_chan, IO$_SENSEMODE, &sg, 0, 0,
442: &sg.class, 12, 0, 0, 0, 0 );
443: #else
444: SETOSPEED (sg, B9600);
445: tcgetattr (0, &sg);
446: #endif /* not VMS */
447: ospeed = OSPEED (sg);
448: }
449:
450: baud_rate = (ospeed < sizeof baud_convert / sizeof baud_convert[0]
451: ? baud_convert[ospeed] : 9600);
452: if (baud_rate == 0)
453: baud_rate = 1200;
454: }
455:
456: /*ARGSUSED*/
457: set_exclusive_use (fd)
458: int fd;
459: {
460: #ifdef FIOCLEX
461: ioctl (fd, FIOCLEX, 0);
462: #endif
463: /* Ok to do nothing if this feature does not exist */
464: }
465:
466: #ifndef subprocesses
467:
468: wait_without_blocking ()
469: {
470: #ifdef BSD
471: wait3 (0, WNOHANG | WUNTRACED, 0);
472: #else
473: croak ("wait_without_blocking");
474: #endif
475: }
476:
477: #endif /* not subprocesses */
478:
479: int wait_debugging; /* Set nonzero to make following function work under dbx
480: (at least for bsd). */
481:
482: /* Wait for subprocess with process id `pid' to terminate and
483: make sure it will get eliminated (not remain forever as a zombie) */
484:
485: wait_for_termination (pid)
486: int pid;
487: {
488: while (1)
489: {
490: #ifdef subprocesses
491: #if defined (BSD) || (defined (HPUX) && !defined (HPUX_5))
492: /* Note that kill returns -1 even if the process is just a zombie now.
493: But inevitably a SIGCHLD interrupt should be generated
494: and child_sig will do wait3 and make the process go away. */
495: /* There is some indication that there is a bug involved with
496: termination of subprocesses, perhaps involving a kernel bug too,
497: but no idea what it is. Just as a hunch we signal SIGCHLD to see
498: if that causes the problem to go away or get worse. */
499: #ifdef BSD4_1
500: extern int synch_process_pid;
501: sighold (SIGCHLD);
502: if (synch_process_pid == 0)
503: {
504: sigrelse (SIGCHLD);
505: break;
506: }
507: if (wait_debugging)
508: sleep (1);
509: else
510: sigpause (SIGCHLD);
511: #else /* not BSD4_1 */
512: sigsetmask (sigmask (SIGCHLD));
513: if (0 > kill (pid, 0))
514: {
515: sigsetmask (SIGEMPTYMASK);
516: kill (getpid (), SIGCHLD);
517: break;
518: }
519: if (wait_debugging)
520: sleep (1);
521: else
522: sigpause (SIGEMPTYMASK);
523: #endif /* not BSD4_1 */
524: #else /* not BSD, and not HPUX version >= 6 */
525: #ifdef UNIPLUS
526: if (0 > kill (pid, 0))
527: break;
528: wait (0);
529: #else /* neither BSD nor UNIPLUS: random sysV */
530: #ifdef HAVE_SYSV_SIGPAUSE
531: sighold (SIGCHLD);
532: if (0 > kill (pid, 0))
533: {
534: sigrelse (SIGCHLD);
535: break;
536: }
537: sigpause (SIGCHLD);
538: #else /* not HAVE_SYSV_SIGPAUSE */
539: if (0 > kill (pid, 0))
540: break;
541: /* Using sleep instead of pause avoids timing error.
542: If the inferior dies just before the sleep,
543: we lose just one second. */
544: sleep (1);
545: #endif /* not HAVE_SYSV_SIGPAUSE */
546: #endif /* not UNIPLUS */
547: #endif /* not BSD, and not HPUX version >= 6 */
548: #else /* not subprocesses */
549: #ifndef BSD4_1
550: if (0 > kill (pid, 0))
551: break;
552: sleep (1);
553: #else /* BSD4_1 */
554: int status;
555: status = wait (0);
556: if (status == pid || status == -1)
557: break;
558: #endif /* BSD4_1 */
559: #endif /* not subprocesses */
560: }
561: }
562:
563: #ifdef subprocesses
564:
565: /*
566: * flush any pending output
567: * (may flush input as well; it does not matter the way we use it)
568: */
569:
570: flush_pending_output (channel)
571: int channel;
572: {
573: #ifdef TCFLSH
574: ioctl (channel, TCFLSH, 1);
575: #else
576: #ifdef TIOCFLUSH
577: int zero = 0;
578: /* 3rd arg should be ignored
579: but some 4.2 kernels actually want the address of an int
580: and nonzero means something different. */
581: ioctl (channel, TIOCFLUSH, &zero);
582: #endif
583: #endif
584: }
585:
586: /* Set up the terminal at the other end of a pseudo-terminal that
587: we will be controlling an inferior through.
588: It should not echo or do line-editing, since that is done
589: in Emacs. No padding needed for insertion into an Emacs buffer. */
590:
591: child_setup_tty (out)
592: int out;
593: {
594: TERMINAL s;
595:
596: tcgetattr (out, &s);
597: #ifdef HAVE_TERMIO
598: s.c_oflag |= OPOST; /* Enable output postprocessing */
599: s.c_oflag &= ~ONLCR; /* Disable map of NL to CR-NL on output */
600: s.c_oflag &= ~(NLDLY|CRDLY|TABDLY|BSDLY|VTDLY|FFDLY); /* No output delays */
601: s.c_lflag &= ~ECHO; /* Disable echo */
602: s.c_lflag |= ISIG; /* Enable signals */
603: s.c_iflag &= ~IUCLC; /* Disable map of upper case to lower on input */
604: s.c_oflag &= ~OLCUC; /* Disable map of lower case to upper on output */
605: /* said to be unnecesary
606: s.c_cc[VMIN] = 1; /* minimum number of characters to accept
607: s.c_cc[VTIME] = 0; /* wait forever for at least 1 character
608: */
609: s.c_lflag |= ICANON; /* Enable erase/kill and eof processing */
610: s.c_cc[VEOF] = 04; /* insure that EOF is Control-D */
611: s.c_cc[VERASE] = 0377; /* disable erase processing */
612: s.c_cc[VKILL] = 0377; /* disable kill processing */
613: #ifdef IRIS_4D /* This is needed for the sake of process_send_signal.
614: Probably a wide class of systems need something like this,
615: but in 18.58, let's be cautious. */
616: s.c_cc[VSWTCH] = 032;
617: #endif
618: #ifdef HPUX
619: s.c_cflag = (s.c_cflag & ~CBAUD) | B9600; /* baud rate sanity */
620: #endif /* HPUX */
621:
622: #ifdef AIX
623: /* AIX enhanced edit loses NULs, so disable it */
624: #ifndef IBMR2AIX
625: s.c_line = 0;
626: s.c_iflag &= ~ASCEDIT;
627: #endif
628: /* Also, PTY overloads NUL and BREAK.
629: don't ignore break, but don't signal either, so it looks like NUL. */
630: s.c_iflag &= ~IGNBRK;
631: s.c_iflag &= ~BRKINT;
632: #if defined(TIOCGPGRP) && defined(TIOCGLTC) && defined(TIOCGETC)
633: /* the QUIT and INTR character are used in process_send_signal
634: so set them here to something useful. */
635: if (s.c_cc[VQUIT] == 0377)
636: s.c_cc[VQUIT] = '\\'&037; /* Control-\ */
637: if (s.c_cc[VINTR] == 0377)
638: s.c_cc[VINTR] = 'C'&037; /* Control-C */
639: #else /* no TIOCGPGRP or no TIOCGLTC or no TIOCGETC */
640: /* QUIT and INTR are sent using system calls, so disable character forms. */
641: s.c_cc[VQUIT] = 0377;
642: s.c_cc[VINTR] = 0377;
643: s.c_lflag &= ~ISIG;
644: #endif /* no TIOCGPGRP or no TIOCGLTC or no TIOCGETC */
645: s.c_cc[VEOL] = 0377;
646: s.c_cflag = (s.c_cflag & ~CBAUD) | B9600; /* baud rate sanity */
647: #endif /* AIX */
648:
649: #else /* not HAVE_TERMIO */
650: s.sg_flags &= ~(ECHO | CRMOD | ANYP | ALLDELAY | RAW | LCASE | CBREAK | TANDEM);
651: s.sg_erase = 0377;
652: s.sg_kill = 0377;
653: #endif /* not HAVE_TERMIO */
654:
655: #ifndef HAVE_TCATTR
656: ioctl (out, TIOCSETN, &s);
657: #else
658: tcsetattr (out, TCSADRAIN, &s);
659: #endif
660:
661: #ifdef BSD4_1
662: if (interrupt_input)
663: reset_sigio ();
664: #endif /* BSD4_1 */
665: #ifdef RTU
666: {
667: int zero = 0;
668: ioctl (out, FIOASYNC, &zero);
669: }
670: #endif /* RTU */
671: }
672:
673: #endif /* subprocesses */
674:
675: /*ARGSUSED*/
676: setpgrp_of_tty (pid)
677: int pid;
678: {
679: #ifdef IBMR2AIX
680: tcsetpgrp ( 0, pid);
681: #else
682: #ifdef TIOCSPGRP
683: ioctl (0, TIOCSPGRP, &pid);
684: #else
685: /* Just ignore this for now and hope for the best */
686: #endif
687: #endif
688: }
689:
690: /* Record a signal code and the handler for it. */
691: struct save_signal
692: {
693: int code;
694: int (*handler) ();
695: };
696:
697: /* Suspend the Emacs process; give terminal to its superior. */
698:
699: sys_suspend ()
700: {
701: #ifdef VMS
702: unsigned long parent_id;
703:
704: parent_id = getppid ();
705: if (parent_id && parent_id != 0xffffffff)
706: {
707: int oldsig = (int) signal (SIGINT, SIG_IGN);
708: int status = LIB$ATTACH (&parent_id) & 1;
709: signal (SIGINT, oldsig);
710: return status;
711: }
712: return -1;
713: #else
714: #ifdef SIGTSTP
715: #ifdef BSD
716: killpg (getpgrp (0), SIGTSTP);
717: #else
718: kill (-getpgrp (0), SIGTSTP);
719: #endif
720:
721: #else
722: #ifdef USG_JOBCTRL /* If you don't know what this is don't mess with it */
723: ptrace (0, 0, 0, 0); /* set for ptrace - caught by csh */
724: kill (getpid (), SIGQUIT);
725:
726: #else
727:
728: /* On a system where suspending is not implemented,
729: instead fork a subshell and let it talk directly to the terminal
730: while we wait. */
731: int pid = fork ();
732: struct save_signal saved_handlers[5];
733:
734: saved_handlers[0].code = SIGINT;
735: saved_handlers[1].code = SIGQUIT;
736: saved_handlers[2].code = SIGTERM;
737: #ifdef SIGIO
738: saved_handlers[3].code = SIGIO;
739: saved_handlers[4].code = 0;
740: #else
741: saved_handlers[3].code = 0;
742: #endif
743:
744: if (pid == -1)
745: error ("Can't spawn subshell");
746: if (pid == 0)
747: {
748: char *sh;
749:
750: sh = (char *) egetenv ("SHELL");
751: if (sh == 0)
752: sh = "sh";
753: /* Use our buffer's default directory for the subshell. */
754: {
755: Lisp_Object dir;
756: unsigned char *str;
757: int len;
758:
759: /* mentioning current_buffer->buffer would mean including buffer.h,
760: which somehow wedges the hp compiler. So instead... */
761:
762: dir = intern ("default-directory");
763: /* Can't use NULL */
764: if (XFASTINT (Fboundp (dir)) == XFASTINT (Qnil))
765: goto xyzzy;
766: dir = Fsymbol_value (dir);
767: if (XTYPE (dir) != Lisp_String)
768: goto xyzzy;
769:
770: str = (unsigned char *) alloca (XSTRING (dir)->size + 2);
771: len = XSTRING (dir)->size;
772: bcopy (XSTRING (dir)->data, str, len);
773: if (str[len - 1] != '/') str[len++] = '/';
774: str[len] = 0;
775: chdir (str);
776: }
777: xyzzy:
778: #ifdef subprocesses
779: close_process_descs (); /* Close Emacs's pipes/ptys */
780: #endif
781: execlp (sh, sh, 0);
782: write (1, "Can't execute subshell", 22);
783: _exit (1);
784: }
785: save_signal_handlers (saved_handlers);
786: wait_for_termination (pid);
787: restore_signal_handlers (saved_handlers);
788: #endif /* no USG_JOBCTRL */
789: #endif /* no SIGTSTP */
790: #endif /* not VMS */
791: }
792:
793: save_signal_handlers (saved_handlers)
794: struct save_signal *saved_handlers;
795: {
796: while (saved_handlers->code)
797: {
798: saved_handlers->handler
799: = (int (*) ()) signal (saved_handlers->code, SIG_IGN);
800: saved_handlers++;
801: }
802: }
803:
804: restore_signal_handlers (saved_handlers)
805: struct save_signal *saved_handlers;
806: {
807: while (saved_handlers->code)
808: {
809: signal (saved_handlers->code, saved_handlers->handler);
810: saved_handlers++;
811: }
812: }
813:
814: #ifdef F_SETFL
815:
816: int old_fcntl_flags;
817:
818: init_sigio ()
819: {
820: #ifdef FASYNC
821: old_fcntl_flags = fcntl (0, F_GETFL, 0) & ~FASYNC;
822: #endif
823: request_sigio ();
824: }
825:
826: reset_sigio ()
827: {
828: unrequest_sigio ();
829: }
830:
831: #ifdef FASYNC /* F_SETFL does not imply existance of FASYNC */
832:
833: request_sigio ()
834: {
835: #ifdef SIGWINCH
836: sigunblock (sigmask (SIGWINCH));
837: #endif
838: fcntl (0, F_SETFL, old_fcntl_flags | FASYNC);
839:
840: interrupts_deferred = 0;
841: }
842:
843: unrequest_sigio ()
844: {
845: #ifdef SIGWINCH
846: sigblock (sigmask (SIGWINCH));
847: #endif
848: fcntl (0, F_SETFL, old_fcntl_flags);
849: interrupts_deferred = 1;
850: }
851:
852: #else /* no FASYNC */
853: #ifdef STRIDE /* Stride doesn't have FASYNC - use FIOASYNC */
854:
855: request_sigio ()
856: {
857: int on = 1;
858: ioctl (0, FIOASYNC, &on);
859: interrupts_deferred = 0;
860: }
861:
862: unrequest_sigio ()
863: {
864: int off = 0;
865:
866: ioctl (0, FIOASYNC, &off);
867: interrupts_deferred = 1;
868: }
869:
870: #else /* not FASYNC, not STRIDE */
871:
872: request_sigio ()
873: {
874: croak ("request_sigio");
875: }
876:
877: unrequest_sigio ()
878: {
879: croak ("unrequest_sigio");
880: }
881:
882: #endif /* STRIDE */
883: #endif /* FASYNC */
884: #endif /* F_SETFL */
885:
886: TERMINAL old_gtty; /* The initial tty mode bits */
887:
888: int term_initted; /* 1 if outer tty status has been recorded */
889:
890: #ifdef F_SETOWN
891: int old_fcntl_owner;
892: #endif /* F_SETOWN */
893:
894: #ifdef TIOCGLTC
895: struct ltchars old_ltchars;
896: #endif /* TIOCGLTC */
897:
898: #ifdef TIOCGETC
899: struct tchars old_tchars;
900: int old_lmode;
901:
902: int lmode; /* Current lmode value. */
903: /* Needed as global for 4.1 */
904: #endif /* TIOCGETC */
905:
906: /* This may also be defined in stdio,
907: but if so, this does no harm,
908: and using the same name avoids wasting the other one's space. */
909:
910: #if defined (USG) || defined (DGUX)
911: unsigned char _sobuf[BUFSIZ+8];
912: #else
913: char _sobuf[BUFSIZ];
914: #endif
915:
916: #ifdef TIOCGLTC
917: static struct ltchars new_ltchars = {-1,-1,-1,-1,-1,-1};
918: #endif
919: #ifdef TIOCGETC
920: static struct tchars new_tchars = {-1,-1,-1,-1,-1,-1};
921: #endif
922:
923: init_sys_modes ()
924: {
925: TERMINAL tty;
926: #ifdef TIOCGETC
927: struct tchars tchars;
928: #endif
929: #ifdef VMS
930: #if 0
931: static int oob_chars[2] = {0, 1 << 7}; /* catch C-g's */
932: extern int (*interrupt_signal) ();
933: #endif
934: #endif
935:
936: if (noninteractive)
937: return;
938:
939: #ifdef VMS
940: if (!input_ef)
941: LIB$GET_EF (&input_ef);
942: SYS$CLREF (input_ef);
943: waiting_for_ast = 0;
944: if (!timer_ef)
945: LIB$GET_EF (&timer_ef);
946: SYS$CLREF (timer_ef);
947: if (!process_ef)
948: {
949: LIB$GET_EF (&process_ef);
950: SYS$CLREF (process_ef);
951: }
952: if (input_ef / 32 != process_ef / 32)
953: croak ("Input and process event flags in different clusters.");
954: if (input_ef / 32 != timer_ef / 32)
955: croak ("Input and process event flags in different clusters.");
956: input_eflist = ((unsigned) 1 << (input_ef % 32)) |
957: ((unsigned) 1 << (process_ef % 32));
958: timer_eflist = ((unsigned) 1 << (input_ef % 32)) |
959: ((unsigned) 1 << (timer_ef % 32));
960: SYS$QIOW (0, input_chan, IO$_SENSEMODE, &old_gtty, 0, 0,
961: &old_gtty.class, 12, 0, 0, 0, 0);
962: #ifndef VMS4_4
963: sys_access_reinit ();
964: #endif
965: #else /* not VMS */
966: tcgetattr (0, &old_gtty);
967: #endif /* not VMS */
968: if (!read_socket_hook)
969: {
970: tty = old_gtty;
971:
972: #ifdef HAVE_TERMIO
973: tty.c_iflag |= (IGNBRK); /* Ignore break condition */
974: tty.c_iflag &= ~ICRNL; /* Disable map of CR to NL on input */
975: #ifdef ISTRIP
976: tty.c_iflag &= ~ISTRIP; /* don't strip 8th bit on input */
977: #endif
978: tty.c_lflag &= ~ECHO; /* Disable echo */
979: tty.c_lflag &= ~ICANON; /* Disable erase/kill processing */
980: #ifdef IEXTEN
981: tty.c_iflag &= ~IEXTEN; /* Disable other editing characters. */
982: #endif
983: tty.c_lflag |= ISIG; /* Enable signals */
984: if (flow_control)
985: {
986: tty.c_iflag |= IXON; /* Enable start/stop output control */
987: #ifdef IXANY
988: tty.c_iflag &= ~IXANY;
989: #endif /* IXANY */
990: }
991: else
992: tty.c_iflag &= ~IXON; /* Disable start/stop output control */
993: tty.c_oflag &= ~ONLCR; /* Disable map of NL to CR-NL on output */
994: tty.c_oflag &= ~TAB3; /* Disable tab expansion */
995: #ifdef CS8
996: tty.c_cflag |= CS8; /* allow 8th bit on input */
997: tty.c_cflag &= ~PARENB; /* Don't check parity */
998: #endif
999: tty.c_cc[VINTR] = quit_char; /* ^G gives SIGINT */
1000: /* Set up C-g (usually) for both SIGQUIT and SIGINT.
1001: We don't know which we will get, but we handle both alike
1002: so which one it really gives us does not matter. */
1003: tty.c_cc[VQUIT] = quit_char;
1004: tty.c_cc[VMIN] = 1; /* Input should wait for at least 1 char */
1005: tty.c_cc[VTIME] = 0; /* no matter how long that takes. */
1006: #ifdef VSWTCH
1007: tty.c_cc[VSWTCH] = CDISABLE; /* Turn off shell layering use of C-z */
1008: #endif /* VSWTCH */
1009: #if defined (mips) || defined (HAVE_TCATTR)
1010: #ifdef VSUSP
1011: tty.c_cc[VSUSP] = CDISABLE; /* Turn off mips handling of C-z. */
1012: #endif /* VSUSP */
1013: #ifdef V_DSUSP
1014: tty.c_cc[V_DSUSP] = CDISABLE; /* Turn off mips handling of C-y. */
1015: #endif /* V_DSUSP */
1016: #ifdef VDSUSP /* Some systems use VDSUSP instead of VD_SUSP. */
1017: tty.c_cc[VDSUSP] = CDISABLE;
1018: #endif /* VDSUSP */
1019: #endif /* mips or HAVE_TCATTR */
1020:
1021: #ifdef AIX
1022: #ifndef IBMR2AIX
1023: /* AIX enhanced edit loses NULs, so disable it */
1024: tty.c_line = 0;
1025: tty.c_iflag &= ~ASCEDIT;
1026: #else
1027: tty.c_cc[VSTRT] = 255;
1028: tty.c_cc[VSTOP] = 255;
1029: tty.c_cc[VSUSP] = 255;
1030: tty.c_cc[VDSUSP] = 255;
1031: #endif /* IBMR2AIX */
1032: /* Also, PTY overloads NUL and BREAK.
1033: don't ignore break, but don't signal either, so it looks like NUL.
1034: This really serves a purpose only if running in an XTERM window
1035: or via TELNET or the like, but does no harm elsewhere. */
1036: tty.c_iflag &= ~IGNBRK;
1037: tty.c_iflag &= ~BRKINT;
1038: #endif /* AIX */
1039:
1040: #else /* if not HAVE_TERMIO */
1041: #ifdef VMS
1042: tty.tt_char |= TT$M_NOECHO | TT$M_EIGHTBIT;
1043: if (flow_control)
1044: tty.tt_char |= TT$M_TTSYNC;
1045: else
1046: tty.tt_char &= ~TT$M_TTSYNC;
1047: tty.tt2_char |= TT2$M_PASTHRU | TT2$M_XON;
1048: #else /* not VMS (BSD, that is) */
1049: tty.sg_flags &= ~(ECHO | CRMOD | XTABS);
1050: tty.sg_flags |= ANYP;
1051: tty.sg_flags |= interrupt_input ? RAW : CBREAK;
1052: #endif /* not VMS (BSD, that is) */
1053: #endif /* not HAVE_TERMIO */
1054:
1055: #ifdef VMS
1056: SYS$QIOW (0, input_chan, IO$_SETMODE, &input_iosb, 0, 0,
1057: &tty.class, 12, 0, 0, 0, 0);
1058: #else
1059: #ifndef HAVE_TCATTR
1060: ioctl (0, TIOCSETN, &tty);
1061: #else
1062: tcsetattr (0, TCSADRAIN, &tty);
1063: #endif
1064: #endif /* not VMS */
1065:
1066: /* This code added to insure that, if flow-control is not to be used,
1067: we have an unlocked screen at the start. */
1068: #ifdef TCXONC
1069: if (!flow_control) ioctl (0, TCXONC, 1);
1070: #endif
1071: #ifndef APOLLO
1072: #ifdef TIOCSTART
1073: if (!flow_control) ioctl (0, TIOCSTART, 0);
1074: #endif
1075: #endif
1076:
1077: #ifdef AIX
1078: hft_init ();
1079: #ifdef IBMR2AIX
1080: {
1081: /* IBM's HFT device usually thinks a ^J should be LF/CR. We need it
1082: to be only LF. This is the way that is done. */
1083: struct termio tty;
1084:
1085: if (ioctl (1, HFTGETID, &tty) != -1)
1086: write (1, "\033[20l", 5);
1087: }
1088: #endif
1089: #endif
1090:
1091: #ifdef F_SETFL
1092: #ifdef F_GETOWN /* F_SETFL does not imply existance of F_GETOWN */
1093: if (interrupt_input)
1094: {
1095: old_fcntl_owner = fcntl (0, F_GETOWN, 0);
1096: fcntl (0, F_SETOWN, getpid ());
1097: init_sigio ();
1098: }
1099: #endif /* F_GETOWN */
1100: #endif /* F_SETFL */
1101:
1102: /* If going to use CBREAK mode, we must request C-g to interrupt
1103: and turn off start and stop chars, etc.
1104: If not going to use CBREAK mode, do this anyway
1105: so as to turn off local flow control for user coming over
1106: network on 4.2; in this case, only t_stopc and t_startc really matter. */
1107: #ifdef TIOCGLTC
1108: ioctl (0, TIOCGLTC, &old_ltchars);
1109: #endif /* TIOCGLTC */
1110: #ifndef HAVE_TERMIO
1111: #ifdef TIOCGETC
1112: ioctl (0, TIOCGETC, &old_tchars);
1113: ioctl (0, TIOCLGET, &old_lmode);
1114:
1115: /* Note: if not using CBREAK mode, it makes no difference how we set this */
1116: tchars = new_tchars;
1117: tchars.t_intrc = quit_char;
1118: if (flow_control)
1119: {
1120: tchars.t_startc = '\021';
1121: tchars.t_stopc = '\023';
1122: }
1123: /* LPASS8 is new in 4.3, and makes cbreak mode provide all 8 bits. */
1124: #ifndef LPASS8
1125: #define LPASS8 0
1126: #endif
1127:
1128: #ifdef BSD4_1
1129: #define LNOFLSH 0100000
1130: #endif
1131:
1132: lmode = LDECCTQ | LLITOUT | LPASS8 | LNOFLSH | old_lmode;
1133:
1134: ioctl (0, TIOCSETC, &tchars);
1135: ioctl (0, TIOCLSET, &lmode);
1136: #endif /* TIOCGETC */
1137: #endif /* not HAVE_TERMIO */
1138: #ifdef TIOCGLTC
1139: ioctl (0, TIOCSLTC, &new_ltchars);
1140: #endif /* TIOCGLTC */
1141:
1142: #ifdef BSD4_1
1143: if (interrupt_input)
1144: init_sigio ();
1145: #endif
1146: #ifdef VMS
1147: /* Appears to do nothing when in PASTHRU mode.
1148: SYS$QIOW (0, input_chan, IO$_SETMODE|IO$M_OUTBAND, 0, 0, 0,
1149: interrupt_signal, oob_chars, 0, 0, 0, 0);
1150: */
1151: queue_kbd_input (0);
1152: #endif /* VMS */
1153: }
1154: #ifdef VMS /* VMS sometimes has this symbol but lacks setvbuf. */
1155: #undef _IOFBF
1156: #endif
1157: #ifdef _IOFBF
1158: /* This symbol is defined on recent USG systems.
1159: Someone says without this call USG won't really buffer the file
1160: even with a call to setbuf. */
1161: setvbuf (stdout, _sobuf, _IOFBF, sizeof _sobuf);
1162: #else
1163: setbuf (stdout, _sobuf);
1164: #endif
1165: set_terminal_modes ();
1166: if (term_initted && no_redraw_on_reenter)
1167: {
1168: if (display_completed)
1169: direct_output_forward_char (0);
1170: }
1171: else
1172: screen_garbaged = 1;
1173: term_initted = 1;
1174: }
1175:
1176: /* Return nonzero if safe to use tabs in output.
1177: At the time this is called, init_sys_modes has not been done yet. */
1178:
1179: tabs_safe_p ()
1180: {
1181: TERMINAL tty;
1182: if (noninteractive)
1183: return 1;
1184: #ifdef VMS
1185: SYS$QIOW (0, input_chan, IO$_SENSEMODE, &tty, 0, 0,
1186: &tty.class, 12, 0, 0, 0, 0);
1187: #else
1188: tcgetattr (0, &tty);
1189: #endif /* not VMS */
1190: return (TABS_OK (tty));
1191: }
1192:
1193: /* Get terminal size from system.
1194: Store number of lines into *heightp and width into *widthp.
1195: If zero or a negative number is stored, the value is not valid. */
1196:
1197: get_screen_size (widthp, heightp)
1198: int *widthp, *heightp;
1199: {
1200: /* Define the 4.3 names in terms of the Sun names
1201: if the latter exist and the former do not. */
1202: #ifdef TIOCGSIZE
1203: #ifndef TIOCGWINSZ
1204: #define TIOCGWINSZ TIOCGSIZE
1205: #define winsize ttysize
1206: #define ws_row ts_lines
1207: #define ws_col ts_cols
1208: #endif
1209: #endif /* Sun */
1210:
1211: /* Do it using the 4.3 names if possible. */
1212: #ifdef TIOCGWINSZ
1213: struct winsize size;
1214: *widthp = 0;
1215: *heightp = 0;
1216: if (ioctl (0, TIOCGWINSZ, &size) < 0)
1217: return;
1218: *widthp = size.ws_col;
1219: *heightp = size.ws_row;
1220: #else /* not TIOCGWNSIZ */
1221: #ifdef VMS
1222: TERMINAL tty;
1223: SYS$QIOW (0, input_chan, IO$_SENSEMODE, &tty, 0, 0,
1224: &tty.class, 12, 0, 0, 0, 0);
1225: *widthp = tty.scr_wid;
1226: *heightp = tty.scr_len;
1227: #else /* system doesn't know size */
1228: *widthp = 0;
1229: *heightp = 0;
1230: #endif /* system does not know size */
1231: #endif /* not TIOCGWINSZ */
1232: }
1233:
1234: reset_sys_modes ()
1235: {
1236: if (noninteractive)
1237: {
1238: fflush (stdout);
1239: return;
1240: }
1241: if (!term_initted)
1242: return;
1243: if (read_socket_hook)
1244: return;
1245: move_cursor (screen_height - 1, 0);
1246: clear_end_of_line (screen_width);
1247: /* clear_end_of_line may move the cursor */
1248: move_cursor (screen_height - 1, 0);
1249: /* Output raw CR so kernel can track the cursor hpos. */
1250: cmputc ('\r');
1251: #ifdef IBMR2AIX
1252: {
1253: /* HFT devices normally use ^J as a LF/CR. We forced it to
1254: do the LF only. Now, we need to reset it. */
1255: struct termio tty;
1256:
1257: if (ioctl (1, HFTGETID, &tty) != -1)
1258: write (1, "\033[20h", 5);
1259: }
1260: #endif
1261:
1262: reset_terminal_modes ();
1263: fflush (stdout);
1264: #ifdef BSD
1265: #ifndef BSD4_1
1266: /* Avoid possible loss of output when changing terminal modes. */
1267: fsync (fileno (stdout));
1268: #endif
1269: #endif
1270: #ifdef TIOCGLTC
1271: ioctl (0, TIOCSLTC, &old_ltchars);
1272: #endif /* TIOCGLTC */
1273: #ifndef HAVE_TERMIO
1274: #ifdef TIOCGETC
1275: ioctl (0, TIOCSETC, &old_tchars);
1276: ioctl (0, TIOCLSET, &old_lmode);
1277: #endif /* TIOCGETC */
1278: #endif /* not HAVE_TERMIO */
1279: #ifdef F_SETFL
1280: #ifdef F_SETOWN /* F_SETFL does not imply existance of F_SETOWN */
1281: if (interrupt_input)
1282: {
1283: reset_sigio ();
1284: fcntl (0, F_SETOWN, old_fcntl_owner);
1285: }
1286: #endif /* F_SETOWN */
1287: #endif /* F_SETFL */
1288: #ifdef BSD4_1
1289: if (interrupt_input)
1290: reset_sigio ();
1291: #endif /* BSD4_1 */
1292: #ifdef VMS
1293: end_kbd_input ();
1294: SYS$QIOW (0, input_chan, IO$_SETMODE, &input_iosb, 0, 0,
1295: &old_gtty.class, 12, 0, 0, 0, 0);
1296: #else /* not VMS */
1297: #ifndef HAVE_TCATTR
1298: while (ioctl (0, TCSETAW, &old_gtty) < 0 && errno == EINTR);
1299: #else
1300: while (tcsetattr (0, TCSADRAIN, &old_gtty) < 0 && errno == EINTR);
1301: #endif
1302: #endif /* not VMS */
1303:
1304: #ifdef AIX
1305: hft_reset ();
1306: #endif
1307: }
1308:
1309: #ifdef HAVE_PTYS
1310:
1311: /* Set up the proper status flags for use of a pty. */
1312:
1313: setup_pty (fd)
1314: int fd;
1315: {
1316: /* I'm told that TOICREMOTE does not mean control chars
1317: "can't be sent" but rather that they don't have
1318: input-editing or signaling effects.
1319: That should be good, because we have other ways
1320: to do those things in Emacs.
1321: However, telnet mode seems not to work on 4.2.
1322: So TIOCREMOTE is turned off now. */
1323:
1324: /* Under hp-ux, if TIOCREMOTE is turned on, some calls
1325: will hang. In particular, the "timeout" feature (which
1326: causes a read to return if there is no data available)
1327: does this. Also it is known that telnet mode will hang
1328: in such a way that Emacs must be stopped (perhaps this
1329: is the same problem).
1330:
1331: If TIOCREMOTE is turned off, then there is a bug in
1332: hp-ux which sometimes loses data. Apparently the
1333: code which blocks the master process when the internal
1334: buffer fills up does not work. Other than this,
1335: though, everything else seems to work fine.
1336:
1337: Since the latter lossage is more benign, we may as well
1338: lose that way. -- cph */
1339: #ifdef FIONBIO
1340: #ifdef SYSV_PTYS
1341: {
1342: int on = 1;
1343: ioctl (fd, FIONBIO, &on);
1344: }
1345: #endif
1346: #endif
1347: #ifdef IBMRTAIX
1348: /* On AIX, the parent gets SIGHUP when a pty attached child dies. So, we */
1349: /* ignore SIGHUP once we've started a child on a pty. Note that this may */
1350: /* cause EMACS not to die when it should, i.e., when its own controlling */
1351: /* tty goes away. I've complained to the AIX developers, and they may */
1352: /* change this behavior, but I'm not going to hold my breath. */
1353: signal (SIGHUP, SIG_IGN);
1354: #endif
1355: }
1356: #endif /* HAVE_PTYS */
1357:
1358: #ifdef VMS
1359:
1360: /* Assigning an input channel is done at the start of Emacs execution.
1361: This is called each time Emacs is resumed, also, but does nothing
1362: because input_chain is no longer zero. */
1363:
1364: init_vms_input ()
1365: {
1366: int status;
1367:
1368: if (input_chan == 0)
1369: {
1370: status = SYS$ASSIGN (&input_dsc, &input_chan, 0, 0);
1371: if (! (status & 1))
1372: LIB$STOP (status);
1373: }
1374: }
1375:
1376: /* Deassigning the input channel is done before exiting. */
1377:
1378: stop_vms_input ()
1379: {
1380: return SYS$DASSGN (input_chan);
1381: }
1382:
1383: short input_buffer;
1384:
1385: /* Request reading one character into the keyboard buffer.
1386: This is done as soon as the buffer becomes empty. */
1387:
1388: queue_kbd_input ()
1389: {
1390: int status;
1391: waiting_for_ast = 0;
1392: stop_input = 0;
1393: status = SYS$QIO (0, input_chan, IO$_READVBLK,
1394: &input_iosb, kbd_input_ast, 1,
1395: &input_buffer, 1, 0, terminator_mask, 0, 0);
1396: }
1397:
1398: int input_count;
1399:
1400: /* Ast routine that is called when keyboard input comes in
1401: in accord with the SYS$QIO above. */
1402:
1403: kbd_input_ast ()
1404: {
1405: register int c = -1;
1406: int old_errno = errno;
1407:
1408: if (waiting_for_ast)
1409: SYS$SETEF (input_ef);
1410: waiting_for_ast = 0;
1411: input_count++;
1412: #ifdef ASTDEBUG
1413: if (input_count == 25)
1414: exit (1);
1415: printf ("Ast # %d,", input_count);
1416: printf (" iosb = %x, %x, %x, %x",
1417: input_iosb.offset, input_iosb.status, input_iosb.termlen,
1418: input_iosb.term);
1419: #endif
1420: if (input_iosb.offset)
1421: {
1422: c = input_buffer;
1423: #ifdef ASTDEBUG
1424: printf (", char = 0%o", c);
1425: #endif
1426: }
1427: #ifdef ASTDEBUG
1428: printf ("\n");
1429: fflush (stdout);
1430: sleep (1);
1431: #endif
1432: if (! stop_input)
1433: queue_kbd_input ();
1434: if (c >= 0)
1435: kbd_buffer_store_char (c);
1436:
1437: errno = old_errno;
1438: }
1439:
1440: /* Wait until there is something in kbd_buffer. */
1441:
1442: wait_for_kbd_input ()
1443: {
1444: extern int have_process_input, process_exited;
1445:
1446: /* If already something, avoid doing system calls. */
1447: if (detect_input_pending ())
1448: {
1449: return;
1450: }
1451: /* Clear a flag, and tell ast routine above to set it. */
1452: SYS$CLREF (input_ef);
1453: waiting_for_ast = 1;
1454: /* Check for timing error: ast happened while we were doing that. */
1455: if (!detect_input_pending ())
1456: {
1457: /* No timing error: wait for flag to be set. */
1458: set_waiting_for_input (0);
1459: SYS$WFLOR (input_ef, input_eflist);
1460: clear_waiting_for_input (0);
1461: if (!detect_input_pending ())
1462: /* Check for subprocess input availability */
1463: {
1464: int dsp = have_process_input || process_exited;
1465:
1466: sys$clref (process_ef);
1467: if (have_process_input)
1468: process_command_input ();
1469: if (process_exited)
1470: process_exit ();
1471: if (dsp)
1472: {
1473: update_mode_lines++;
1474: redisplay_preserve_echo_area ();
1475: }
1476: }
1477: }
1478: waiting_for_ast = 0;
1479: }
1480:
1481: /* Get rid of any pending QIO, when we are about to suspend
1482: or when we want to throw away pending input.
1483: We wait for a positive sign that the AST routine has run
1484: and therefore there is no I/O request queued when we return.
1485: SYS$SETAST is used to avoid a timing error. */
1486:
1487: end_kbd_input ()
1488: {
1489: #ifdef ASTDEBUG
1490: printf ("At end_kbd_input.\n");
1491: fflush (stdout);
1492: sleep (1);
1493: #endif
1494: if (LIB$AST_IN_PROG ()) /* Don't wait if suspending from kbd_buffer_store_char! */
1495: {
1496: SYS$CANCEL (input_chan);
1497: return;
1498: }
1499:
1500: SYS$SETAST (0);
1501: /* Clear a flag, and tell ast routine above to set it. */
1502: SYS$CLREF (input_ef);
1503: waiting_for_ast = 1;
1504: stop_input = 1;
1505: SYS$CANCEL (input_chan);
1506: SYS$SETAST (1);
1507: SYS$WAITFR (input_ef);
1508: waiting_for_ast = 0;
1509: }
1510:
1511: /* Wait for either input available or time interval expiry. */
1512:
1513: input_wait_timeout (timeval)
1514: int timeval; /* Time to wait, in seconds */
1515: {
1516: int time [2];
1517: static int zero = 0;
1518: static int large = -10000000;
1519:
1520: LIB$EMUL (&timeval, &large, &zero, time); /* Convert to VMS format */
1521:
1522: /* If already something, avoid doing system calls. */
1523: if (detect_input_pending ())
1524: {
1525: return;
1526: }
1527: /* Clear a flag, and tell ast routine above to set it. */
1528: SYS$CLREF (input_ef);
1529: waiting_for_ast = 1;
1530: /* Check for timing error: ast happened while we were doing that. */
1531: if (!detect_input_pending ())
1532: {
1533: /* No timing error: wait for flag to be set. */
1534: SYS$CANTIM (1, 0);
1535: if (SYS$SETIMR (timer_ef, time, 0, 1) & 1) /* Set timer */
1536: SYS$WFLOR (timer_ef, timer_eflist); /* Wait for timer expiry or input */
1537: }
1538: waiting_for_ast = 0;
1539: }
1540:
1541: /* The standard `sleep' routine works some other way
1542: and it stops working if you have ever quit out of it.
1543: This one continues to work. */
1544:
1545: sys_sleep (timeval)
1546: int timeval;
1547: {
1548: int time [2];
1549: static int zero = 0;
1550: static int large = -10000000;
1551:
1552: LIB$EMUL (&timeval, &large, &zero, time); /* Convert to VMS format */
1553:
1554: SYS$CANTIM (1, 0);
1555: if (SYS$SETIMR (timer_ef, time, 0, 1) & 1) /* Set timer */
1556: SYS$WAITFR (timer_ef); /* Wait for timer expiry only */
1557: }
1558:
1559: init_sigio ()
1560: {
1561: request_sigio ();
1562: }
1563:
1564: reset_sigio ()
1565: {
1566: unrequest_sigio ();
1567: }
1568:
1569: request_sigio ()
1570: {
1571: croak ("request sigio");
1572: }
1573:
1574: unrequest_sigio ()
1575: {
1576: croak ("unrequest sigio");
1577: }
1578:
1579: #endif /* VMS */
1580:
1581: /* Note that VMS compiler won't accept defined (CANNOT_DUMP). */
1582: #ifndef CANNOT_DUMP
1583: #define NEED_STARTS
1584: #endif
1585:
1586: #ifndef SYSTEM_MALLOC
1587: #ifndef NEED_STARTS
1588: #define NEED_STARTS
1589: #endif
1590: #endif
1591:
1592: #ifdef NEED_STARTS
1593: /* Some systems that cannot dump also cannot implement these. */
1594:
1595: /*
1596: * Return the address of the start of the text segment prior to
1597: * doing an unexec. After unexec the return value is undefined.
1598: * See crt0.c for further explanation and _start.
1599: *
1600: */
1601:
1602: #ifndef CANNOT_UNEXEC
1603: char *
1604: start_of_text ()
1605: {
1606: #ifdef TEXT_START
1607: return ((char *) TEXT_START);
1608: #else
1609: #ifdef GOULD
1610: extern csrt ();
1611: return ((char *) csrt);
1612: #else /* not GOULD */
1613: extern int _start ();
1614: return ((char *) _start);
1615: #endif /* GOULD */
1616: #endif /* TEXT_START */
1617: }
1618: #endif /* not CANNOT_UNEXEC */
1619:
1620: /*
1621: * Return the address of the start of the data segment prior to
1622: * doing an unexec. After unexec the return value is undefined.
1623: * See crt0.c for further information and definition of data_start.
1624: *
1625: * Apparently, on BSD systems this is etext at startup. On
1626: * USG systems (swapping) this is highly mmu dependent and
1627: * is also dependent on whether or not the program is running
1628: * with shared text. Generally there is a (possibly large)
1629: * gap between end of text and start of data with shared text.
1630: *
1631: * On Uniplus+ systems with shared text, data starts at a
1632: * fixed address. Each port (from a given oem) is generally
1633: * different, and the specific value of the start of data can
1634: * be obtained via the UniPlus+ specific "uvar" system call,
1635: * however the method outlined in crt0.c seems to be more portable.
1636: *
1637: * Probably what will have to happen when a USG unexec is available,
1638: * at least on UniPlus, is temacs will have to be made unshared so
1639: * that text and data are contiguous. Then once loadup is complete,
1640: * unexec will produce a shared executable where the data can be
1641: * at the normal shared text boundry and the startofdata variable
1642: * will be patched by unexec to the correct value.
1643: *
1644: */
1645:
1646: char *
1647: start_of_data ()
1648: {
1649: #ifdef DATA_START
1650: return ((char *) DATA_START);
1651: #else
1652: extern int data_start;
1653: return ((char *) &data_start);
1654: #endif
1655: }
1656: #endif /* NEED_STARTS (not CANNOT_DUMP or not SYSTEM_MALLOC) */
1657:
1658: #ifndef CANNOT_DUMP
1659: /* Some systems that cannot dump also cannot implement these. */
1660:
1661: /*
1662: * Return the address of the end of the text segment prior to
1663: * doing an unexec. After unexec the return value is undefined.
1664: */
1665:
1666: char *
1667: end_of_text ()
1668: {
1669: #ifdef TEXT_END
1670: return ((char *) TEXT_END);
1671: #else
1672: extern int etext;
1673: return ((char *) &etext);
1674: #endif
1675: }
1676:
1677: /*
1678: * Return the address of the end of the data segment prior to
1679: * doing an unexec. After unexec the return value is undefined.
1680: */
1681:
1682: char *
1683: end_of_data ()
1684: {
1685: #ifdef DATA_END
1686: return ((char *) DATA_END);
1687: #else
1688: extern int edata;
1689: return ((char *) &edata);
1690: #endif
1691: }
1692:
1693: #endif /* not CANNOT_DUMP */
1694:
1695: /* Get_system_name returns as its value
1696: a string for the Lisp function system-name to return. */
1697:
1698: #ifdef BSD4_1
1699: #include <whoami.h>
1700: #endif
1701:
1702: /* Can't have this within the function since `static' is #defined to
1703: * nothing for some USG systems.
1704: */
1705: #ifdef USG
1706: #ifdef HAVE_GETHOSTNAME
1707: static char get_system_name_name[256];
1708: #else /* not HAVE_GETHOSTNAME */
1709: static struct utsname get_system_name_name;
1710: #endif /* not HAVE_GETHOSTNAME */
1711: #endif /* USG */
1712:
1713: char *
1714: get_system_name ()
1715: {
1716: #ifdef USG
1717: #ifdef HAVE_GETHOSTNAME
1718: gethostname (get_system_name_name, sizeof (get_system_name_name));
1719: return get_system_name_name;
1720: #else /* not HAVE_GETHOSTNAME */
1721: uname (&get_system_name_name);
1722: return (get_system_name_name.nodename);
1723: #endif /* not HAVE_GETHOSTNAME */
1724: #else /* Not USG */
1725: #ifdef BSD4_1
1726: return sysname;
1727: #else /* not USG, not 4.1 */
1728: static char system_name_saved[32];
1729: #ifdef VMS
1730: char *sp;
1731: if ((sp = egetenv ("SYS$NODE")) == 0)
1732: sp = "vax-vms";
1733: else
1734: {
1735: char *end;
1736:
1737: if ((end = index (sp, ':')) != 0)
1738: *end = '\0';
1739: }
1740: strcpy (system_name_saved, sp);
1741: #else /* not VMS */
1742: gethostname (system_name_saved, sizeof (system_name_saved));
1743: #endif /* not VMS */
1744: return system_name_saved;
1745: #endif /* not USG, not 4.1 */
1746: #endif /* not USG */
1747: }
1748:
1749: #ifndef HAVE_SELECT
1750:
1751: /* Emulate as much as select as is possible under 4.1 and needed by Gnu Emacs
1752: * Only checks read descriptors.
1753: */
1754: /* How long to wait between checking fds in select */
1755: #define SELECT_PAUSE 1
1756: int select_alarmed;
1757:
1758: /* For longjmp'ing back to read_input_waiting. */
1759:
1760: jmp_buf read_alarm_throw;
1761:
1762: /* Nonzero if the alarm signal should throw back to read_input_waiting.
1763: The read_socket_hook function sets this to 1 while it is waiting. */
1764:
1765: int read_alarm_should_throw;
1766:
1767: select_alarm ()
1768: {
1769: select_alarmed = 1;
1770: #ifdef BSD4_1
1771: sigrelse (SIGALRM);
1772: #else /* not BSD4_1 */
1773: signal (SIGALRM, SIG_IGN);
1774: #endif /* not BSD4_1 */
1775: if (read_alarm_should_throw)
1776: longjmp (read_alarm_throw, 1);
1777: }
1778:
1779: /* Only rfds are checked. */
1780: int
1781: select (nfds, rfds, wfds, efds, timeout)
1782: int nfds;
1783: int *rfds, *wfds, *efds, *timeout;
1784: {
1785: int ravail = 0, orfds = 0, old_alarm;
1786: int timeoutval = timeout ? *timeout : 100000;
1787: int *local_timeout = &timeoutval;
1788: extern int kbd_count;
1789: extern int proc_buffered_char[];
1790: #ifndef subprocesses
1791: int process_tick = 0, update_tick = 0;
1792: #else
1793: extern int process_tick, update_tick;
1794: #endif
1795: int (*old_trap) ();
1796: char buf;
1797:
1798: if (rfds)
1799: {
1800: orfds = *rfds;
1801: *rfds = 0;
1802: }
1803: if (wfds)
1804: *wfds = 0;
1805: if (efds)
1806: *efds = 0;
1807:
1808: /* If we are looking only for the terminal, with no timeout,
1809: just read it and wait -- that's more efficient. */
1810: if (orfds == 1 && (!timeout || *timeout == 100000)
1811: && process_tick == update_tick)
1812: {
1813: if (!kbd_count)
1814: read_input_waiting ();
1815: *rfds = 1;
1816: return 1;
1817: }
1818:
1819: /* Once a second, till the timer expires, check all the flagged read
1820: * descriptors to see if any input is available. If there is some then
1821: * set the corresponding bit in the return copy of rfds.
1822: */
1823: while (1)
1824: {
1825: register int to_check, bit, fd;
1826:
1827: if (rfds)
1828: {
1829: for (to_check = nfds, bit = 1, fd = 0; --to_check >= 0; bit <<= 1, fd++)
1830: {
1831: if (orfds & bit)
1832: {
1833: int avail = 0, status = 0;
1834:
1835: if (bit == 1)
1836: avail = detect_input_pending (); /* Special keyboard handler */
1837: else
1838: {
1839: #ifdef FIONREAD
1840: status = ioctl (fd, FIONREAD, &avail);
1841: #else /* no FIONREAD */
1842: /* Hoping it will return -1 if nothing available
1843: or 0 if all 0 chars requested are read. */
1844: if (proc_buffered_char[fd] >= 0)
1845: avail = 1;
1846: else
1847: {
1848: avail = read (fd, &buf, 1);
1849: if (avail > 0)
1850: proc_buffered_char[fd] = buf;
1851: }
1852: #endif /* no FIONREAD */
1853: }
1854: if (status >= 0 && avail > 0)
1855: {
1856: (*rfds) |= bit;
1857: ravail++;
1858: }
1859: }
1860: }
1861: }
1862: if (*local_timeout == 0 || ravail != 0 || process_tick != update_tick)
1863: break;
1864: old_alarm = alarm (0);
1865: old_trap = (int (*)()) signal (SIGALRM, select_alarm);
1866: select_alarmed = 0;
1867: alarm (SELECT_PAUSE);
1868: /* Wait for a SIGALRM (or maybe a SIGTINT) */
1869: while (select_alarmed == 0 && *local_timeout != 0
1870: && process_tick == update_tick)
1871: {
1872: /* If we are interested in terminal input,
1873: wait by reading the terminal.
1874: That makes instant wakeup for terminal input at least. */
1875: if (orfds & 1)
1876: {
1877: read_input_waiting ();
1878: if (kbd_count)
1879: select_alarmed = 1;
1880: }
1881: else
1882: pause ();
1883: }
1884: (*local_timeout) -= SELECT_PAUSE;
1885: /* Reset the old alarm if there was one */
1886: alarm (0);
1887: signal (SIGALRM, old_trap);
1888: if (old_alarm != 0)
1889: {
1890: /* Reset or forge an interrupt for the original handler. */
1891: old_alarm -= SELECT_PAUSE;
1892: if (old_alarm <= 0)
1893: kill (getpid (), SIGALRM); /* Fake an alarm with the orig' handler */
1894: else
1895: alarm (old_alarm);
1896: }
1897: if (*local_timeout == 0) /* Stop on timer being cleared */
1898: break;
1899: }
1900: return ravail;
1901: }
1902:
1903: /* Read keyboard input into the standard buffer,
1904: waiting for at least one character. */
1905:
1906: /* Make all keyboard buffers much bigger when using X windows. */
1907: #ifdef HAVE_X_WINDOWS
1908: #define BUFFER_SIZE_FACTOR 16
1909: #else
1910: #define BUFFER_SIZE_FACTOR 1
1911: #endif
1912:
1913: read_input_waiting ()
1914: {
1915: extern int kbd_count;
1916: extern unsigned char kbd_buffer[];
1917: extern unsigned char *kbd_ptr;
1918: int val;
1919:
1920: if (read_socket_hook)
1921: {
1922: read_alarm_should_throw = 0;
1923: if (! setjmp (read_alarm_throw))
1924: val = (*read_socket_hook) (0, kbd_buffer, 256 * BUFFER_SIZE_FACTOR);
1925: else
1926: val = -1;
1927: }
1928: else
1929: val = read (fileno (stdin), kbd_buffer, 1);
1930:
1931: if (val > 0)
1932: {
1933: kbd_ptr = kbd_buffer;
1934: kbd_count = val;
1935: }
1936: }
1937:
1938: #endif /* not HAVE_SELECT */
1939:
1940: #ifdef BSD4_1
1941: /* VARARGS */
1942: setpriority ()
1943: {
1944: return 0;
1945: }
1946:
1947: /*
1948: * Partially emulate 4.2 open call.
1949: * open is defined as this in 4.1.
1950: *
1951: * - added by Michael Bloom @ Citicorp/TTI
1952: *
1953: */
1954:
1955: int
1956: sys_open (path, oflag, mode)
1957: char *path;
1958: int oflag, mode;
1959: {
1960: if (oflag & O_CREAT)
1961: return creat (path, mode);
1962: else
1963: return open (path, oflag);
1964: }
1965:
1966: init_sigio ()
1967: {
1968: if (noninteractive)
1969: return;
1970: lmode = LINTRUP | lmode;
1971: ioctl (0, TIOCLSET, &lmode);
1972: }
1973:
1974: reset_sigio ()
1975: {
1976: if (noninteractive)
1977: return;
1978: lmode = ~LINTRUP & lmode;
1979: ioctl (0, TIOCLSET, &lmode);
1980: }
1981:
1982: request_sigio ()
1983: {
1984: sigrelse (SIGTINT);
1985:
1986: interrupts_deferred = 0;
1987: }
1988:
1989: unrequest_sigio ()
1990: {
1991: sighold (SIGTINT);
1992:
1993: interrupts_deferred = 1;
1994: }
1995:
1996: /* still inside #ifdef BSD4_1 */
1997: #ifdef subprocesses
1998:
1999: int sigheld; /* Mask of held signals */
2000:
2001: sigholdx (signum)
2002: int signum;
2003: {
2004: sigheld |= sigbit (signum);
2005: sighold (signum);
2006: }
2007:
2008: sigisheld (signum)
2009: int signum;
2010: {
2011: sigheld |= sigbit (signum);
2012: }
2013:
2014: sigunhold (signum)
2015: int signum;
2016: {
2017: sigheld &= ~sigbit (signum);
2018: sigrelse (signum);
2019: }
2020:
2021: sigfree () /* Free all held signals */
2022: {
2023: int i;
2024: for (i = 0; i < NSIG; i++)
2025: if (sigheld & sigbit (i))
2026: sigrelse (i);
2027: sigheld = 0;
2028: }
2029:
2030: sigbit (i)
2031: {
2032: return 1 << (i - 1);
2033: }
2034: #endif /* subprocesses */
2035: #endif /* BSD4_1 */
2036:
2037: /* POSIX signals support - DJB */
2038: /* Anyone with POSIX signals should have ANSI C declarations */
2039:
2040: #ifdef POSIX_SIGNALS
2041:
2042: sigset_t signal_empty_mask, signal_full_mask;
2043: static struct sigaction new_action, old_action;
2044:
2045: init_signals ()
2046: {
2047: #ifdef POSIX_SIGNALS
2048: sigemptyset (&signal_empty_mask);
2049: sigfillset (&signal_full_mask);
2050: #endif
2051: }
2052:
2053: typedef int (*signal_handler_t) ();
2054:
2055: signal_handler_t
2056: sys_signal (int signal_number, signal_handler_t action)
2057: {
2058: #ifdef DGUX
2059: /* This gets us restartable system calls for efficiency.
2060: The "else" code will works as well. */
2061: return (berk_signal (signal_number, action));
2062: #else
2063: sigemptyset (&new_action.sa_mask);
2064: new_action.sa_handler = action;
2065: new_action.sa_flags = NULL;
2066: sigaction (signal_number, &new_action, &old_action);
2067: return (old_action.sa_handler);
2068: #endif /* DGUX */
2069: }
2070:
2071: int
2072: sys_sigpause (sigset_t new_mask)
2073: {
2074: /* pause emulating berk sigpause... */
2075: sigsuspend (&new_mask);
2076: return (EINTR);
2077: }
2078:
2079: /* I'd like to have these guys return pointers to the mask storage in here,
2080: but there'd be trouble if the code was saving multiple masks. I'll be
2081: safe and pass the structure. It normally won't be more than 2 bytes
2082: anyhow. - DJB */
2083:
2084: sigset_t
2085: sys_sigblock (sigset_t new_mask)
2086: {
2087: sigset_t old_mask;
2088: sigprocmask (SIG_BLOCK, &new_mask, &old_mask);
2089: return (old_mask);
2090: }
2091:
2092: sigset_t
2093: sys_sigunblock (sigset_t new_mask)
2094: {
2095: sigset_t old_mask;
2096: sigprocmask (SIG_UNBLOCK, &new_mask, &old_mask);
2097: return (old_mask);
2098: }
2099:
2100: sigset_t
2101: sys_sigsetmask (sigset_t new_mask)
2102: {
2103: sigset_t old_mask;
2104: sigprocmask (SIG_SETMASK, &new_mask, &old_mask);
2105: return (old_mask);
2106: }
2107:
2108: #endif /* POSIX_SIGNALS */
2109:
2110: #ifndef BSTRING
2111:
2112: void
2113: bzero (b, length)
2114: register char *b;
2115: register int length;
2116: {
2117: #ifdef VMS
2118: short zero = 0;
2119: long max_str = 65535;
2120:
2121: while (length > max_str) {
2122: (void) LIB$MOVC5 (&zero, &zero, &zero, &max_str, b);
2123: length -= max_str;
2124: b += max_str;
2125: }
2126: max_str = length;
2127: (void) LIB$MOVC5 (&zero, &zero, &zero, &max_str, b);
2128: #else
2129: while (length-- > 0)
2130: *b++ = 0;
2131: #endif /* not VMS */
2132: }
2133:
2134: /* Saying `void' requires a declaration, above, where bcopy is used
2135: and that declaration causes pain for systems where bcopy is a macro. */
2136: bcopy (b1, b2, length)
2137: register char *b1;
2138: register char *b2;
2139: register int length;
2140: {
2141: #ifdef VMS
2142: long max_str = 65535;
2143:
2144: while (length > max_str) {
2145: (void) LIB$MOVC3 (&max_str, b1, b2);
2146: length -= max_str;
2147: b1 += max_str;
2148: b2 += max_str;
2149: }
2150: max_str = length;
2151: (void) LIB$MOVC3 (&max_str, b1, b2);
2152: #else
2153: while (length-- > 0)
2154: *b2++ = *b1++;
2155: #endif /* not VMS */
2156: }
2157:
2158: int
2159: bcmp (b1, b2, length) /* This could be a macro! */
2160: register char *b1;
2161: register char *b2;
2162: register int length;
2163: {
2164: #ifdef VMS
2165: struct dsc$descriptor_s src1 = {length, DSC$K_DTYPE_T, DSC$K_CLASS_S, b1};
2166: struct dsc$descriptor_s src2 = {length, DSC$K_DTYPE_T, DSC$K_CLASS_S, b2};
2167:
2168: return STR$COMPARE (&src1, &src2);
2169: #else
2170: while (length-- > 0)
2171: if (*b1++ != *b2++)
2172: return 1;
2173:
2174: return 0;
2175: #endif /* not VMS */
2176: }
2177: #endif /* not BSTRING */
2178:
2179: #ifdef BSD4_1
2180: long random ()
2181: {
2182: return (rand ());
2183: }
2184:
2185: srandom (arg)
2186: int arg;
2187: {
2188: srand (arg);
2189: }
2190: #endif /* BSD4_1 */
2191:
2192: #ifdef HPUX
2193: #ifdef X11
2194: #define HAVE_RANDOM
2195: #endif
2196: #endif
2197:
2198: #ifdef USG
2199: #ifndef HAVE_RANDOM
2200: /*
2201: * The BSD random returns numbers in the range of
2202: * 0 to 2e31 - 1. The USG rand(3C) returns numbers in the
2203: * range of 0 to 2e15 - 1. This is probably not significant
2204: * in this usage.
2205: */
2206:
2207: long
2208: random ()
2209: {
2210: /* Arrange to return a range centered on zero. */
2211: return rand () - (1 << 14);
2212: }
2213:
2214: srandom (arg)
2215: int arg;
2216: {
2217: srand (arg);
2218: }
2219:
2220: #endif /* HAVE_RANDOM */
2221: #endif /* USG */
2222:
2223:
2224: #ifdef VMS
2225:
2226: #ifdef getenv
2227: /* If any place else asks for the TERM variable,
2228: allow it to be overridden with the EMACS_TERM variable
2229: before attempting to translate the logical name TERM. As a last
2230: resort, ask for VAX C's special idea of the TERM variable. */
2231: #undef getenv
2232: char *
2233: sys_getenv (name)
2234: char *name;
2235: {
2236: register char *val;
2237: static char buf[256];
2238: static struct dsc$descriptor_s equiv
2239: = {sizeof (buf), DSC$K_DTYPE_T, DSC$K_CLASS_S, buf};
2240: static struct dsc$descriptor_s d_name
2241: = {0, DSC$K_DTYPE_T, DSC$K_CLASS_S, 0};
2242: short eqlen;
2243:
2244: if (!strcmp (name, "TERM"))
2245: {
2246: val = (char *) getenv ("EMACS_TERM");
2247: if (val)
2248: return val;
2249: }
2250:
2251: d_name.dsc$w_length = strlen (name);
2252: d_name.dsc$a_pointer = name;
2253: if (lib$sys_trnlog (&d_name, &eqlen, &equiv) == 1)
2254: {
2255: char *str = (char *) xmalloc (eqlen + 1);
2256: bcopy (buf, str, eqlen);
2257: str[eqlen] = '\0';
2258: /* This is a storage leak, but a pain to fix. With luck,
2259: no one will ever notice. */
2260: return str;
2261: }
2262: return (char *) getenv (name);
2263: }
2264: #endif /* getenv */
2265:
2266: #ifdef abort
2267: /* Since VMS doesn't believe in core dumps, the only way to debug this beast is
2268: to force a call on the debugger from within the image. */
2269: #undef abort
2270: sys_abort ()
2271: {
2272: reset_sys_modes ();
2273: LIB$SIGNAL (SS$_DEBUG);
2274: }
2275: #endif /* abort */
2276: #endif /* VMS */
2277:
2278: #ifdef VMS
2279: #ifdef LINK_CRTL_SHARE
2280: #ifdef SHAREABLE_LIB_BUG
2281: /* Variables declared noshare and initialized in shareable libraries
2282: cannot be shared. The VMS linker incorrectly forces you to use a private
2283: version which is uninitialized... If not for this "feature", we
2284: could use the C library definition of sys_nerr and sys_errlist. */
2285: int sys_nerr = 35;
2286: char *sys_errlist[] =
2287: {
2288: "error 0",
2289: "not owner",
2290: "no such file or directory",
2291: "no such process",
2292: "interrupted system call",
2293: "i/o error",
2294: "no such device or address",
2295: "argument list too long",
2296: "exec format error",
2297: "bad file number",
2298: "no child process",
2299: "no more processes",
2300: "not enough memory",
2301: "permission denied",
2302: "bad address",
2303: "block device required",
2304: "mount devices busy",
2305: "file exists",
2306: "cross-device link",
2307: "no such device",
2308: "not a directory",
2309: "is a directory",
2310: "invalid argument",
2311: "file table overflow",
2312: "too many open files",
2313: "not a typewriter",
2314: "text file busy",
2315: "file too big",
2316: "no space left on device",
2317: "illegal seek",
2318: "read-only file system",
2319: "too many links",
2320: "broken pipe",
2321: "math argument",
2322: "result too large",
2323: "I/O stream empty",
2324: "vax/vms specific error code nontranslatable error"
2325: };
2326: #endif /* SHAREABLE_LIB_BUG */
2327: #endif /* LINK_CRTL_SHARE */
2328: #endif /* VMS */
2329:
2330: #ifdef INTERRUPTABLE_OPEN
2331:
2332: int
2333: /* VARARGS 2 */
2334: sys_open (path, oflag, mode)
2335: char *path;
2336: int oflag, mode;
2337: {
2338: register int rtnval;
2339:
2340: while ((rtnval = open (path, oflag, mode)) == -1
2341: && (errno == EINTR));
2342: return (rtnval);
2343: }
2344:
2345: #endif /* INTERRUPTABLE_OPEN */
2346:
2347: #ifdef INTERRUPTABLE_CLOSE
2348:
2349: sys_close (fd)
2350: int fd;
2351: {
2352: register int rtnval;
2353:
2354: while ((rtnval = close (fd)) == -1
2355: && (errno == EINTR));
2356: return rtnval;
2357: }
2358:
2359: #endif /* INTERRUPTABLE_CLOSE */
2360:
2361: #ifdef INTERRUPTABLE_IO
2362:
2363: int
2364: sys_read (fildes, buf, nbyte)
2365: int fildes;
2366: char *buf;
2367: unsigned int nbyte;
2368: {
2369: register int rtnval;
2370:
2371: while ((rtnval = read (fildes, buf, nbyte)) == -1
2372: && (errno == EINTR));
2373: return (rtnval);
2374: }
2375:
2376: int
2377: sys_write (fildes, buf, nbyte)
2378: int fildes;
2379: char *buf;
2380: unsigned int nbyte;
2381: {
2382: register int rtnval;
2383:
2384: while ((rtnval = write (fildes, buf, nbyte)) == -1
2385: && (errno == EINTR));
2386: return (rtnval);
2387: }
2388:
2389: #endif /* INTERRUPTABLE_IO */
2390:
2391: #ifdef USG
2392: /*
2393: * All of the following are for USG.
2394: *
2395: * On USG systems the system calls are interruptable by signals
2396: * that the user program has elected to catch. Thus the system call
2397: * must be retried in these cases. To handle this without massive
2398: * changes in the source code, we remap the standard system call names
2399: * to names for our own functions in sysdep.c that do the system call
2400: * with retries. Actually, for portability reasons, it is good
2401: * programming practice, as this example shows, to limit all actual
2402: * system calls to a single occurance in the source. Sure, this
2403: * adds an extra level of function call overhead but it is almost
2404: * always negligible. Fred Fish, Unisoft Systems Inc.
2405: */
2406:
2407: char *sys_siglist[NSIG + 1] =
2408: {
2409: #ifdef AIX
2410: /* AIX has changed the signals a bit */
2411: "bogus signal", /* 0 */
2412: "hangup", /* 1 SIGHUP */
2413: "interrupt", /* 2 SIGINT */
2414: "quit", /* 3 SIGQUIT */
2415: "illegal instruction", /* 4 SIGILL */
2416: "trace trap", /* 5 SIGTRAP */
2417: "IOT instruction", /* 6 SIGIOT */
2418: "crash likely", /* 7 SIGDANGER */
2419: "floating point exception", /* 8 SIGFPE */
2420: "kill", /* 9 SIGKILL */
2421: "bus error", /* 10 SIGBUS */
2422: "segmentation violation", /* 11 SIGSEGV */
2423: "bad argument to system call", /* 12 SIGSYS */
2424: "write on a pipe with no one to read it", /* 13 SIGPIPE */
2425: "alarm clock", /* 14 SIGALRM */
2426: "software termination signum", /* 15 SIGTERM */
2427: "user defined signal 1", /* 16 SIGUSR1 */
2428: "user defined signal 2", /* 17 SIGUSR2 */
2429: "death of a child", /* 18 SIGCLD */
2430: "power-fail restart", /* 19 SIGPWR */
2431: "bogus signal", /* 20 */
2432: "bogus signal", /* 21 */
2433: "bogus signal", /* 22 */
2434: "bogus signal", /* 23 */
2435: "bogus signal", /* 24 */
2436: "LAN I/O interrupt", /* 25 SIGAIO */
2437: "PTY I/O interrupt", /* 26 SIGPTY */
2438: "I/O intervention required", /* 27 SIGIOINT */
2439: "HFT grant", /* 28 SIGGRANT */
2440: "HFT retract", /* 29 SIGRETRACT */
2441: "HFT sound done", /* 30 SIGSOUND */
2442: "HFT input ready", /* 31 SIGMSG */
2443: #else /* not AIX */
2444: "bogus signal", /* 0 */
2445: "hangup", /* 1 SIGHUP */
2446: "interrupt", /* 2 SIGINT */
2447: "quit", /* 3 SIGQUIT */
2448: "illegal instruction", /* 4 SIGILL */
2449: "trace trap", /* 5 SIGTRAP */
2450: "IOT instruction", /* 6 SIGIOT */
2451: "EMT instruction", /* 7 SIGEMT */
2452: "floating point exception", /* 8 SIGFPE */
2453: "kill", /* 9 SIGKILL */
2454: "bus error", /* 10 SIGBUS */
2455: "segmentation violation", /* 11 SIGSEGV */
2456: "bad argument to system call", /* 12 SIGSYS */
2457: "write on a pipe with no one to read it", /* 13 SIGPIPE */
2458: "alarm clock", /* 14 SIGALRM */
2459: "software termination signum", /* 15 SIGTERM */
2460: "user defined signal 1", /* 16 SIGUSR1 */
2461: "user defined signal 2", /* 17 SIGUSR2 */
2462: "death of a child", /* 18 SIGCLD */
2463: "power-fail restart", /* 19 SIGPWR */
2464: #endif /* not AIX */
2465: 0
2466: };
2467:
2468: /*
2469: * Warning, this function may not duplicate 4.2 action properly
2470: * under error conditions.
2471: */
2472:
2473: #ifndef MAXPATHLEN
2474: /* In 4.1, param.h fails to define this. */
2475: #define MAXPATHLEN 1024
2476: #endif
2477:
2478: #ifndef HAVE_GETWD
2479:
2480: char *
2481: getwd (pathname)
2482: char *pathname;
2483: {
2484: char *npath, *spath;
2485: extern char *getcwd ();
2486:
2487: spath = npath = getcwd ((char *) 0, MAXPATHLEN);
2488: /* On Altos 3068, getcwd can return @hostname/dir, so discard
2489: up to first slash. Should be harmless on other systems. */
2490: while (*npath && *npath != '/')
2491: npath++;
2492: strcpy (pathname, npath);
2493: free (spath); /* getcwd uses malloc */
2494: return pathname;
2495: }
2496:
2497: #endif /* not HAVE_GETWD */
2498:
2499: #ifndef HAVE_RENAME
2500:
2501: /*
2502: * Emulate rename using unlink/link. Note that this is
2503: * only partially correct. Also, doesn't enforce restriction
2504: * that files be of same type (regular->regular, dir->dir, etc).
2505: */
2506:
2507: rename (from, to)
2508: #ifdef __STDC__ /* Avoid error if system has proper ANSI prototype. */
2509: const char *from;
2510: const char *to;
2511: #else
2512: char *from;
2513: char *to;
2514: #endif
2515: {
2516: if (access (from, 0) == 0)
2517: {
2518: unlink (to);
2519: if (link (from, to) == 0)
2520: if (unlink (from) == 0)
2521: return (0);
2522: }
2523: return (-1);
2524: }
2525: #endif /* not HAVE_RENAME */
2526:
2527: /* VARARGS */
2528: setpriority ()
2529: {
2530: return (0);
2531: }
2532:
2533: #ifndef HAVE_VFORK
2534:
2535: /*
2536: * Substitute fork(2) for vfork(2) on USG flavors.
2537: */
2538:
2539: vfork ()
2540: {
2541: return (fork ());
2542: }
2543:
2544: #endif /* not HAVE_VFORK */
2545:
2546: #ifdef MISSING_UTIMES
2547:
2548: /* HPUX (among others) sets HAVE_TIMEVAL but does not implement utimes. */
2549:
2550: utimes ()
2551: {
2552: }
2553: #endif
2554:
2555: #ifdef IRIS_UTIME
2556:
2557: /* The IRIS (3.5) has timevals, but uses sys V utime, and doesn't have the
2558: utimbuf structure defined anywhere but in the man page. */
2559:
2560: struct utimbuf
2561: {
2562: long actime;
2563: long modtime;
2564: };
2565:
2566: utimes (name, tvp)
2567: char *name;
2568: struct timeval tvp[];
2569: {
2570: struct utimbuf utb;
2571: utb.actime = tvp[0].tv_sec;
2572: utb.modtime = tvp[1].tv_sec;
2573: utime (name, &utb);
2574: }
2575: #endif /* IRIS_UTIME */
2576:
2577:
2578: #if 0
2579: #ifdef HPUX
2580:
2581: /* HPUX curses library references perror, but as far as we know
2582: it won't be called. Anyway this definition will do for now. */
2583:
2584: perror ()
2585: {
2586: }
2587:
2588: #endif /* HPUX */
2589: #endif /* 0 */
2590:
2591: #ifndef HAVE_DUP2
2592:
2593: /*
2594: * Emulate BSD dup2(2). First close newd if it already exists.
2595: * Then, attempt to dup oldd. If not successful, call dup2 recursively
2596: * until we are, then close the unsuccessful ones.
2597: */
2598:
2599: dup2 (oldd, newd)
2600: int oldd;
2601: int newd;
2602: {
2603: register int fd, ret;
2604:
2605: sys_close (newd);
2606:
2607: #ifdef F_DUPFD
2608: fd = fcntl (oldd, F_DUPFD, newd);
2609: if (fd != newd)
2610: error ("cant dup2 (%i,%i) : %s", oldd, newd, sys_errlist[errno]);
2611: #else
2612: fd = dup (old);
2613: if (fd == -1)
2614: return -1;
2615: if (fd == new)
2616: return new;
2617: ret = dup2 (old,new);
2618: sys_close (fd);
2619: return ret;
2620: #endif
2621: }
2622:
2623: #endif /* not HAVE_DUP2 */
2624:
2625: /*
2626: * Gettimeofday. Simulate as much as possible. Only accurate
2627: * to nearest second. Emacs doesn't use tzp so ignore it for now.
2628: * Only needed when subprocesses are defined.
2629: */
2630:
2631: #ifdef subprocesses
2632: #ifndef HAVE_GETTIMEOFDAY
2633: #ifdef HAVE_TIMEVAL
2634:
2635: /* ARGSUSED */
2636: gettimeofday (tp, tzp)
2637: struct timeval *tp;
2638: struct timezone *tzp;
2639: {
2640: extern long time ();
2641:
2642: tp->tv_sec = time ((long *)0);
2643: tp->tv_usec = 0;
2644: }
2645:
2646: #endif
2647: #endif
2648: #endif /* subprocess && !HAVE_GETTIMEOFDAY && HAVE_TIMEVAL */
2649:
2650: /*
2651: * This function will go away as soon as all the stubs fixed. (fnf)
2652: */
2653:
2654: croak (badfunc)
2655: char *badfunc;
2656: {
2657: printf ("%s not yet implemented\r\n", badfunc);
2658: reset_sys_modes ();
2659: exit (1);
2660: }
2661:
2662: #endif /* USG */
2663:
2664: #ifdef DGUX
2665:
2666: char *sys_siglist[NSIG + 1] =
2667: {
2668: "null signal", /* 0 SIGNULL */
2669: "hangup", /* 1 SIGHUP */
2670: "interrupt", /* 2 SIGINT */
2671: "quit", /* 3 SIGQUIT */
2672: "illegal instruction", /* 4 SIGILL */
2673: "trace trap", /* 5 SIGTRAP */
2674: "abort termination", /* 6 SIGABRT */
2675: "SIGEMT", /* 7 SIGEMT */
2676: "floating point exception", /* 8 SIGFPE */
2677: "kill", /* 9 SIGKILL */
2678: "bus error", /* 10 SIGBUS */
2679: "segmentation violation", /* 11 SIGSEGV */
2680: "bad argument to system call", /* 12 SIGSYS */
2681: "write on a pipe with no reader", /* 13 SIGPIPE */
2682: "alarm clock", /* 14 SIGALRM */
2683: "software termination signal", /* 15 SIGTERM */
2684: "user defined signal 1", /* 16 SIGUSR1 */
2685: "user defined signal 2", /* 17 SIGUSR2 */
2686: "child stopped or terminated", /* 18 SIGCLD */
2687: "power-fail restart", /* 19 SIGPWR */
2688: "window size changed", /* 20 SIGWINCH */
2689: "undefined", /* 21 */
2690: "pollable event occured", /* 22 SIGPOLL */
2691: "sendable stop signal not from tty", /* 23 SIGSTOP */
2692: "stop signal from tty", /* 24 SIGSTP */
2693: "continue a stopped process", /* 25 SIGCONT */
2694: "attempted background tty read", /* 26 SIGTTIN */
2695: "attempted background tty write", /* 27 SIGTTOU */
2696: "undefined", /* 28 */
2697: "undefined", /* 29 */
2698: "undefined", /* 30 */
2699: "undefined", /* 31 */
2700: "undefined", /* 32 */
2701: "socket (TCP/IP) urgent data arrival", /* 33 SIGURG */
2702: "I/O is possible", /* 34 SIGIO */
2703: "exceeded cpu time limit", /* 35 SIGXCPU */
2704: "exceeded file size limit", /* 36 SIGXFSZ */
2705: "virtual time alarm", /* 37 SIGVTALRM */
2706: "profiling time alarm", /* 38 SIGPROF */
2707: "undefined", /* 39 */
2708: "file record locks revoked", /* 40 SIGLOST */
2709: "undefined", /* 41 */
2710: "undefined", /* 42 */
2711: "undefined", /* 43 */
2712: "undefined", /* 44 */
2713: "undefined", /* 45 */
2714: "undefined", /* 46 */
2715: "undefined", /* 47 */
2716: "undefined", /* 48 */
2717: "undefined", /* 49 */
2718: "undefined", /* 50 */
2719: "undefined", /* 51 */
2720: "undefined", /* 52 */
2721: "undefined", /* 53 */
2722: "undefined", /* 54 */
2723: "undefined", /* 55 */
2724: "undefined", /* 56 */
2725: "undefined", /* 57 */
2726: "undefined", /* 58 */
2727: "undefined", /* 59 */
2728: "undefined", /* 60 */
2729: "undefined", /* 61 */
2730: "undefined", /* 62 */
2731: "undefined", /* 63 */
2732: "notification message in mess. queue", /* 64 SIGDGNOTIFY */
2733: 0
2734: };
2735:
2736: #endif /* DGUX */
2737:
2738: /* Directory routines for systems that don't have them. */
2739:
2740: #ifdef SYSV_SYSTEM_DIR
2741:
2742: #include <dirent.h>
2743:
2744: #ifndef HAVE_CLOSEDIR
2745: int
2746: closedir (dirp)
2747: register DIR *dirp; /* stream from opendir */
2748: {
2749: sys_close (dirp->dd_fd);
2750: free ((char *) dirp->dd_buf); /* directory block defined in <dirent.h> */
2751: free ((char *) dirp);
2752: }
2753: #endif /* not HAVE_CLOSEDIR */
2754:
2755: #endif /* SYSV_SYSTEM_DIR */
2756:
2757: #ifdef NONSYSTEM_DIR_LIBRARY
2758:
2759: DIR *
2760: opendir (filename)
2761: char *filename; /* name of directory */
2762: {
2763: register DIR *dirp; /* -> malloc'ed storage */
2764: register int fd; /* file descriptor for read */
2765: struct stat sbuf; /* result of fstat() */
2766:
2767: fd = sys_open (filename, 0);
2768: if (fd < 0)
2769: return 0;
2770:
2771: if (fstat (fd, &sbuf) < 0
2772: || (sbuf.st_mode & S_IFMT) != S_IFDIR
2773: || (dirp = (DIR *) malloc (sizeof (DIR))) == 0)
2774: {
2775: sys_close (fd);
2776: return 0; /* bad luck today */
2777: }
2778:
2779: dirp->dd_fd = fd;
2780: dirp->dd_loc = dirp->dd_size = 0; /* refill needed */
2781:
2782: return dirp;
2783: }
2784:
2785: void
2786: closedir (dirp)
2787: register DIR *dirp; /* stream from opendir() */
2788: {
2789: sys_close (dirp->dd_fd);
2790: free ((char *) dirp);
2791: }
2792:
2793:
2794: #ifndef VMS
2795: #define DIRSIZ 14
2796: struct olddir
2797: {
2798: ino_t od_ino; /* inode */
2799: char od_name[DIRSIZ]; /* filename */
2800: };
2801: #endif /* not VMS */
2802:
2803: struct direct dir_static; /* simulated directory contents */
2804:
2805: /* ARGUSED */
2806: struct direct *
2807: readdir (dirp)
2808: register DIR *dirp; /* stream from opendir() */
2809: {
2810: #ifndef VMS
2811: register struct olddir *dp; /* -> directory data */
2812: #else /* VMS */
2813: register struct dir$_name *dp; /* -> directory data */
2814: register struct dir$_version *dv; /* -> version data */
2815: #endif /* VMS */
2816:
2817: for (; ;)
2818: {
2819: if (dirp->dd_loc >= dirp->dd_size)
2820: dirp->dd_loc = dirp->dd_size = 0;
2821:
2822: if (dirp->dd_size == 0 /* refill buffer */
2823: && (dirp->dd_size = sys_read (dirp->dd_fd, dirp->dd_buf, DIRBLKSIZ)) <= 0)
2824: return 0;
2825:
2826: #ifndef VMS
2827: dp = (struct olddir *) &dirp->dd_buf[dirp->dd_loc];
2828: dirp->dd_loc += sizeof (struct olddir);
2829:
2830: if (dp->od_ino != 0) /* not deleted entry */
2831: {
2832: dir_static.d_ino = dp->od_ino;
2833: strncpy (dir_static.d_name, dp->od_name, DIRSIZ);
2834: dir_static.d_name[DIRSIZ] = '\0';
2835: dir_static.d_namlen = strlen (dir_static.d_name);
2836: dir_static.d_reclen = sizeof (struct direct)
2837: - MAXNAMLEN + 3
2838: + dir_static.d_namlen - dir_static.d_namlen % 4;
2839: return &dir_static; /* -> simulated structure */
2840: }
2841: #else /* VMS */
2842: dp = (struct dir$_name *) dirp->dd_buf;
2843: if (dirp->dd_loc == 0)
2844: dirp->dd_loc = (dp->dir$b_namecount&1) ? dp->dir$b_namecount + 1
2845: : dp->dir$b_namecount;
2846: dv = (struct dir$_version *)&dp->dir$t_name[dirp->dd_loc];
2847: dir_static.d_ino = dv->dir$w_fid_num;
2848: dir_static.d_namlen = dp->dir$b_namecount;
2849: dir_static.d_reclen = sizeof (struct direct)
2850: - MAXNAMLEN + 3
2851: + dir_static.d_namlen - dir_static.d_namlen % 4;
2852: strncpy (dir_static.d_name, dp->dir$t_name, dp->dir$b_namecount);
2853: dir_static.d_name[dir_static.d_namlen] = '\0';
2854: dirp->dd_loc = dirp->dd_size; /* only one record at a time */
2855: return &dir_static;
2856: #endif /* VMS */
2857: }
2858: }
2859:
2860: #ifdef VMS
2861: /* readdirver is just like readdir except it returns all versions of a file
2862: as separate entries. */
2863:
2864: /* ARGUSED */
2865: struct direct *
2866: readdirver (dirp)
2867: register DIR *dirp; /* stream from opendir() */
2868: {
2869: register struct dir$_name *dp; /* -> directory data */
2870: register struct dir$_version *dv; /* -> version data */
2871:
2872: if (dirp->dd_loc >= dirp->dd_size - sizeof (struct dir$_name))
2873: dirp->dd_loc = dirp->dd_size = 0;
2874:
2875: if (dirp->dd_size == 0 /* refill buffer */
2876: && (dirp->dd_size = sys_read (dirp->dd_fd, dirp->dd_buf, DIRBLKSIZ)) <= 0)
2877: return 0;
2878:
2879: dp = (struct dir$_name *) dirp->dd_buf;
2880: if (dirp->dd_loc == 0)
2881: dirp->dd_loc = (dp->dir$b_namecount & 1) ? dp->dir$b_namecount + 1
2882: : dp->dir$b_namecount;
2883: dv = (struct dir$_version *) &dp->dir$t_name[dirp->dd_loc];
2884: strncpy (dir_static.d_name, dp->dir$t_name, dp->dir$b_namecount);
2885: sprintf (&dir_static.d_name[dp->dir$b_namecount], ";%d", dv->dir$w_version);
2886: dir_static.d_namlen = strlen (dir_static.d_name);
2887: dir_static.d_ino = dv->dir$w_fid_num;
2888: dir_static.d_reclen = sizeof (struct direct) - MAXNAMLEN + 3
2889: + dir_static.d_namlen - dir_static.d_namlen % 4;
2890: dirp->dd_loc = ((char *) (++dv) - dp->dir$t_name);
2891: return &dir_static;
2892: }
2893:
2894: #endif /* VMS */
2895:
2896: #endif /* NONSYSTEM_DIR_LIBRARY */
2897:
2898: /* Functions for VMS */
2899: #ifdef VMS
2900: #include "vms-pwd.h"
2901: #include <acldef.h>
2902: #include <chpdef.h>
2903: #include <jpidef.h>
2904:
2905: /* Return as a string the VMS error string pertaining to STATUS.
2906: Reuses the same static buffer each time it is called. */
2907:
2908: char *
2909: vmserrstr (status)
2910: int status; /* VMS status code */
2911: {
2912: int bufadr[2];
2913: short len;
2914: static char buf[257];
2915:
2916: bufadr[0] = sizeof buf - 1;
2917: bufadr[1] = (int) buf;
2918: if (! (SYS$GETMSG (status, &len, bufadr, 0x1, 0) & 1))
2919: return "untranslatable VMS error status";
2920: buf[len] = '\0';
2921: return buf;
2922: }
2923:
2924: #ifdef access
2925: #undef access
2926:
2927: /* The following is necessary because 'access' emulation by VMS C (2.0) does
2928: * not work correctly. (It also doesn't work well in version 2.3.)
2929: */
2930:
2931: #ifdef VMS4_4
2932:
2933: #define DESCRIPTOR(name,string) struct dsc$descriptor_s name = \
2934: { strlen (string), DSC$K_DTYPE_T, DSC$K_CLASS_S, string }
2935:
2936: typedef union {
2937: struct {
2938: unsigned short s_buflen;
2939: unsigned short s_code;
2940: char *s_bufadr;
2941: unsigned short *s_retlenadr;
2942: } s;
2943: int end;
2944: } item;
2945:
2946: #define ITEMSETUP(CODE,VAR,RETLEN) \
2947: itemlst[cnt].s.s_buflen = sizeof (VAR); \
2948: itemlst[cnt].s.s_code = CODE; \
2949: itemlst[cnt].s.s_bufadr = (char *) &VAR; \
2950: itemlst[cnt++].s.s_retlenadr = (unsigned short *) &RETLEN
2951:
2952: #define R_OK 4 /* test for read permission */
2953: #define W_OK 2 /* test for write permission */
2954: #define X_OK 1 /* test for execute (search) permission */
2955: #define F_OK 0 /* test for presence of file */
2956:
2957: int
2958: sys_access (path, mode)
2959: char *path;
2960: int mode;
2961: {
2962: static char *user = NULL;
2963: char dir_fn[512];
2964:
2965: /* translate possible directory spec into .DIR file name, so brain-dead
2966: * access() can treat the directory like a file. */
2967: if (directory_file_name (path, dir_fn))
2968: path = dir_fn;
2969:
2970: if (mode == F_OK)
2971: return access (path, mode);
2972: if (user == NULL && (user = (char *) getenv ("USER")) == NULL)
2973: return -1;
2974: {
2975: int stat;
2976: int flags;
2977: int acces;
2978: int dummy;
2979: int cnt;
2980: int prvmask[2];
2981: item itemlst[8];
2982: struct FAB fab;
2983: struct XABPRO xab;
2984: char *aclbuf;
2985:
2986: flags = 0;
2987: acces = 0;
2988: if ((mode & X_OK) && ((stat = access(path, mode)) < 0 || mode == X_OK))
2989: return stat;
2990: if (mode & R_OK)
2991: flags |= CHP$M_READ;
2992: if (mode & W_OK)
2993: flags |= CHP$M_WRITE;
2994:
2995: acces = flags;
2996:
2997: /* Find privilege bits */
2998: stat = sys$setprv (0, 0, 0, prvmask);
2999:
3000: /* Open the file, and find the particulars. */
3001: fab = cc$rms_fab;
3002: fab.fab$b_fac = FAB$M_GET;
3003: fab.fab$l_fna = path;
3004: fab.fab$b_fns = strlen (path);
3005: fab.fab$l_xab = (char*) &xab;
3006: xab = cc$rms_xabpro;
3007: xab.xab$l_aclbuf = (char*) alloca(60); /* Use 60 initially */;
3008: xab.xab$w_aclsiz = 60;
3009: stat = sys$open (&fab, 0, 0);
3010: if (! (stat & 1))
3011: return -1;
3012: /* If ACL was not empty (2512) and error occurred, then deny access. */
3013: if ((xab.xab$l_aclsts != 2512) && (! (xab.xab$l_aclsts & 1)))
3014: return -1;
3015: sys$close (&fab, 0, 0);
3016:
3017: /* See if we allocated enough space for the ACL. If not, create a larger
3018: buffer (now that we now know the actual size), and do it again. */
3019:
3020: if(xab.xab$w_acllen > xab.xab$w_aclsiz){
3021: xab.xab$l_aclbuf = (char *) alloca(xab.xab$w_acllen);
3022: xab.xab$w_aclsiz = xab.xab$w_acllen;
3023: xab.xab$l_aclctx = 0;
3024: stat = sys$open (&fab, 0, 0);
3025: if (! (stat & 1))
3026: return -1;
3027: sys$close (&fab, 0, 0);
3028: };
3029: cnt=0;
3030: ITEMSETUP(CHP$_OWNER,xab.xab$l_uic,dummy);
3031: ITEMSETUP(CHP$_PROT,xab.xab$w_pro,dummy);
3032: ITEMSETUP(CHP$_ACCESS,acces,dummy);
3033: ITEMSETUP(CHP$_FLAGS,flags,dummy);
3034:
3035: if (xab.xab$w_acllen != 0)
3036: {
3037: itemlst[cnt].s.s_buflen = xab.xab$w_acllen;
3038: itemlst[cnt].s.s_code = CHP$_ACL;
3039: itemlst[cnt].s.s_bufadr = xab.xab$l_aclbuf;
3040: itemlst[cnt++].s.s_retlenadr = (unsigned short *) &dummy;
3041: };
3042:
3043: ITEMSETUP(CHP$_PRIV,prvmask,dummy);
3044: /* ITEMSETUP(CHP$_PRIVUSED,pused,pusedl); For diagnostic purposes only */
3045: itemlst[cnt].s.s_buflen = 0;
3046: itemlst[cnt].s.s_code = CHP$_END;
3047:
3048: /* SYS$CHECK_ACCESS can get privileges wrong. SYS$CHKPRO will not. */
3049: stat = SYS$CHKPRO(itemlst);
3050: return stat == SS$_NORMAL ? 0 : -1;
3051: }
3052: }
3053:
3054: #else /* not VMS4_4 */
3055:
3056: #include <prvdef.h>
3057: #define ACE$M_WRITE 2
3058: #define ACE$C_KEYID 1
3059:
3060: static unsigned short memid, grpid;
3061: static unsigned int uic;
3062:
3063: /* Called from init_sys_modes, so it happens not very often
3064: but at least each time Emacs is loaded. */
3065: sys_access_reinit ()
3066: {
3067: uic = 0;
3068: }
3069:
3070: int
3071: sys_access (filename, type)
3072: char * filename;
3073: int type;
3074: {
3075: struct FAB fab;
3076: struct XABPRO xab;
3077: int status, size, i, typecode, acl_controlled;
3078: unsigned int *aclptr, *aclend, aclbuf[60];
3079: union prvdef prvmask;
3080:
3081: /* Get UIC and GRP values for protection checking. */
3082: if (uic == 0)
3083: {
3084: status = LIB$GETJPI (&JPI$_UIC, 0, 0, &uic, 0, 0);
3085: if (! (status & 1))
3086: return -1;
3087: memid = uic & 0xFFFF;
3088: grpid = uic >> 16;
3089: }
3090:
3091: if (type != 2) /* not checking write access */
3092: return access (filename, type);
3093:
3094: /* Check write protection. */
3095:
3096: #define CHECKPRIV(bit) (prvmask.bit)
3097: #define WRITEABLE(field) (! ((xab.xab$w_pro >> field) & XAB$M_NOWRITE))
3098:
3099: /* Find privilege bits */
3100: status = sys$setprv (0, 0, 0, prvmask);
3101: if (! (status & 1))
3102: error ("Unable to find privileges: %s", vmserrstr (status));
3103: if (CHECKPRIV (PRV$V_BYPASS))
3104: return 0; /* BYPASS enabled */
3105: fab = cc$rms_fab;
3106: fab.fab$b_fac = FAB$M_GET;
3107: fab.fab$l_fna = filename;
3108: fab.fab$b_fns = strlen (filename);
3109: fab.fab$l_xab = &xab;
3110: xab = cc$rms_xabpro;
3111: xab.xab$l_aclbuf = aclbuf;
3112: xab.xab$w_aclsiz = sizeof (aclbuf);
3113: status = sys$open (&fab, 0, 0);
3114: if (! (status & 1))
3115: return -1;
3116: sys$close (&fab, 0, 0);
3117: /* Check system access */
3118: if (CHECKPRIV (PRV$V_SYSPRV) && WRITEABLE (XAB$V_SYS))
3119: return 0;
3120: /* Check ACL entries, if any */
3121: acl_controlled = 0;
3122: if (xab.xab$w_acllen > 0)
3123: {
3124: aclptr = aclbuf;
3125: aclend = &aclbuf[xab.xab$w_acllen / 4];
3126: while (*aclptr && aclptr < aclend)
3127: {
3128: size = (*aclptr & 0xff) / 4;
3129: typecode = (*aclptr >> 8) & 0xff;
3130: if (typecode == ACE$C_KEYID)
3131: for (i = size - 1; i > 1; i--)
3132: if (aclptr[i] == uic)
3133: {
3134: acl_controlled = 1;
3135: if (aclptr[1] & ACE$M_WRITE)
3136: return 0; /* Write access through ACL */
3137: }
3138: aclptr = &aclptr[size];
3139: }
3140: if (acl_controlled) /* ACL specified, prohibits write access */
3141: return -1;
3142: }
3143: /* No ACL entries specified, check normal protection */
3144: if (WRITEABLE (XAB$V_WLD)) /* World writeable */
3145: return 0;
3146: if (WRITEABLE (XAB$V_GRP) &&
3147: (unsigned short) (xab.xab$l_uic >> 16) == grpid)
3148: return 0; /* Group writeable */
3149: if (WRITEABLE (XAB$V_OWN) &&
3150: (xab.xab$l_uic & 0xFFFF) == memid)
3151: return 0; /* Owner writeable */
3152:
3153: return -1; /* Not writeable */
3154: }
3155: #endif /* not VMS4_4 */
3156: #endif /* access */
3157:
3158: static char vtbuf[NAM$C_MAXRSS+1];
3159:
3160: /* translate a vms file spec to a unix path */
3161: char *
3162: sys_translate_vms (vfile)
3163: char * vfile;
3164: {
3165: char * p;
3166: char * targ;
3167:
3168: if (!vfile)
3169: return 0;
3170:
3171: targ = vtbuf;
3172:
3173: /* leading device or logical name is a root directory */
3174: if (p = strchr (vfile, ':'))
3175: {
3176: *targ++ = '/';
3177: while (vfile < p)
3178: *targ++ = *vfile++;
3179: vfile++;
3180: *targ++ = '/';
3181: }
3182: p = vfile;
3183: if (*p == '[' || *p == '<')
3184: {
3185: while (*++vfile != *p + 2)
3186: switch (*vfile)
3187: {
3188: case '.':
3189: if (vfile[-1] == *p)
3190: *targ++ = '.';
3191: *targ++ = '/';
3192: break;
3193:
3194: case '-':
3195: *targ++ = '.';
3196: *targ++ = '.';
3197: break;
3198:
3199: default:
3200: *targ++ = *vfile;
3201: break;
3202: }
3203: vfile++;
3204: *targ++ = '/';
3205: }
3206: while (*vfile)
3207: *targ++ = *vfile++;
3208:
3209: return vtbuf;
3210: }
3211:
3212: static char utbuf[NAM$C_MAXRSS+1];
3213:
3214: /* translate a unix path to a VMS file spec */
3215: char *
3216: sys_translate_unix (ufile)
3217: char * ufile;
3218: {
3219: int slash_seen = 0;
3220: char *p;
3221: char * targ;
3222:
3223: if (!ufile)
3224: return 0;
3225:
3226: targ = utbuf;
3227:
3228: if (*ufile == '/')
3229: {
3230: ufile++;
3231: }
3232:
3233: while (*ufile)
3234: {
3235: switch (*ufile)
3236: {
3237: case '/':
3238: if (slash_seen)
3239: if (index (&ufile[1], '/'))
3240: *targ++ = '.';
3241: else
3242: *targ++ = ']';
3243: else
3244: {
3245: *targ++ = ':';
3246: if (index (&ufile[1], '/'))
3247: *targ++ = '[';
3248: slash_seen = 1;
3249: }
3250: break;
3251:
3252: case '.':
3253: if (strncmp (ufile, "./", 2) == 0)
3254: {
3255: if (!slash_seen)
3256: {
3257: *targ++ = '[';
3258: slash_seen = 1;
3259: }
3260: ufile++; /* skip the dot */
3261: if (index (&ufile[1], '/'))
3262: *targ++ = '.';
3263: else
3264: *targ++ = ']';
3265: }
3266: else if (strncmp (ufile, "../", 3) == 0)
3267: {
3268: if (!slash_seen)
3269: {
3270: *targ++ = '[';
3271: slash_seen = 1;
3272: }
3273: *targ++ = '-';
3274: ufile += 2; /* skip the dots */
3275: if (index (&ufile[1], '/'))
3276: *targ++ = '.';
3277: else
3278: *targ++ = ']';
3279: }
3280: else
3281: *targ++ = *ufile;
3282: break;
3283:
3284: default:
3285: *targ++ = *ufile;
3286: break;
3287: }
3288: ufile++;
3289: }
3290: *targ = '\0';
3291:
3292: return utbuf;
3293: }
3294:
3295: char *
3296: getwd (pathname)
3297: char *pathname;
3298: {
3299: char *ptr;
3300: strcpy (pathname, egetenv ("PATH"));
3301:
3302: ptr = pathname;
3303: while (*ptr)
3304: {
3305: if ('a' <= *ptr && *ptr <= 'z')
3306: *ptr -= 040;
3307: ptr++;
3308: }
3309: return pathname;
3310: }
3311:
3312: getppid ()
3313: {
3314: long item_code = JPI$_OWNER;
3315: unsigned long parent_id;
3316: int status;
3317:
3318: if (((status = LIB$GETJPI (&item_code, 0, 0, &parent_id)) & 1) == 0)
3319: {
3320: errno = EVMSERR;
3321: vaxc$errno = status;
3322: return -1;
3323: }
3324: return parent_id;
3325: }
3326:
3327: #undef getuid
3328: unsigned
3329: sys_getuid ()
3330: {
3331: return (getgid () << 16) | getuid ();
3332: }
3333:
3334: int
3335: sys_read (fildes, buf, nbyte)
3336: int fildes;
3337: char *buf;
3338: unsigned int nbyte;
3339: {
3340: return read (fildes, buf, (nbyte < MAXIOSIZE ? nbyte : MAXIOSIZE));
3341: }
3342:
3343: #if 0
3344: int
3345: sys_write (fildes, buf, nbyte)
3346: int fildes;
3347: char *buf;
3348: unsigned int nbyte;
3349: {
3350: register int nwrote, rtnval = 0;
3351:
3352: while (nbyte > MAXIOSIZE && (nwrote = write (fildes, buf, MAXIOSIZE)) > 0) {
3353: nbyte -= nwrote;
3354: buf += nwrote;
3355: rtnval += nwrote;
3356: }
3357: if (nwrote < 0)
3358: return rtnval ? rtnval : -1;
3359: if ((nwrote = write (fildes, buf, nbyte)) < 0)
3360: return rtnval ? rtnval : -1;
3361: return (rtnval + nwrote);
3362: }
3363: #endif /* 0 */
3364:
3365: /*
3366: * VAX/VMS VAX C RTL really loses. It insists that records
3367: * end with a newline (carriage return) character, and if they
3368: * don't it adds one (nice of it isn't it!)
3369: *
3370: * Thus we do this stupidity below.
3371: */
3372:
3373: int
3374: sys_write (fildes, buf, nbytes)
3375: int fildes;
3376: char *buf;
3377: unsigned int nbytes;
3378: {
3379: register char *p;
3380: register char *e;
3381: int sum = 0;
3382: struct stat st;
3383:
3384: fstat (fildes, &st);
3385: p = buf;
3386: while (nbytes > 0)
3387: {
3388: int len, retval;
3389:
3390: /* Handle fixed-length files with carriage control. */
3391: if (st.st_fab_rfm == FAB$C_FIX
3392: && ((st.st_fab_rat & (FAB$M_FTN | FAB$M_CR)) != 0))
3393: {
3394: len = st.st_fab_mrs;
3395: retval = write (fildes, p, min (len, nbytes));
3396: if (retval != len)
3397: return -1;
3398: retval++; /* This skips the implied carriage control */
3399: }
3400: else
3401: {
3402: e = p + min (MAXIOSIZE, nbytes) - 1;
3403: while (*e != '\n' && e > p) e--;
3404: if (p == e) /* Ok.. so here we add a newline... sigh. */
3405: e = p + min (MAXIOSIZE, nbytes) - 1;
3406: len = e + 1 - p;
3407: retval = write (fildes, p, len);
3408: if (retval != len)
3409: return -1;
3410: }
3411: p += retval;
3412: sum += retval;
3413: nbytes -= retval;
3414: }
3415: return sum;
3416: }
3417:
3418: /* Create file NEW copying its attributes from file OLD. If
3419: OLD is 0 or does not exist, create based on the value of
3420: vms_stmlf_recfm. */
3421:
3422: /* Protection value the file should ultimately have.
3423: Set by create_copy_attrs, and use by rename_sansversions. */
3424: static unsigned short int fab_final_pro;
3425:
3426: int
3427: creat_copy_attrs (old, new)
3428: char *old, *new;
3429: {
3430: struct FAB fab = cc$rms_fab;
3431: struct XABPRO xabpro;
3432: char aclbuf[256]; /* Choice of size is arbitrary. See below. */
3433: extern int vms_stmlf_recfm;
3434:
3435: if (old)
3436: {
3437: fab.fab$b_fac = FAB$M_GET;
3438: fab.fab$l_fna = old;
3439: fab.fab$b_fns = strlen (old);
3440: fab.fab$l_xab = (char *) &xabpro;
3441: xabpro = cc$rms_xabpro;
3442: xabpro.xab$l_aclbuf = aclbuf;
3443: xabpro.xab$w_aclsiz = sizeof aclbuf;
3444: /* Call $OPEN to fill in the fab & xabpro fields. */
3445: if (sys$open (&fab, 0, 0) & 1)
3446: {
3447: sys$close (&fab, 0, 0);
3448: fab.fab$l_alq = 0; /* zero the allocation quantity */
3449: if (xabpro.xab$w_acllen > 0)
3450: {
3451: if (xabpro.xab$w_acllen > sizeof aclbuf)
3452: /* If the acl buffer was too short, redo open with longer one.
3453: Wouldn't need to do this if there were some system imposed
3454: limit on the size of an ACL, but I can't find any such. */
3455: {
3456: xabpro.xab$l_aclbuf = (char *) alloca (xabpro.xab$w_acllen);
3457: xabpro.xab$w_aclsiz = xabpro.xab$w_acllen;
3458: if (sys$open (&fab, 0, 0) & 1)
3459: sys$close (&fab, 0, 0);
3460: else
3461: old = 0;
3462: }
3463: }
3464: else
3465: xabpro.xab$l_aclbuf = 0;
3466: }
3467: else
3468: old = 0;
3469: }
3470: fab.fab$l_fna = new;
3471: fab.fab$b_fns = strlen (new);
3472: if (!old)
3473: {
3474: fab.fab$l_xab = 0;
3475: fab.fab$b_rfm = vms_stmlf_recfm ? FAB$C_STMLF : FAB$C_VAR;
3476: fab.fab$b_rat = FAB$M_CR;
3477: }
3478: /* Set the file protections such that we will be able to manipulate
3479: this file. Once we are done writing and renaming it, we will set
3480: the protections back. */
3481: if (old)
3482: fab_final_pro = xabpro.xab$w_pro;
3483: else
3484: sys$setdfprot (0, &fab_final_pro);
3485: xabpro.xab$w_pro &= 0xff0f; /* set O:rewd for now. This is set back later. */
3486: /* Create the new file with either default attrs or attrs copied
3487: from old file. */
3488: if (!(SYS$CREATE (&fab, 0, 0) & 1))
3489: return -1;
3490: sys$close (&fab, 0, 0);
3491: /* As this is a "replacement" for creat, return a file descriptor
3492: opened for writing. */
3493: return open (new, O_WRONLY);
3494: }
3495:
3496: #ifdef creat
3497: #undef creat
3498: #include <varargs.h>
3499: #ifdef __GNUC__
3500: #ifndef va_count
3501: #define va_count(X) ((X) = *(((int *) &(va_alist)) - 1))
3502: #endif
3503: #endif
3504:
3505: sys_creat (va_alist)
3506: va_dcl
3507: {
3508: va_list list_incrementor;
3509: char *name;
3510: int mode;
3511: int rfd; /* related file descriptor */
3512: int fd; /* Our new file descriptor */
3513: int count;
3514: struct stat st_buf;
3515: char rfm[12];
3516: char rat[15];
3517: char mrs[13];
3518: char fsz[13];
3519: extern int vms_stmlf_recfm;
3520:
3521: va_count (count);
3522: va_start (list_incrementor);
3523: name = va_arg (list_incrementor, char *);
3524: mode = va_arg (list_incrementor, int);
3525: if (count > 2)
3526: rfd = va_arg (list_incrementor, int);
3527: va_end (list_incrementor);
3528: if (count > 2)
3529: {
3530: /* Use information from the related file descriptor to set record
3531: format of the newly created file. */
3532: fstat (rfd, &st_buf);
3533: switch (st_buf.st_fab_rfm)
3534: {
3535: case FAB$C_FIX:
3536: strcpy (rfm, "rfm = fix");
3537: sprintf (mrs, "mrs = %d", st_buf.st_fab_mrs);
3538: strcpy (rat, "rat = ");
3539: if (st_buf.st_fab_rat & FAB$M_CR)
3540: strcat (rat, "cr");
3541: else if (st_buf.st_fab_rat & FAB$M_FTN)
3542: strcat (rat, "ftn");
3543: else if (st_buf.st_fab_rat & FAB$M_PRN)
3544: strcat (rat, "prn");
3545: if (st_buf.st_fab_rat & FAB$M_BLK)
3546: if (st_buf.st_fab_rat & (FAB$M_CR|FAB$M_FTN|FAB$M_PRN))
3547: strcat (rat, ", blk");
3548: else
3549: strcat (rat, "blk");
3550: return creat (name, 0, rfm, rat, mrs);
3551:
3552: case FAB$C_VFC:
3553: strcpy (rfm, "rfm = vfc");
3554: sprintf (fsz, "fsz = %d", st_buf.st_fab_fsz);
3555: strcpy (rat, "rat = ");
3556: if (st_buf.st_fab_rat & FAB$M_CR)
3557: strcat (rat, "cr");
3558: else if (st_buf.st_fab_rat & FAB$M_FTN)
3559: strcat (rat, "ftn");
3560: else if (st_buf.st_fab_rat & FAB$M_PRN)
3561: strcat (rat, "prn");
3562: if (st_buf.st_fab_rat & FAB$M_BLK)
3563: if (st_buf.st_fab_rat & (FAB$M_CR|FAB$M_FTN|FAB$M_PRN))
3564: strcat (rat, ", blk");
3565: else
3566: strcat (rat, "blk");
3567: return creat (name, 0, rfm, rat, fsz);
3568:
3569: case FAB$C_STM:
3570: strcpy (rfm, "rfm = stm");
3571: break;
3572:
3573: case FAB$C_STMCR:
3574: strcpy (rfm, "rfm = stmcr");
3575: break;
3576:
3577: case FAB$C_STMLF:
3578: strcpy (rfm, "rfm = stmlf");
3579: break;
3580:
3581: case FAB$C_UDF:
3582: strcpy (rfm, "rfm = udf");
3583: break;
3584:
3585: case FAB$C_VAR:
3586: strcpy (rfm, "rfm = var");
3587: break;
3588: }
3589: strcpy (rat, "rat = ");
3590: if (st_buf.st_fab_rat & FAB$M_CR)
3591: strcat (rat, "cr");
3592: else if (st_buf.st_fab_rat & FAB$M_FTN)
3593: strcat (rat, "ftn");
3594: else if (st_buf.st_fab_rat & FAB$M_PRN)
3595: strcat (rat, "prn");
3596: if (st_buf.st_fab_rat & FAB$M_BLK)
3597: if (st_buf.st_fab_rat & (FAB$M_CR|FAB$M_FTN|FAB$M_PRN))
3598: strcat (rat, ", blk");
3599: else
3600: strcat (rat, "blk");
3601: }
3602: else
3603: {
3604: strcpy (rfm, vms_stmlf_recfm ? "rfm = stmlf" : "rfm=var");
3605: strcpy (rat, "rat=cr");
3606: }
3607: /* Until the VAX C RTL fixes the many bugs with modes, always use
3608: mode 0 to get the user's default protection. */
3609: fd = creat (name, 0, rfm, rat);
3610: if (fd < 0 && errno == EEXIST)
3611: {
3612: if (unlink (name) < 0)
3613: report_file_error ("delete", build_string (name));
3614: fd = creat (name, 0, rfm, rat);
3615: }
3616: return fd;
3617: }
3618: #endif /* creat */
3619:
3620: /* fwrite to stdout is S L O W. Speed it up by using fputc...*/
3621: sys_fwrite (ptr, size, num, fp)
3622: register char * ptr;
3623: FILE * fp;
3624: {
3625: register int tot = num * size;
3626:
3627: while (tot--)
3628: fputc (*ptr++, fp);
3629: }
3630:
3631: /*
3632: * The VMS C library routine creat() actually creates a new version of an
3633: * existing file rather than truncating the old version. There are times
3634: * when this is not the desired behavior, for instance, when writing an
3635: * auto save file (you only want one version), or when you don't have
3636: * write permission in the directory containing the file (but the file
3637: * itself is writable). Hence this routine, which is equivalent to
3638: * "close (creat (fn, 0));" on Unix if fn already exists.
3639: */
3640: int
3641: vms_truncate (fn)
3642: char *fn;
3643: {
3644: struct FAB xfab = cc$rms_fab;
3645: struct RAB xrab = cc$rms_rab;
3646: int status;
3647:
3648: xfab.fab$l_fop = FAB$M_TEF; /* free allocated but unused blocks on close */
3649: xfab.fab$b_fac = FAB$M_TRN | FAB$M_GET; /* allow truncate and get access */
3650: xfab.fab$b_shr = FAB$M_NIL; /* allow no sharing - file must be locked */
3651: xfab.fab$l_fna = fn;
3652: xfab.fab$b_fns = strlen (fn);
3653: xfab.fab$l_dna = ";0"; /* default to latest version of the file */
3654: xfab.fab$b_dns = 2;
3655: xrab.rab$l_fab = &xfab;
3656:
3657: /* This gibberish opens the file, positions to the first record, and
3658: deletes all records from there until the end of file. */
3659: if ((sys$open (&xfab) & 01) == 01)
3660: {
3661: if ((sys$connect (&xrab) & 01) == 01 &&
3662: (sys$find (&xrab) & 01) == 01 &&
3663: (sys$truncate (&xrab) & 01) == 01)
3664: status = 0;
3665: else
3666: status = -1;
3667: }
3668: else
3669: status = -1;
3670: sys$close (&xfab);
3671: return status;
3672: }
3673:
3674: /* Define this symbol to actually read SYSUAF.DAT. This requires either
3675: SYSPRV or a readable SYSUAF.DAT. */
3676:
3677: #ifdef READ_SYSUAF
3678: /*
3679: * getuaf.c
3680: *
3681: * Routine to read the VMS User Authorization File and return
3682: * a specific user's record.
3683: */
3684:
3685: static struct UAF retuaf;
3686:
3687: struct UAF *
3688: get_uaf_name (uname)
3689: char * uname;
3690: {
3691: register status;
3692: struct FAB uaf_fab;
3693: struct RAB uaf_rab;
3694:
3695: uaf_fab = cc$rms_fab;
3696: uaf_rab = cc$rms_rab;
3697: /* initialize fab fields */
3698: uaf_fab.fab$l_fna = "SYS$SYSTEM:SYSUAF.DAT";
3699: uaf_fab.fab$b_fns = 21;
3700: uaf_fab.fab$b_fac = FAB$M_GET;
3701: uaf_fab.fab$b_org = FAB$C_IDX;
3702: uaf_fab.fab$b_shr = FAB$M_GET|FAB$M_PUT|FAB$M_UPD|FAB$M_DEL;
3703: /* initialize rab fields */
3704: uaf_rab.rab$l_fab = &uaf_fab;
3705: /* open the User Authorization File */
3706: status = sys$open (&uaf_fab);
3707: if (!(status&1))
3708: {
3709: errno = EVMSERR;
3710: vaxc$errno = status;
3711: return 0;
3712: }
3713: status = sys$connect (&uaf_rab);
3714: if (!(status&1))
3715: {
3716: errno = EVMSERR;
3717: vaxc$errno = status;
3718: return 0;
3719: }
3720: /* read the requested record - index is in uname */
3721: uaf_rab.rab$l_kbf = uname;
3722: uaf_rab.rab$b_ksz = strlen (uname);
3723: uaf_rab.rab$b_rac = RAB$C_KEY;
3724: uaf_rab.rab$l_ubf = (char *)&retuaf;
3725: uaf_rab.rab$w_usz = sizeof retuaf;
3726: status = sys$get (&uaf_rab);
3727: if (!(status&1))
3728: {
3729: errno = EVMSERR;
3730: vaxc$errno = status;
3731: return 0;
3732: }
3733: /* close the User Authorization File */
3734: status = sys$disconnect (&uaf_rab);
3735: if (!(status&1))
3736: {
3737: errno = EVMSERR;
3738: vaxc$errno = status;
3739: return 0;
3740: }
3741: status = sys$close (&uaf_fab);
3742: if (!(status&1))
3743: {
3744: errno = EVMSERR;
3745: vaxc$errno = status;
3746: return 0;
3747: }
3748: return &retuaf;
3749: }
3750:
3751: struct UAF *
3752: get_uaf_uic (uic)
3753: unsigned long uic;
3754: {
3755: register status;
3756: struct FAB uaf_fab;
3757: struct RAB uaf_rab;
3758:
3759: uaf_fab = cc$rms_fab;
3760: uaf_rab = cc$rms_rab;
3761: /* initialize fab fields */
3762: uaf_fab.fab$l_fna = "SYS$SYSTEM:SYSUAF.DAT";
3763: uaf_fab.fab$b_fns = 21;
3764: uaf_fab.fab$b_fac = FAB$M_GET;
3765: uaf_fab.fab$b_org = FAB$C_IDX;
3766: uaf_fab.fab$b_shr = FAB$M_GET|FAB$M_PUT|FAB$M_UPD|FAB$M_DEL;
3767: /* initialize rab fields */
3768: uaf_rab.rab$l_fab = &uaf_fab;
3769: /* open the User Authorization File */
3770: status = sys$open (&uaf_fab);
3771: if (!(status&1))
3772: {
3773: errno = EVMSERR;
3774: vaxc$errno = status;
3775: return 0;
3776: }
3777: status = sys$connect (&uaf_rab);
3778: if (!(status&1))
3779: {
3780: errno = EVMSERR;
3781: vaxc$errno = status;
3782: return 0;
3783: }
3784: /* read the requested record - index is in uic */
3785: uaf_rab.rab$b_krf = 1; /* 1st alternate key */
3786: uaf_rab.rab$l_kbf = (char *) &uic;
3787: uaf_rab.rab$b_ksz = sizeof uic;
3788: uaf_rab.rab$b_rac = RAB$C_KEY;
3789: uaf_rab.rab$l_ubf = (char *)&retuaf;
3790: uaf_rab.rab$w_usz = sizeof retuaf;
3791: status = sys$get (&uaf_rab);
3792: if (!(status&1))
3793: {
3794: errno = EVMSERR;
3795: vaxc$errno = status;
3796: return 0;
3797: }
3798: /* close the User Authorization File */
3799: status = sys$disconnect (&uaf_rab);
3800: if (!(status&1))
3801: {
3802: errno = EVMSERR;
3803: vaxc$errno = status;
3804: return 0;
3805: }
3806: status = sys$close (&uaf_fab);
3807: if (!(status&1))
3808: {
3809: errno = EVMSERR;
3810: vaxc$errno = status;
3811: return 0;
3812: }
3813: return &retuaf;
3814: }
3815:
3816: static struct passwd retpw;
3817:
3818: struct passwd *
3819: cnv_uaf_pw (up)
3820: struct UAF * up;
3821: {
3822: char * ptr;
3823:
3824: /* copy these out first because if the username is 32 chars, the next
3825: section will overwrite the first byte of the UIC */
3826: retpw.pw_uid = up->uaf$w_mem;
3827: retpw.pw_gid = up->uaf$w_grp;
3828:
3829: /* I suppose this is not the best sytle, to possibly overwrite one
3830: byte beyond the end of the field, but what the heck... */
3831: ptr = &up->uaf$t_username[UAF$S_USERNAME];
3832: while (ptr[-1] == ' ')
3833: ptr--;
3834: *ptr = '\0';
3835: strcpy (retpw.pw_name, up->uaf$t_username);
3836:
3837: /* the rest of these are counted ascii strings */
3838: strncpy (retpw.pw_gecos, &up->uaf$t_owner[1], up->uaf$t_owner[0]);
3839: retpw.pw_gecos[up->uaf$t_owner[0]] = '\0';
3840: strncpy (retpw.pw_dir, &up->uaf$t_defdev[1], up->uaf$t_defdev[0]);
3841: retpw.pw_dir[up->uaf$t_defdev[0]] = '\0';
3842: strncat (retpw.pw_dir, &up->uaf$t_defdir[1], up->uaf$t_defdir[0]);
3843: retpw.pw_dir[up->uaf$t_defdev[0] + up->uaf$t_defdir[0]] = '\0';
3844: strncpy (retpw.pw_shell, &up->uaf$t_defcli[1], up->uaf$t_defcli[0]);
3845: retpw.pw_shell[up->uaf$t_defcli[0]] = '\0';
3846:
3847: return &retpw;
3848: }
3849: #else /* not READ_SYSUAF */
3850: static struct passwd retpw;
3851: #endif /* not READ_SYSUAF */
3852:
3853: struct passwd *
3854: getpwnam (name)
3855: char * name;
3856: {
3857: #ifdef READ_SYSUAF
3858: struct UAF *up;
3859: #else
3860: char * user;
3861: char * dir;
3862: unsigned char * full;
3863: #endif /* READ_SYSUAF */
3864: char *ptr = name;
3865:
3866: while (*ptr)
3867: {
3868: if ('a' <= *ptr && *ptr <= 'z')
3869: *ptr -= 040;
3870: ptr++;
3871: }
3872: #ifdef READ_SYSUAF
3873: if (!(up = get_uaf_name (name)))
3874: return 0;
3875: return cnv_uaf_pw (up);
3876: #else
3877: if (strcmp (name, getenv ("USER")) == 0)
3878: {
3879: retpw.pw_uid = getuid ();
3880: retpw.pw_gid = getgid ();
3881: strcpy (retpw.pw_name, name);
3882: if (full = (unsigned char*) egetenv ("FULLNAME"))
3883: strcpy (retpw.pw_gecos, full);
3884: else
3885: *retpw.pw_gecos = '\0';
3886: strcpy (retpw.pw_dir, egetenv ("HOME"));
3887: *retpw.pw_shell = '\0';
3888: return &retpw;
3889: }
3890: else
3891: return 0;
3892: #endif /* not READ_SYSUAF */
3893: }
3894:
3895: struct passwd *
3896: getpwuid (uid)
3897: unsigned long uid;
3898: {
3899: #ifdef READ_SYSUAF
3900: struct UAF * up;
3901:
3902: if (!(up = get_uaf_uic (uid)))
3903: return 0;
3904: return cnv_uaf_pw (up);
3905: #else
3906: if (uid == sys_getuid ())
3907: return getpwnam (egetenv ("USER"));
3908: else
3909: return 0;
3910: #endif /* not READ_SYSUAF */
3911: }
3912:
3913: /* return total address space available to the current process. This is
3914: the sum of the current p0 size, p1 size and free page table entries
3915: available. */
3916: vlimit ()
3917: {
3918: int item_code;
3919: unsigned long free_pages;
3920: unsigned long frep0va;
3921: unsigned long frep1va;
3922: register status;
3923:
3924: item_code = JPI$_FREPTECNT;
3925: if (((status = LIB$GETJPI (&item_code, 0, 0, &free_pages)) & 1) == 0)
3926: {
3927: errno = EVMSERR;
3928: vaxc$errno = status;
3929: return -1;
3930: }
3931: free_pages *= 512;
3932:
3933: item_code = JPI$_FREP0VA;
3934: if (((status = LIB$GETJPI (&item_code, 0, 0, &frep0va)) & 1) == 0)
3935: {
3936: errno = EVMSERR;
3937: vaxc$errno = status;
3938: return -1;
3939: }
3940: item_code = JPI$_FREP1VA;
3941: if (((status = LIB$GETJPI (&item_code, 0, 0, &frep1va)) & 1) == 0)
3942: {
3943: errno = EVMSERR;
3944: vaxc$errno = status;
3945: return -1;
3946: }
3947:
3948: return free_pages + frep0va + (0x7fffffff - frep1va);
3949: }
3950:
3951: define_logical_name (varname, string)
3952: char *varname;
3953: char *string;
3954: {
3955: struct dsc$descriptor_s strdsc =
3956: {strlen (string), DSC$K_DTYPE_T, DSC$K_CLASS_S, string};
3957: struct dsc$descriptor_s envdsc =
3958: {strlen (varname), DSC$K_DTYPE_T, DSC$K_CLASS_S, varname};
3959: struct dsc$descriptor_s lnmdsc =
3960: {7, DSC$K_DTYPE_T, DSC$K_CLASS_S, "LNM$JOB"};
3961:
3962: return LIB$SET_LOGICAL (&envdsc, &strdsc, &lnmdsc, 0, 0);
3963: }
3964:
3965: delete_logical_name (varname)
3966: char *varname;
3967: {
3968: struct dsc$descriptor_s envdsc =
3969: {strlen (varname), DSC$K_DTYPE_T, DSC$K_CLASS_S, varname};
3970: struct dsc$descriptor_s lnmdsc =
3971: {7, DSC$K_DTYPE_T, DSC$K_CLASS_S, "LNM$JOB"};
3972:
3973: return LIB$DELETE_LOGICAL (&envdsc, &lnmdsc);
3974: }
3975:
3976: ulimit ()
3977: {}
3978:
3979: setpriority ()
3980: {}
3981:
3982: setpgrp ()
3983: {}
3984:
3985: execvp ()
3986: {
3987: error ("execvp system call not implemented");
3988: }
3989:
3990: int
3991: rename (from, to)
3992: char *from, *to;
3993: {
3994: int status;
3995: struct FAB from_fab = cc$rms_fab, to_fab = cc$rms_fab;
3996: struct NAM from_nam = cc$rms_nam, to_nam = cc$rms_nam;
3997: char from_esn[NAM$C_MAXRSS];
3998: char to_esn[NAM$C_MAXRSS];
3999:
4000: from_fab.fab$l_fna = from;
4001: from_fab.fab$b_fns = strlen (from);
4002: from_fab.fab$l_nam = &from_nam;
4003: from_fab.fab$l_fop = FAB$M_NAM;
4004:
4005: from_nam.nam$l_esa = from_esn;
4006: from_nam.nam$b_ess = sizeof from_esn;
4007:
4008: to_fab.fab$l_fna = to;
4009: to_fab.fab$b_fns = strlen (to);
4010: to_fab.fab$l_nam = &to_nam;
4011: to_fab.fab$l_fop = FAB$M_NAM;
4012:
4013: to_nam.nam$l_esa = to_esn;
4014: to_nam.nam$b_ess = sizeof to_esn;
4015:
4016: status = SYS$RENAME (&from_fab, 0, 0, &to_fab);
4017:
4018: if (status & 1)
4019: return 0;
4020: else
4021: {
4022: if (status == RMS$_DEV)
4023: errno = EXDEV;
4024: else
4025: errno = EVMSERR;
4026: vaxc$errno = status;
4027: return -1;
4028: }
4029: }
4030:
4031: /* This function renames a file like `rename', but it strips
4032: the version number from the "to" filename, such that the "to" file is
4033: will always be a new version. It also sets the file protection once it is
4034: finished. The protection that we will use is stored in fab_final_pro,
4035: and was set when we did a creat_copy_attrs to create the file that we
4036: are renaming.
4037:
4038: We could use the chmod function, but Eunichs uses 3 bits per user category
4039: to describe the protection, and VMS uses 4 (write and delete are seperate
4040: bits). To maintain portability, the VMS implementation of `chmod' wires
4041: the W and D bits together. */
4042:
4043:
4044: static struct fibdef fib; /* We need this initialized to zero */
4045: char vms_file_written[NAM$C_MAXRSS];
4046:
4047: int
4048: rename_sans_version (from,to)
4049: char *from, *to;
4050: {
4051: short int chan;
4052: int stat;
4053: short int iosb[4];
4054: int status;
4055: struct FAB to_fab = cc$rms_fab;
4056: struct NAM to_nam = cc$rms_nam;
4057: struct dsc$descriptor fib_d ={sizeof (fib),0,0,(char*) &fib};
4058: struct dsc$descriptor fib_attr[2]
4059: = {{sizeof (fab_final_pro),ATR$C_FPRO,0,(char*) &fab_final_pro},{0,0,0,0}};
4060: char to_esn[NAM$C_MAXRSS];
4061:
4062: $DESCRIPTOR (disk,to_esn);
4063:
4064: to_fab.fab$l_fna = to;
4065: to_fab.fab$b_fns = strlen (to);
4066: to_fab.fab$l_nam = &to_nam;
4067: to_fab.fab$l_fop = FAB$M_NAM;
4068:
4069: to_nam.nam$l_esa = to_esn;
4070: to_nam.nam$b_ess = sizeof to_esn;
4071:
4072: status = SYS$PARSE (&to_fab, 0, 0); /* figure out the full file name */
4073:
4074: if (to_nam.nam$l_fnb && NAM$M_EXP_VER)
4075: *(to_nam.nam$l_ver) = '\0';
4076:
4077: stat = rename (from, to_esn);
4078: if (stat < 0)
4079: return stat;
4080:
4081: strcpy (vms_file_written, to_esn);
4082:
4083: to_fab.fab$l_fna = vms_file_written; /* this points to the versionless name */
4084: to_fab.fab$b_fns = strlen (vms_file_written);
4085:
4086: /* Now set the file protection to the correct value */
4087: sys$open (&to_fab, 0, 0); /* This fills in the nam$w_fid fields */
4088:
4089: /* Copy these fields into the fib */
4090: fib.fib$r_fid_overlay.fib$w_fid[0] = to_nam.nam$w_fid[0];
4091: fib.fib$r_fid_overlay.fib$w_fid[1] = to_nam.nam$w_fid[1];
4092: fib.fib$r_fid_overlay.fib$w_fid[2] = to_nam.nam$w_fid[2];
4093:
4094: sys$close (&to_fab, 0, 0);
4095:
4096: stat = sys$assign (&disk, &chan, 0, 0); /* open a channel to the disk */
4097: if (!stat)
4098: lib$signal (stat);
4099: stat = sys$qiow (0, chan, IO$_MODIFY, iosb, 0, 0, &fib_d,
4100: 0, 0, 0, &fib_attr, 0);
4101: if (!stat)
4102: lib$signal (stat);
4103: stat = sys$dassgn (chan);
4104: if (!stat)
4105: lib$signal (stat);
4106: strcpy (vms_file_written, to_esn); /* We will write this to the screen*/
4107: return 0;
4108: }
4109:
4110: link (file, new)
4111: char * file, * new;
4112: {
4113: register status;
4114: struct FAB fab;
4115: struct NAM nam;
4116: unsigned short fid[3];
4117: char esa[NAM$C_MAXRSS];
4118:
4119: fab = cc$rms_fab;
4120: fab.fab$l_fop = FAB$M_OFP;
4121: fab.fab$l_fna = file;
4122: fab.fab$b_fns = strlen (file);
4123: fab.fab$l_nam = &nam;
4124:
4125: nam = cc$rms_nam;
4126: nam.nam$l_esa = esa;
4127: nam.nam$b_ess = NAM$C_MAXRSS;
4128:
4129: status = SYS$PARSE (&fab);
4130: if ((status & 1) == 0)
4131: {
4132: errno = EVMSERR;
4133: vaxc$errno = status;
4134: return -1;
4135: }
4136: status = SYS$SEARCH (&fab);
4137: if ((status & 1) == 0)
4138: {
4139: errno = EVMSERR;
4140: vaxc$errno = status;
4141: return -1;
4142: }
4143:
4144: fid[0] = nam.nam$w_fid[0];
4145: fid[1] = nam.nam$w_fid[1];
4146: fid[2] = nam.nam$w_fid[2];
4147:
4148: fab.fab$l_fna = new;
4149: fab.fab$b_fns = strlen (new);
4150:
4151: status = SYS$PARSE (&fab);
4152: if ((status & 1) == 0)
4153: {
4154: errno = EVMSERR;
4155: vaxc$errno = status;
4156: return -1;
4157: }
4158:
4159: nam.nam$w_fid[0] = fid[0];
4160: nam.nam$w_fid[1] = fid[1];
4161: nam.nam$w_fid[2] = fid[2];
4162:
4163: nam.nam$l_esa = nam.nam$l_name;
4164: nam.nam$b_esl = nam.nam$b_name + nam.nam$b_type + nam.nam$b_ver;
4165:
4166: status = SYS$ENTER (&fab);
4167: if ((status & 1) == 0)
4168: {
4169: errno = EVMSERR;
4170: vaxc$errno = status;
4171: return -1;
4172: }
4173:
4174: return 0;
4175: }
4176:
4177: croak (badfunc)
4178: char *badfunc;
4179: {
4180: printf ("%s not yet implemented\r\n", badfunc);
4181: reset_sys_modes ();
4182: exit (1);
4183: }
4184:
4185: long
4186: random ()
4187: {
4188: /* Arrange to return a range centered on zero. */
4189: return rand () - (1 << 30);
4190: }
4191:
4192: srandom (seed)
4193: {
4194: srand (seed);
4195: }
4196: #endif /* VMS */
4197:
4198: #ifdef WRONG_NAME_INSQUE
4199:
4200: insque(q,p)
4201: caddr_t q,p;
4202: {
4203: _insque(q,p);
4204: }
4205:
4206: #endif
4207:
4208: #ifdef AIX
4209:
4210: /* Called from init_sys_modes. */
4211: hft_init ()
4212: {
4213: int junk;
4214:
4215: /* If we're not on an HFT we shouldn't do any of this. We determine
4216: if we are on an HFT by trying to get an HFT error code. If this
4217: call fails, we're not on an HFT. */
4218: #ifdef IBMR2AIX
4219: if (ioctl (0, HFQERROR, &junk) < 0)
4220: return;
4221: #else /* not IBMR2AIX */
4222: if (ioctl (0, HFQEIO, 0) < 0)
4223: return;
4224: #endif /* not IBMR2AIX */
4225:
4226: /* On AIX the default hft keyboard mapping uses backspace rather than delete
4227: as the rubout key's ASCII code. Here this is changed. The bug is that
4228: there's no way to determine the old mapping, so in reset_sys_modes
4229: we need to assume that the normal map had been present. Of course, this
4230: code also doesn't help if on a terminal emulator which doesn't understand
4231: HFT VTD's. */
4232: {
4233: struct hfbuf buf;
4234: struct hfkeymap keymap;
4235:
4236: buf.hf_bufp = (char *)&keymap;
4237: buf.hf_buflen = sizeof (keymap);
4238: keymap.hf_nkeys = 2;
4239: keymap.hfkey[0].hf_kpos = 15;
4240: keymap.hfkey[0].hf_kstate = HFMAPCHAR | HFSHFNONE;
4241: #ifdef IBMR2AIX
4242: keymap.hfkey[0].hf_keyidh = '<';
4243: #else /* not IBMR2AIX */
4244: keymap.hfkey[0].hf_page = '<';
4245: #endif /* not IBMR2AIX */
4246: keymap.hfkey[0].hf_char = 127;
4247: keymap.hfkey[1].hf_kpos = 15;
4248: keymap.hfkey[1].hf_kstate = HFMAPCHAR | HFSHFSHFT;
4249: #ifdef IBMR2AIX
4250: keymap.hfkey[1].hf_keyidh = '<';
4251: #else /* not IBMR2AIX */
4252: keymap.hfkey[1].hf_page = '<';
4253: #endif /* not IBMR2AIX */
4254: keymap.hfkey[1].hf_char = 127;
4255: hftctl (0, HFSKBD, &buf);
4256: }
4257: /* The HFT system on AIX doesn't optimize for scrolling, so it's really ugly
4258: at times. */
4259: line_ins_del_ok = char_ins_del_ok = 0;
4260: }
4261:
4262: /* Reset the rubout key to backspace. */
4263:
4264: hft_reset ()
4265: {
4266: struct hfbuf buf;
4267: struct hfkeymap keymap;
4268: int junk;
4269:
4270: #ifdef IBMR2AIX
4271: if (ioctl (0, HFQERROR, &junk) < 0)
4272: return;
4273: #else /* not IBMR2AIX */
4274: if (ioctl (0, HFQEIO, 0) < 0)
4275: return;
4276: #endif /* not IBMR2AIX */
4277:
4278: buf.hf_bufp = (char *)&keymap;
4279: buf.hf_buflen = sizeof (keymap);
4280: keymap.hf_nkeys = 2;
4281: keymap.hfkey[0].hf_kpos = 15;
4282: keymap.hfkey[0].hf_kstate = HFMAPCHAR | HFSHFNONE;
4283: #ifdef IBMR2AIX
4284: keymap.hfkey[0].hf_keyidh = '<';
4285: #else /* not IBMR2AIX */
4286: keymap.hfkey[0].hf_page = '<';
4287: #endif /* not IBMR2AIX */
4288: keymap.hfkey[0].hf_char = 8;
4289: keymap.hfkey[1].hf_kpos = 15;
4290: keymap.hfkey[1].hf_kstate = HFMAPCHAR | HFSHFSHFT;
4291: #ifdef IBMR2AIX
4292: keymap.hfkey[1].hf_keyidh = '<';
4293: #else /* not IBMR2AIX */
4294: keymap.hfkey[1].hf_page = '<';
4295: #endif /* not IBMR2AIX */
4296: keymap.hfkey[1].hf_char = 8;
4297: hftctl (0, HFSKBD, &buf);
4298: }
4299:
4300: #endif /* AIX */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.