Daily bump.
[official-gcc.git] / libiberty / pex-unix.c
blob0715115747826d510a960ae772cccc052012ee5a
1 /* Utilities to execute a program in a subprocess (possibly linked by pipes
2 with other subprocesses), and wait for it. Generic Unix version
3 (also used for UWIN and VMS).
4 Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2009,
5 2010 Free Software Foundation, Inc.
7 This file is part of the libiberty library.
8 Libiberty is free software; you can redistribute it and/or
9 modify it under the terms of the GNU Library General Public
10 License as published by the Free Software Foundation; either
11 version 2 of the License, or (at your option) any later version.
13 Libiberty is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Library General Public License for more details.
18 You should have received a copy of the GNU Library General Public
19 License along with libiberty; see the file COPYING.LIB. If not,
20 write to the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
21 Boston, MA 02110-1301, USA. */
23 #include "config.h"
24 #include "libiberty.h"
25 #include "pex-common.h"
27 #include <stdio.h>
28 #include <signal.h>
29 #include <errno.h>
30 #ifdef NEED_DECLARATION_ERRNO
31 extern int errno;
32 #endif
33 #ifdef HAVE_STDLIB_H
34 #include <stdlib.h>
35 #endif
36 #ifdef HAVE_STRING_H
37 #include <string.h>
38 #endif
39 #ifdef HAVE_UNISTD_H
40 #include <unistd.h>
41 #endif
43 #include <sys/types.h>
45 #ifdef HAVE_FCNTL_H
46 #include <fcntl.h>
47 #endif
48 #ifdef HAVE_SYS_WAIT_H
49 #include <sys/wait.h>
50 #endif
51 #ifdef HAVE_GETRUSAGE
52 #include <sys/time.h>
53 #include <sys/resource.h>
54 #endif
55 #ifdef HAVE_SYS_STAT_H
56 #include <sys/stat.h>
57 #endif
58 #ifdef HAVE_PROCESS_H
59 #include <process.h>
60 #endif
62 #ifdef vfork /* Autoconf may define this to fork for us. */
63 # define VFORK_STRING "fork"
64 #else
65 # define VFORK_STRING "vfork"
66 #endif
67 #ifdef HAVE_VFORK_H
68 #include <vfork.h>
69 #endif
70 #if defined(VMS) && defined (__LONG_POINTERS)
71 #ifndef __CHAR_PTR32
72 typedef char * __char_ptr32
73 __attribute__ ((mode (SI)));
74 #endif
76 typedef __char_ptr32 *__char_ptr_char_ptr32
77 __attribute__ ((mode (SI)));
79 /* Return a 32 bit pointer to an array of 32 bit pointers
80 given a 64 bit pointer to an array of 64 bit pointers. */
82 static __char_ptr_char_ptr32
83 to_ptr32 (char **ptr64)
85 int argc;
86 __char_ptr_char_ptr32 short_argv;
88 /* Count number of arguments. */
89 for (argc = 0; ptr64[argc] != NULL; argc++)
92 /* Reallocate argv with 32 bit pointers. */
93 short_argv = (__char_ptr_char_ptr32) decc$malloc
94 (sizeof (__char_ptr32) * (argc + 1));
96 for (argc = 0; ptr64[argc] != NULL; argc++)
97 short_argv[argc] = (__char_ptr32) decc$strdup (ptr64[argc]);
99 short_argv[argc] = (__char_ptr32) 0;
100 return short_argv;
103 #else
104 #define to_ptr32(argv) argv
105 #endif
107 /* File mode to use for private and world-readable files. */
109 #if defined (S_IRUSR) && defined (S_IWUSR) && defined (S_IRGRP) && defined (S_IWGRP) && defined (S_IROTH) && defined (S_IWOTH)
110 #define PUBLIC_MODE \
111 (S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH)
112 #else
113 #define PUBLIC_MODE 0666
114 #endif
116 /* Get the exit status of a particular process, and optionally get the
117 time that it took. This is simple if we have wait4, slightly
118 harder if we have waitpid, and is a pain if we only have wait. */
120 static pid_t pex_wait (struct pex_obj *, pid_t, int *, struct pex_time *);
122 #ifdef HAVE_WAIT4
124 static pid_t
125 pex_wait (struct pex_obj *obj ATTRIBUTE_UNUSED, pid_t pid, int *status,
126 struct pex_time *time)
128 pid_t ret;
129 struct rusage r;
131 #ifdef HAVE_WAITPID
132 if (time == NULL)
133 return waitpid (pid, status, 0);
134 #endif
136 ret = wait4 (pid, status, 0, &r);
138 if (time != NULL)
140 time->user_seconds = r.ru_utime.tv_sec;
141 time->user_microseconds= r.ru_utime.tv_usec;
142 time->system_seconds = r.ru_stime.tv_sec;
143 time->system_microseconds= r.ru_stime.tv_usec;
146 return ret;
149 #else /* ! defined (HAVE_WAIT4) */
151 #ifdef HAVE_WAITPID
153 #ifndef HAVE_GETRUSAGE
155 static pid_t
156 pex_wait (struct pex_obj *obj ATTRIBUTE_UNUSED, pid_t pid, int *status,
157 struct pex_time *time)
159 if (time != NULL)
160 memset (time, 0, sizeof (struct pex_time));
161 return waitpid (pid, status, 0);
164 #else /* defined (HAVE_GETRUSAGE) */
166 static pid_t
167 pex_wait (struct pex_obj *obj ATTRIBUTE_UNUSED, pid_t pid, int *status,
168 struct pex_time *time)
170 struct rusage r1, r2;
171 pid_t ret;
173 if (time == NULL)
174 return waitpid (pid, status, 0);
176 getrusage (RUSAGE_CHILDREN, &r1);
178 ret = waitpid (pid, status, 0);
179 if (ret < 0)
180 return ret;
182 getrusage (RUSAGE_CHILDREN, &r2);
184 time->user_seconds = r2.ru_utime.tv_sec - r1.ru_utime.tv_sec;
185 time->user_microseconds = r2.ru_utime.tv_usec - r1.ru_utime.tv_usec;
186 if (r2.ru_utime.tv_usec < r1.ru_utime.tv_usec)
188 --time->user_seconds;
189 time->user_microseconds += 1000000;
192 time->system_seconds = r2.ru_stime.tv_sec - r1.ru_stime.tv_sec;
193 time->system_microseconds = r2.ru_stime.tv_usec - r1.ru_stime.tv_usec;
194 if (r2.ru_stime.tv_usec < r1.ru_stime.tv_usec)
196 --time->system_seconds;
197 time->system_microseconds += 1000000;
200 return ret;
203 #endif /* defined (HAVE_GETRUSAGE) */
205 #else /* ! defined (HAVE_WAITPID) */
207 struct status_list
209 struct status_list *next;
210 pid_t pid;
211 int status;
212 struct pex_time time;
215 static pid_t
216 pex_wait (struct pex_obj *obj, pid_t pid, int *status, struct pex_time *time)
218 struct status_list **pp;
220 for (pp = (struct status_list **) &obj->sysdep;
221 *pp != NULL;
222 pp = &(*pp)->next)
224 if ((*pp)->pid == pid)
226 struct status_list *p;
228 p = *pp;
229 *status = p->status;
230 if (time != NULL)
231 *time = p->time;
232 *pp = p->next;
233 free (p);
234 return pid;
238 while (1)
240 pid_t cpid;
241 struct status_list *psl;
242 struct pex_time pt;
243 #ifdef HAVE_GETRUSAGE
244 struct rusage r1, r2;
245 #endif
247 if (time != NULL)
249 #ifdef HAVE_GETRUSAGE
250 getrusage (RUSAGE_CHILDREN, &r1);
251 #else
252 memset (&pt, 0, sizeof (struct pex_time));
253 #endif
256 cpid = wait (status);
258 #ifdef HAVE_GETRUSAGE
259 if (time != NULL && cpid >= 0)
261 getrusage (RUSAGE_CHILDREN, &r2);
263 pt.user_seconds = r2.ru_utime.tv_sec - r1.ru_utime.tv_sec;
264 pt.user_microseconds = r2.ru_utime.tv_usec - r1.ru_utime.tv_usec;
265 if (pt.user_microseconds < 0)
267 --pt.user_seconds;
268 pt.user_microseconds += 1000000;
271 pt.system_seconds = r2.ru_stime.tv_sec - r1.ru_stime.tv_sec;
272 pt.system_microseconds = r2.ru_stime.tv_usec - r1.ru_stime.tv_usec;
273 if (pt.system_microseconds < 0)
275 --pt.system_seconds;
276 pt.system_microseconds += 1000000;
279 #endif
281 if (cpid < 0 || cpid == pid)
283 if (time != NULL)
284 *time = pt;
285 return cpid;
288 psl = XNEW (struct status_list);
289 psl->pid = cpid;
290 psl->status = *status;
291 if (time != NULL)
292 psl->time = pt;
293 psl->next = (struct status_list *) obj->sysdep;
294 obj->sysdep = (void *) psl;
298 #endif /* ! defined (HAVE_WAITPID) */
299 #endif /* ! defined (HAVE_WAIT4) */
301 static void pex_child_error (struct pex_obj *, const char *, const char *, int)
302 ATTRIBUTE_NORETURN;
303 static int pex_unix_open_read (struct pex_obj *, const char *, int);
304 static int pex_unix_open_write (struct pex_obj *, const char *, int, int);
305 static pid_t pex_unix_exec_child (struct pex_obj *, int, const char *,
306 char * const *, char * const *,
307 int, int, int, int,
308 const char **, int *);
309 static int pex_unix_close (struct pex_obj *, int);
310 static int pex_unix_wait (struct pex_obj *, pid_t, int *, struct pex_time *,
311 int, const char **, int *);
312 static int pex_unix_pipe (struct pex_obj *, int *, int);
313 static FILE *pex_unix_fdopenr (struct pex_obj *, int, int);
314 static FILE *pex_unix_fdopenw (struct pex_obj *, int, int);
315 static void pex_unix_cleanup (struct pex_obj *);
317 /* The list of functions we pass to the common routines. */
319 const struct pex_funcs funcs =
321 pex_unix_open_read,
322 pex_unix_open_write,
323 pex_unix_exec_child,
324 pex_unix_close,
325 pex_unix_wait,
326 pex_unix_pipe,
327 pex_unix_fdopenr,
328 pex_unix_fdopenw,
329 pex_unix_cleanup
332 /* Return a newly initialized pex_obj structure. */
334 struct pex_obj *
335 pex_init (int flags, const char *pname, const char *tempbase)
337 return pex_init_common (flags, pname, tempbase, &funcs);
340 /* Open a file for reading. */
342 static int
343 pex_unix_open_read (struct pex_obj *obj ATTRIBUTE_UNUSED, const char *name,
344 int binary ATTRIBUTE_UNUSED)
346 return open (name, O_RDONLY);
349 /* Open a file for writing. */
351 static int
352 pex_unix_open_write (struct pex_obj *obj ATTRIBUTE_UNUSED, const char *name,
353 int binary ATTRIBUTE_UNUSED, int append)
355 /* Note that we can't use O_EXCL here because gcc may have already
356 created the temporary file via make_temp_file. */
357 return open (name, O_WRONLY | O_CREAT
358 | (append ? O_APPEND : O_TRUNC), PUBLIC_MODE);
361 /* Close a file. */
363 static int
364 pex_unix_close (struct pex_obj *obj ATTRIBUTE_UNUSED, int fd)
366 return close (fd);
369 /* Report an error from a child process. We don't use stdio routines,
370 because we might be here due to a vfork call. */
372 static void
373 pex_child_error (struct pex_obj *obj, const char *executable,
374 const char *errmsg, int err)
376 int retval = 0;
377 #define writeerr(s) retval |= (write (STDERR_FILE_NO, s, strlen (s)) < 0)
378 writeerr (obj->pname);
379 writeerr (": error trying to exec '");
380 writeerr (executable);
381 writeerr ("': ");
382 writeerr (errmsg);
383 writeerr (": ");
384 writeerr (xstrerror (err));
385 writeerr ("\n");
386 #undef writeerr
387 /* Exit with -2 if the error output failed, too. */
388 _exit (retval == 0 ? -1 : -2);
391 /* Execute a child. */
393 extern char **environ;
395 #if defined(HAVE_SPAWNVE) && defined(HAVE_SPAWNVPE)
396 /* Implementation of pex->exec_child using the Cygwin spawn operation. */
398 /* Subroutine of pex_unix_exec_child. Move OLD_FD to a new file descriptor
399 to be stored in *PNEW_FD, save the flags in *PFLAGS, and arrange for the
400 saved copy to be close-on-exec. Move CHILD_FD into OLD_FD. If CHILD_FD
401 is -1, OLD_FD is to be closed. Return -1 on error. */
403 static int
404 save_and_install_fd(int *pnew_fd, int *pflags, int old_fd, int child_fd)
406 int new_fd, flags;
408 flags = fcntl (old_fd, F_GETFD);
410 /* If we could not retrieve the flags, then OLD_FD was not open. */
411 if (flags < 0)
413 new_fd = -1, flags = 0;
414 if (child_fd >= 0 && dup2 (child_fd, old_fd) < 0)
415 return -1;
417 /* If we wish to close OLD_FD, just mark it CLOEXEC. */
418 else if (child_fd == -1)
420 new_fd = old_fd;
421 if ((flags & FD_CLOEXEC) == 0 && fcntl (old_fd, F_SETFD, FD_CLOEXEC) < 0)
422 return -1;
424 /* Otherwise we need to save a copy of OLD_FD before installing CHILD_FD. */
425 else
427 #ifdef F_DUPFD_CLOEXEC
428 new_fd = fcntl (old_fd, F_DUPFD_CLOEXEC, 3);
429 if (new_fd < 0)
430 return -1;
431 #else
432 /* Prefer F_DUPFD over dup in order to avoid getting a new fd
433 in the range 0-2, right where a new stderr fd might get put. */
434 new_fd = fcntl (old_fd, F_DUPFD, 3);
435 if (new_fd < 0)
436 return -1;
437 if (fcntl (new_fd, F_SETFD, FD_CLOEXEC) < 0)
438 return -1;
439 #endif
440 if (dup2 (child_fd, old_fd) < 0)
441 return -1;
444 *pflags = flags;
445 if (pnew_fd)
446 *pnew_fd = new_fd;
447 else if (new_fd != old_fd)
448 abort ();
450 return 0;
453 /* Subroutine of pex_unix_exec_child. Move SAVE_FD back to OLD_FD
454 restoring FLAGS. If SAVE_FD < 0, OLD_FD is to be closed. */
456 static int
457 restore_fd(int old_fd, int save_fd, int flags)
459 /* For SAVE_FD < 0, all we have to do is restore the
460 "closed-ness" of the original. */
461 if (save_fd < 0)
462 return close (old_fd);
464 /* For SAVE_FD == OLD_FD, all we have to do is restore the
465 original setting of the CLOEXEC flag. */
466 if (save_fd == old_fd)
468 if (flags & FD_CLOEXEC)
469 return 0;
470 return fcntl (old_fd, F_SETFD, flags);
473 /* Otherwise we have to move the descriptor back, restore the flags,
474 and close the saved copy. */
475 #ifdef HAVE_DUP3
476 if (flags == FD_CLOEXEC)
478 if (dup3 (save_fd, old_fd, O_CLOEXEC) < 0)
479 return -1;
481 else
482 #endif
484 if (dup2 (save_fd, old_fd) < 0)
485 return -1;
486 if (flags != 0 && fcntl (old_fd, F_SETFD, flags) < 0)
487 return -1;
489 return close (save_fd);
492 static pid_t
493 pex_unix_exec_child (struct pex_obj *obj ATTRIBUTE_UNUSED,
494 int flags, const char *executable,
495 char * const * argv, char * const * env,
496 int in, int out, int errdes, int toclose,
497 const char **errmsg, int *err)
499 int fl_in = 0, fl_out = 0, fl_err = 0, fl_tc = 0;
500 int save_in = -1, save_out = -1, save_err = -1;
501 int max, retries;
502 pid_t pid;
504 if (flags & PEX_STDERR_TO_STDOUT)
505 errdes = out;
507 /* We need the three standard file descriptors to be set up as for
508 the child before we perform the spawn. The file descriptors for
509 the parent need to be moved and marked for close-on-exec. */
510 if (in != STDIN_FILE_NO
511 && save_and_install_fd (&save_in, &fl_in, STDIN_FILE_NO, in) < 0)
512 goto error_dup2;
513 if (out != STDOUT_FILE_NO
514 && save_and_install_fd (&save_out, &fl_out, STDOUT_FILE_NO, out) < 0)
515 goto error_dup2;
516 if (errdes != STDERR_FILE_NO
517 && save_and_install_fd (&save_err, &fl_err, STDERR_FILE_NO, errdes) < 0)
518 goto error_dup2;
519 if (toclose >= 0
520 && save_and_install_fd (NULL, &fl_tc, toclose, -1) < 0)
521 goto error_dup2;
523 /* Now that we've moved the file descriptors for the child into place,
524 close the originals. Be careful not to close any of the standard
525 file descriptors that we just set up. */
526 max = -1;
527 if (errdes >= 0)
528 max = STDERR_FILE_NO;
529 else if (out >= 0)
530 max = STDOUT_FILE_NO;
531 else if (in >= 0)
532 max = STDIN_FILE_NO;
533 if (in > max)
534 close (in);
535 if (out > max)
536 close (out);
537 if (errdes > max && errdes != out)
538 close (errdes);
540 /* If we were not given an environment, use the global environment. */
541 if (env == NULL)
542 env = environ;
544 /* Launch the program. If we get EAGAIN (normally out of pid's), try
545 again a few times with increasing backoff times. */
546 retries = 0;
547 while (1)
549 typedef const char * const *cc_cp;
551 if (flags & PEX_SEARCH)
552 pid = spawnvpe (_P_NOWAITO, executable, (cc_cp)argv, (cc_cp)env);
553 else
554 pid = spawnve (_P_NOWAITO, executable, (cc_cp)argv, (cc_cp)env);
556 if (pid > 0)
557 break;
559 *err = errno;
560 *errmsg = "spawn";
561 if (errno != EAGAIN || ++retries == 4)
562 return (pid_t) -1;
563 sleep (1 << retries);
566 /* Success. Restore the parent's file descriptors that we saved above. */
567 if (toclose >= 0
568 && restore_fd (toclose, toclose, fl_tc) < 0)
569 goto error_dup2;
570 if (in != STDIN_FILE_NO
571 && restore_fd (STDIN_FILE_NO, save_in, fl_in) < 0)
572 goto error_dup2;
573 if (out != STDOUT_FILE_NO
574 && restore_fd (STDOUT_FILE_NO, save_out, fl_out) < 0)
575 goto error_dup2;
576 if (errdes != STDERR_FILE_NO
577 && restore_fd (STDERR_FILE_NO, save_err, fl_err) < 0)
578 goto error_dup2;
580 return pid;
582 error_dup2:
583 *err = errno;
584 *errmsg = "dup2";
585 return (pid_t) -1;
588 #else
589 /* Implementation of pex->exec_child using standard vfork + exec. */
591 static pid_t
592 pex_unix_exec_child (struct pex_obj *obj, int flags, const char *executable,
593 char * const * argv, char * const * env,
594 int in, int out, int errdes,
595 int toclose, const char **errmsg, int *err)
597 pid_t pid;
599 /* We declare these to be volatile to avoid warnings from gcc about
600 them being clobbered by vfork. */
601 volatile int sleep_interval;
602 volatile int retries;
604 /* We vfork and then set environ in the child before calling execvp.
605 This clobbers the parent's environ so we need to restore it.
606 It would be nice to use one of the exec* functions that takes an
607 environment as a parameter, but that may have portability issues. */
608 char **save_environ = environ;
610 sleep_interval = 1;
611 pid = -1;
612 for (retries = 0; retries < 4; ++retries)
614 pid = vfork ();
615 if (pid >= 0)
616 break;
617 sleep (sleep_interval);
618 sleep_interval *= 2;
621 switch (pid)
623 case -1:
624 *err = errno;
625 *errmsg = VFORK_STRING;
626 return (pid_t) -1;
628 case 0:
629 /* Child process. */
630 if (in != STDIN_FILE_NO)
632 if (dup2 (in, STDIN_FILE_NO) < 0)
633 pex_child_error (obj, executable, "dup2", errno);
634 if (close (in) < 0)
635 pex_child_error (obj, executable, "close", errno);
637 if (out != STDOUT_FILE_NO)
639 if (dup2 (out, STDOUT_FILE_NO) < 0)
640 pex_child_error (obj, executable, "dup2", errno);
641 if (close (out) < 0)
642 pex_child_error (obj, executable, "close", errno);
644 if (errdes != STDERR_FILE_NO)
646 if (dup2 (errdes, STDERR_FILE_NO) < 0)
647 pex_child_error (obj, executable, "dup2", errno);
648 if (close (errdes) < 0)
649 pex_child_error (obj, executable, "close", errno);
651 if (toclose >= 0)
653 if (close (toclose) < 0)
654 pex_child_error (obj, executable, "close", errno);
656 if ((flags & PEX_STDERR_TO_STDOUT) != 0)
658 if (dup2 (STDOUT_FILE_NO, STDERR_FILE_NO) < 0)
659 pex_child_error (obj, executable, "dup2", errno);
662 if (env)
664 /* NOTE: In a standard vfork implementation this clobbers the
665 parent's copy of environ "too" (in reality there's only one copy).
666 This is ok as we restore it below. */
667 environ = (char**) env;
670 if ((flags & PEX_SEARCH) != 0)
672 execvp (executable, to_ptr32 (argv));
673 pex_child_error (obj, executable, "execvp", errno);
675 else
677 execv (executable, to_ptr32 (argv));
678 pex_child_error (obj, executable, "execv", errno);
681 /* NOTREACHED */
682 return (pid_t) -1;
684 default:
685 /* Parent process. */
687 /* Restore environ.
688 Note that the parent either doesn't run until the child execs/exits
689 (standard vfork behaviour), or if it does run then vfork is behaving
690 more like fork. In either case we needn't worry about clobbering
691 the child's copy of environ. */
692 environ = save_environ;
694 if (in != STDIN_FILE_NO)
696 if (close (in) < 0)
698 *err = errno;
699 *errmsg = "close";
700 return (pid_t) -1;
703 if (out != STDOUT_FILE_NO)
705 if (close (out) < 0)
707 *err = errno;
708 *errmsg = "close";
709 return (pid_t) -1;
712 if (errdes != STDERR_FILE_NO)
714 if (close (errdes) < 0)
716 *err = errno;
717 *errmsg = "close";
718 return (pid_t) -1;
722 return pid;
725 #endif /* SPAWN */
727 /* Wait for a child process to complete. */
729 static int
730 pex_unix_wait (struct pex_obj *obj, pid_t pid, int *status,
731 struct pex_time *time, int done, const char **errmsg,
732 int *err)
734 /* If we are cleaning up when the caller didn't retrieve process
735 status for some reason, encourage the process to go away. */
736 if (done)
737 kill (pid, SIGTERM);
739 if (pex_wait (obj, pid, status, time) < 0)
741 *err = errno;
742 *errmsg = "wait";
743 return -1;
746 return 0;
749 /* Create a pipe. */
751 static int
752 pex_unix_pipe (struct pex_obj *obj ATTRIBUTE_UNUSED, int *p,
753 int binary ATTRIBUTE_UNUSED)
755 return pipe (p);
758 /* Get a FILE pointer to read from a file descriptor. */
760 static FILE *
761 pex_unix_fdopenr (struct pex_obj *obj ATTRIBUTE_UNUSED, int fd,
762 int binary ATTRIBUTE_UNUSED)
764 return fdopen (fd, "r");
767 static FILE *
768 pex_unix_fdopenw (struct pex_obj *obj ATTRIBUTE_UNUSED, int fd,
769 int binary ATTRIBUTE_UNUSED)
771 if (fcntl (fd, F_SETFD, FD_CLOEXEC) < 0)
772 return NULL;
773 return fdopen (fd, "w");
776 static void
777 pex_unix_cleanup (struct pex_obj *obj ATTRIBUTE_UNUSED)
779 #if !defined (HAVE_WAIT4) && !defined (HAVE_WAITPID)
780 while (obj->sysdep != NULL)
782 struct status_list *this;
783 struct status_list *next;
785 this = (struct status_list *) obj->sysdep;
786 next = this->next;
787 free (this);
788 obj->sysdep = (void *) next;
790 #endif