home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / mitsch75.zip / scheme-7_5_17-src.zip / scheme-7.5.17 / src / microcode / uxtop.c < prev    next >
C/C++ Source or Header  |  2000-12-05  |  12KB  |  424 lines
  1. /* -*-C-*-
  2.  
  3. $Id: uxtop.c,v 1.25 2000/12/05 21:23:49 cph Exp $
  4.  
  5. Copyright (c) 1990-2000 Massachusetts Institute of Technology
  6.  
  7. This program is free software; you can redistribute it and/or modify
  8. it under the terms of the GNU General Public License as published by
  9. the Free Software Foundation; either version 2 of the License, or (at
  10. your option) any later version.
  11.  
  12. This program is distributed in the hope that it will be useful, but
  13. WITHOUT ANY WARRANTY; without even the implied warranty of
  14. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15. General Public License for more details.
  16.  
  17. You should have received a copy of the GNU General Public License
  18. along with this program; if not, write to the Free Software
  19. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20. */
  21.  
  22. #include "ux.h"
  23. #include "uxtop.h"
  24. #include "osctty.h"
  25. #include "uxutil.h"
  26. #include "errors.h"
  27. #include "option.h"
  28. #include "config.h"
  29. #include "default.h"
  30. #include "extern.h"
  31.  
  32. extern void EXFUN (UX_initialize_channels, (void));
  33. extern void EXFUN (UX_initialize_ctty, (int interactive));
  34. extern void EXFUN (UX_initialize_directory_reader, (void));
  35. extern void EXFUN (UX_initialize_environment, (void));
  36. extern void EXFUN (UX_initialize_processes, (void));
  37. extern void EXFUN (UX_initialize_signals, (void));
  38. extern void EXFUN (UX_initialize_terminals, (void));
  39. extern void EXFUN (UX_initialize_trap_recovery, (void));
  40. extern void EXFUN (UX_initialize_tty, (void));
  41. extern void EXFUN (UX_initialize_userio, (void));
  42.  
  43. extern void EXFUN (UX_reset_channels, (void));
  44. extern void EXFUN (UX_reset_processes, (void));
  45. extern void EXFUN (UX_reset_terminals, (void));
  46. extern void EXFUN (execute_reload_cleanups, (void));
  47.  
  48. extern cc_t EXFUN (OS_ctty_quit_char, (void));
  49. extern void EXFUN (UX_ctty_save_external_state, (void));
  50. extern void EXFUN (UX_ctty_save_internal_state, (void));
  51. extern void EXFUN (UX_ctty_restore_internal_state, (void));
  52. extern void EXFUN (UX_ctty_restore_external_state, (void));
  53.  
  54. /* reset_interruptable_extent */
  55.  
  56. extern CONST char * OS_Name;
  57. extern CONST char * OS_Variant;
  58.  
  59. static int interactive;
  60.  
  61. int
  62. DEFUN_VOID (OS_under_emacs_p)
  63. {
  64.   return (option_emacs_subprocess);
  65. }
  66.  
  67. void
  68. DEFUN_VOID (OS_initialize)
  69. {
  70.   initialize_interruptable_extent ();
  71.   {
  72.     interactive =
  73.       (option_force_interactive
  74.        || (isatty (STDIN_FILENO))
  75.        || (isatty (STDOUT_FILENO))
  76.        || (isatty (STDERR_FILENO)));
  77.     /* If none of the stdio streams is a terminal, disassociate us
  78.        from the controlling terminal so that we're not affected by
  79.        keyboard interrupts or hangup signals.  However, if we're
  80.        running under Emacs we don't want to do this, because we want
  81.        to receive a hangup signal if Emacs dies. */
  82.     if ((!interactive) && (!option_emacs_subprocess))
  83.       UX_setsid ();
  84.     /* The argument passed to `UX_ctty_initialize' says whether to
  85.        permit interrupt control, i.e. whether to attempt to setup the
  86.        keyboard interrupt characters. */
  87.     UX_initialize_ctty (interactive);
  88.   }
  89.   UX_initialize_channels ();
  90.   UX_initialize_terminals ();
  91.   UX_initialize_environment ();
  92.   UX_initialize_tty ();
  93.   UX_initialize_userio ();
  94.   UX_initialize_signals ();
  95.   UX_initialize_processes ();
  96.   UX_initialize_trap_recovery ();
  97.   UX_initialize_directory_reader ();
  98.   OS_Name = SYSTEM_NAME;
  99.   OS_Variant = SYSTEM_VARIANT;
  100. #if defined(_SUNOS) || defined(_SUNOS3) || defined(_SUNOS4)
  101.   vadvise (VA_ANOM);        /* Anomolous paging, don't try to guess. */
  102. #endif
  103. }
  104.  
  105. void
  106. DEFUN_VOID (OS_announcement)
  107. {
  108.   if ((!option_emacs_subprocess) && (OS_ctty_interrupt_control ()))
  109.     fprintf
  110.       (stdout,
  111.        "Type %s followed by `H' to obtain information about interrupts.\n",
  112.        (char_description ((OS_ctty_quit_char ()), 1)));
  113. }
  114.  
  115. void
  116. DEFUN_VOID (OS_reset)
  117. {
  118.   /*
  119.     There should really be a reset for each initialize above,
  120.     but the rest seem innocuous.
  121.    */
  122.  
  123.   UX_reset_channels ();
  124.   UX_reset_terminals ();
  125.   UX_reset_processes ();
  126.   execute_reload_cleanups ();
  127. }
  128.  
  129. void
  130. DEFUN (OS_quit, (code, abnormal_p), int code AND int abnormal_p)
  131. {
  132.   fflush (stdout);
  133.   if (abnormal_p
  134.       && interactive
  135.       && (! ((code == TERM_SIGNAL) || (code == TERM_EOF))))
  136.     {
  137.       fputs ("\nScheme has terminated abnormally!\n", stdout);
  138.       {
  139.     int dump_core =
  140.       ((!option_disable_core_dump)
  141.        && (userio_confirm ("Would you like a core dump? [Y or N] "))
  142.        && (userio_confirm ("Do you really want a core dump? [Y or N] ")));
  143.     putc ('\n', stdout);
  144.     fflush (stdout);
  145.     if (dump_core)
  146.       UX_dump_core ();
  147.       }
  148.     }
  149.   OS_restore_external_state ();
  150. }
  151.  
  152. void
  153. DEFUN_VOID (UX_dump_core)
  154. {
  155.   OS_restore_external_state ();
  156.   /* Unmask this too? */
  157.   UX_signal (SIGABRT, SIG_DFL);
  158.   UX_abort ();
  159. }
  160.  
  161. void
  162. DEFUN_VOID (OS_save_external_state)
  163. {
  164.   UX_ctty_save_external_state ();
  165. }
  166.  
  167. void
  168. DEFUN_VOID (OS_save_internal_state)
  169. {
  170.   UX_ctty_save_internal_state ();
  171. }
  172.  
  173. void
  174. DEFUN_VOID (OS_restore_internal_state)
  175. {
  176.   UX_ctty_restore_internal_state ();
  177. }
  178.  
  179. void
  180. DEFUN_VOID (OS_restore_external_state)
  181. {
  182.   UX_ctty_restore_external_state ();
  183. }
  184.  
  185. enum syserr_names
  186. DEFUN (OS_error_code_to_syserr, (code), int code)
  187. {
  188.   switch (code)
  189.     {
  190.     case E2BIG:        return (syserr_arg_list_too_long);
  191.     case EACCES:    return (syserr_permission_denied);
  192.     case EAGAIN:    return (syserr_resource_temporarily_unavailable);
  193.     case EBADF:        return (syserr_bad_file_descriptor);
  194.     case EBUSY:        return (syserr_resource_busy);
  195.     case ECHILD:    return (syserr_no_child_processes);
  196.     case EDEADLK:    return (syserr_resource_deadlock_avoided);
  197.     case EDOM:        return (syserr_domain_error);
  198.     case EEXIST:    return (syserr_file_exists);
  199.     case EFAULT:    return (syserr_bad_address);
  200.     case EFBIG:        return (syserr_file_too_large);
  201.     case EINTR:        return (syserr_interrupted_function_call);
  202.     case EINVAL:    return (syserr_invalid_argument);
  203.     case EIO:        return (syserr_io_error);
  204.     case EISDIR:    return (syserr_is_a_directory);
  205.     case EMFILE:    return (syserr_too_many_open_files);
  206.     case EMLINK:    return (syserr_too_many_links);
  207. #ifdef ENAMETOOLONG
  208.     case ENAMETOOLONG:    return (syserr_filename_too_long);
  209. #endif
  210.     case ENFILE:    return (syserr_too_many_open_files_in_system);
  211.     case ENODEV:    return (syserr_no_such_device);
  212.     case ENOENT:    return (syserr_no_such_file_or_directory);
  213.     case ENOEXEC:    return (syserr_exec_format_error);
  214. #ifdef ENOLCK
  215.     case ENOLCK:    return (syserr_no_locks_available);
  216. #endif
  217.     case ENOMEM:    return (syserr_not_enough_space);
  218.     case ENOSPC:    return (syserr_no_space_left_on_device);
  219.     case ENOSYS:    return (syserr_function_not_implemented);
  220.     case ENOTDIR:    return (syserr_not_a_directory);
  221. #if defined(ENOTEMPTY) && (ENOTEMPTY != EEXIST)
  222.     case ENOTEMPTY:    return (syserr_directory_not_empty);
  223. #endif
  224.     case ENOTTY:    return (syserr_inappropriate_io_control_operation);
  225.     case ENXIO:        return (syserr_no_such_device_or_address);
  226.     case EPERM:        return (syserr_operation_not_permitted);
  227.     case EPIPE:        return (syserr_broken_pipe);
  228.     case ERANGE:    return (syserr_result_too_large);
  229.     case EROFS:        return (syserr_read_only_file_system);
  230.     case ESPIPE:    return (syserr_invalid_seek);
  231.     case ESRCH:        return (syserr_no_such_process);
  232.     case EXDEV:        return (syserr_improper_link);
  233.     default:        return (syserr_unknown);
  234.     }
  235. }
  236.  
  237. static int
  238. DEFUN (syserr_to_error_code, (syserr), enum syserr_names syserr)
  239. {
  240.   switch (syserr)
  241.     {
  242.     case syserr_arg_list_too_long:            return (E2BIG);
  243.     case syserr_bad_address:                return (EFAULT);
  244.     case syserr_bad_file_descriptor:            return (EBADF);
  245.     case syserr_broken_pipe:                return (EPIPE);
  246. #ifdef ENOTEMPTY
  247.     case syserr_directory_not_empty:            return (ENOTEMPTY);
  248. #endif
  249.     case syserr_domain_error:                return (EDOM);
  250.     case syserr_exec_format_error:            return (ENOEXEC);
  251.     case syserr_file_exists:                return (EEXIST);
  252.     case syserr_file_too_large:                return (EFBIG);
  253. #ifdef ENAMETOOLONG
  254.     case syserr_filename_too_long:            return (ENAMETOOLONG);
  255. #endif
  256.     case syserr_function_not_implemented:        return (ENOSYS);
  257.     case syserr_improper_link:                return (EXDEV);
  258.     case syserr_inappropriate_io_control_operation:    return (ENOTTY);
  259.     case syserr_interrupted_function_call:        return (EINTR);
  260.     case syserr_invalid_argument:            return (EINVAL);
  261.     case syserr_invalid_seek:                return (ESPIPE);
  262.     case syserr_io_error:                return (EIO);
  263.     case syserr_is_a_directory:                return (EISDIR);
  264.     case syserr_no_child_processes:            return (ECHILD);
  265. #ifdef ENOLCK
  266.     case syserr_no_locks_available:            return (ENOLCK);
  267. #endif
  268.     case syserr_no_space_left_on_device:        return (ENOSPC);
  269.     case syserr_no_such_device:                return (ENODEV);
  270.     case syserr_no_such_device_or_address:        return (ENXIO);
  271.     case syserr_no_such_file_or_directory:        return (ENOENT);
  272.     case syserr_no_such_process:            return (ESRCH);
  273.     case syserr_not_a_directory:            return (ENOTDIR);
  274.     case syserr_not_enough_space:            return (ENOMEM);
  275.     case syserr_operation_not_permitted:        return (EPERM);
  276.     case syserr_permission_denied:            return (EACCES);
  277.     case syserr_read_only_file_system:            return (EROFS);
  278.     case syserr_resource_busy:                return (EBUSY);
  279.     case syserr_resource_deadlock_avoided:        return (EDEADLK);
  280.     case syserr_resource_temporarily_unavailable:    return (EAGAIN);
  281.     case syserr_result_too_large:            return (ERANGE);
  282.     case syserr_too_many_links:                return (EMLINK);
  283.     case syserr_too_many_open_files:            return (EMFILE);
  284.     case syserr_too_many_open_files_in_system:        return (ENFILE);
  285.     default: return (0);
  286.     }
  287. }
  288.  
  289. #ifdef __HPUX__
  290. #define NEED_ERRLIST_DEFINITIONS
  291. #endif
  292.  
  293. #ifdef NEED_ERRLIST_DEFINITIONS
  294. extern char * sys_errlist [];
  295. extern int sys_nerr;
  296. #endif
  297.  
  298. CONST char *
  299. DEFUN (OS_error_code_to_message, (syserr), unsigned int syserr)
  300. {
  301.   int code = (syserr_to_error_code ((enum syserr_names) syserr));
  302.   return (((code > 0) && (code <= sys_nerr)) ? (sys_errlist [code]) : 0);
  303. }
  304.  
  305. static char * syscall_names_table [] =
  306. {
  307.   "accept",
  308.   "bind",
  309.   "chdir",
  310.   "chmod",
  311.   "close",
  312.   "connect",
  313.   "fcntl-getfl",
  314.   "fcntl-setfl",
  315.   "fork",
  316.   "fstat",
  317.   "ftruncate",
  318.   "getcwd",
  319.   "gethostname",
  320.   "gettimeofday",
  321.   "gmtime",
  322.   "ioctl-tiocgpgrp",
  323.   "ioctl-tiocsigsend",
  324.   "kill",
  325.   "link",
  326.   "listen",
  327.   "localtime",
  328.   "lseek",
  329.   "malloc",
  330.   "mkdir",
  331.   "open",
  332.   "opendir",
  333.   "pause",
  334.   "pipe",
  335.   "read",
  336.   "readlink",
  337.   "realloc",
  338.   "rename",
  339.   "rmdir",
  340.   "select",
  341.   "setitimer",
  342.   "setpgid",
  343.   "sighold",
  344.   "sigprocmask",
  345.   "sigsuspend",
  346.   "sleep",
  347.   "socket",
  348.   "symlink",
  349.   "tcdrain",
  350.   "tcflush",
  351.   "tcgetpgrp",
  352.   "tcsetpgrp",
  353.   "terminal-get-state",
  354.   "terminal-set-state",
  355.   "time",
  356.   "times",
  357.   "unlink",
  358.   "utime",
  359.   "vfork",
  360.   "write",
  361.   "stat",
  362.   "lstat",
  363.   "mktime",
  364.   "dynamic-load",
  365.   "statfs",
  366.   "fstatfs"
  367. };
  368.  
  369. void
  370. OS_syscall_names (unsigned int * length, unsigned char *** names)
  371. {
  372.   (*length) = ((sizeof (syscall_names_table)) / (sizeof (char *)));
  373.   (*names) = ((unsigned char **) syscall_names_table);
  374. }
  375.  
  376. static char * syserr_names_table [] =
  377. {
  378.   "unknown",
  379.   "arg-list-too-long",
  380.   "bad-address",
  381.   "bad-file-descriptor",
  382.   "broken-pipe",
  383.   "directory-not-empty",
  384.   "domain-error",
  385.   "exec-format-error",
  386.   "file-exists",
  387.   "file-too-large",
  388.   "filename-too-long",
  389.   "function-not-implemented",
  390.   "improper-link",
  391.   "inappropriate-io-control-operation",
  392.   "interrupted-function-call",
  393.   "invalid-argument",
  394.   "invalid-seek",
  395.   "io-error",
  396.   "is-a-directory",
  397.   "no-child-processes",
  398.   "no-locks-available",
  399.   "no-space-left-on-device",
  400.   "no-such-device",
  401.   "no-such-device-or-address",
  402.   "no-such-file-or-directory",
  403.   "no-such-process",
  404.   "not-a-directory",
  405.   "not-enough-space",
  406.   "operation-not-permitted",
  407.   "permission-denied",
  408.   "read-only-file-system",
  409.   "resource-busy",
  410.   "resource-deadlock-avoided",
  411.   "resource-temporarily-unavailable",
  412.   "result-too-large",
  413.   "too-many-links",
  414.   "too-many-open-files",
  415.   "too-many-open-files"
  416. };
  417.  
  418. void
  419. OS_syserr_names (unsigned int * length, unsigned char *** names)
  420. {
  421.   (*length) = ((sizeof (syserr_names_table)) / (sizeof (char *)));
  422.   (*names) = ((unsigned char **) syserr_names_table);
  423. }
  424.