Mercurial > hg > xemacs-beta
annotate src/syssignal.h @ 5127:a9c41067dd88 ben-lisp-object
more cleanups, terminology clarification, lots of doc work
-------------------- ChangeLog entries follow: --------------------
man/ChangeLog addition:
2010-03-05 Ben Wing <ben@xemacs.org>
* internals/internals.texi (Introduction to Allocation):
* internals/internals.texi (Integers and Characters):
* internals/internals.texi (Allocation from Frob Blocks):
* internals/internals.texi (lrecords):
* internals/internals.texi (Low-level allocation):
Rewrite section on allocation of Lisp objects to reflect the new
reality. Remove references to nonexistent XSETINT and XSETCHAR.
modules/ChangeLog addition:
2010-03-05 Ben Wing <ben@xemacs.org>
* postgresql/postgresql.c (allocate_pgconn):
* postgresql/postgresql.c (allocate_pgresult):
* postgresql/postgresql.h (struct Lisp_PGconn):
* postgresql/postgresql.h (struct Lisp_PGresult):
* ldap/eldap.c (allocate_ldap):
* ldap/eldap.h (struct Lisp_LDAP):
Same changes as in src/ dir. See large log there in ChangeLog,
but basically:
ALLOC_LISP_OBJECT -> ALLOC_NORMAL_LISP_OBJECT
LISP_OBJECT_HEADER -> NORMAL_LISP_OBJECT_HEADER
../hlo/src/ChangeLog addition:
2010-03-05 Ben Wing <ben@xemacs.org>
* alloc.c:
* alloc.c (old_alloc_sized_lcrecord):
* alloc.c (very_old_free_lcrecord):
* alloc.c (copy_lisp_object):
* alloc.c (zero_sized_lisp_object):
* alloc.c (zero_nonsized_lisp_object):
* alloc.c (lisp_object_storage_size):
* alloc.c (free_normal_lisp_object):
* alloc.c (FREE_FIXED_TYPE_WHEN_NOT_IN_GC):
* alloc.c (ALLOC_FROB_BLOCK_LISP_OBJECT):
* alloc.c (Fcons):
* alloc.c (noseeum_cons):
* alloc.c (make_float):
* alloc.c (make_bignum):
* alloc.c (make_bignum_bg):
* alloc.c (make_ratio):
* alloc.c (make_ratio_bg):
* alloc.c (make_ratio_rt):
* alloc.c (make_bigfloat):
* alloc.c (make_bigfloat_bf):
* alloc.c (size_vector):
* alloc.c (make_compiled_function):
* alloc.c (Fmake_symbol):
* alloc.c (allocate_extent):
* alloc.c (allocate_event):
* alloc.c (make_key_data):
* alloc.c (make_button_data):
* alloc.c (make_motion_data):
* alloc.c (make_process_data):
* alloc.c (make_timeout_data):
* alloc.c (make_magic_data):
* alloc.c (make_magic_eval_data):
* alloc.c (make_eval_data):
* alloc.c (make_misc_user_data):
* alloc.c (Fmake_marker):
* alloc.c (noseeum_make_marker):
* alloc.c (size_string_direct_data):
* alloc.c (make_uninit_string):
* alloc.c (make_string_nocopy):
* alloc.c (mark_lcrecord_list):
* alloc.c (alloc_managed_lcrecord):
* alloc.c (free_managed_lcrecord):
* alloc.c (sweep_lcrecords_1):
* alloc.c (malloced_storage_size):
* buffer.c (allocate_buffer):
* buffer.c (compute_buffer_usage):
* buffer.c (DEFVAR_BUFFER_LOCAL_1):
* buffer.c (nuke_all_buffer_slots):
* buffer.c (common_init_complex_vars_of_buffer):
* buffer.h (struct buffer_text):
* buffer.h (struct buffer):
* bytecode.c:
* bytecode.c (make_compiled_function_args):
* bytecode.c (size_compiled_function_args):
* bytecode.h (struct compiled_function_args):
* casetab.c (allocate_case_table):
* casetab.h (struct Lisp_Case_Table):
* charset.h (struct Lisp_Charset):
* chartab.c (fill_char_table):
* chartab.c (Fmake_char_table):
* chartab.c (make_char_table_entry):
* chartab.c (copy_char_table_entry):
* chartab.c (Fcopy_char_table):
* chartab.c (put_char_table):
* chartab.h (struct Lisp_Char_Table_Entry):
* chartab.h (struct Lisp_Char_Table):
* console-gtk-impl.h (struct gtk_device):
* console-gtk-impl.h (struct gtk_frame):
* console-impl.h (struct console):
* console-msw-impl.h (struct Lisp_Devmode):
* console-msw-impl.h (struct mswindows_device):
* console-msw-impl.h (struct msprinter_device):
* console-msw-impl.h (struct mswindows_frame):
* console-msw-impl.h (struct mswindows_dialog_id):
* console-stream-impl.h (struct stream_console):
* console-stream.c (stream_init_console):
* console-tty-impl.h (struct tty_console):
* console-tty-impl.h (struct tty_device):
* console-tty.c (allocate_tty_console_struct):
* console-x-impl.h (struct x_device):
* console-x-impl.h (struct x_frame):
* console.c (allocate_console):
* console.c (nuke_all_console_slots):
* console.c (DEFVAR_CONSOLE_LOCAL_1):
* console.c (common_init_complex_vars_of_console):
* data.c (make_weak_list):
* data.c (make_weak_box):
* data.c (make_ephemeron):
* database.c:
* database.c (struct Lisp_Database):
* database.c (allocate_database):
* database.c (finalize_database):
* device-gtk.c (allocate_gtk_device_struct):
* device-impl.h (struct device):
* device-msw.c:
* device-msw.c (mswindows_init_device):
* device-msw.c (msprinter_init_device):
* device-msw.c (finalize_devmode):
* device-msw.c (allocate_devmode):
* device-tty.c (allocate_tty_device_struct):
* device-x.c (allocate_x_device_struct):
* device.c:
* device.c (nuke_all_device_slots):
* device.c (allocate_device):
* dialog-msw.c (handle_question_dialog_box):
* elhash.c:
* elhash.c (struct Lisp_Hash_Table):
* elhash.c (finalize_hash_table):
* elhash.c (make_general_lisp_hash_table):
* elhash.c (Fcopy_hash_table):
* elhash.h (htentry):
* emacs.c (main_1):
* eval.c:
* eval.c (size_multiple_value):
* event-stream.c (finalize_command_builder):
* event-stream.c (allocate_command_builder):
* event-stream.c (free_command_builder):
* event-stream.c (event_stream_generate_wakeup):
* event-stream.c (event_stream_resignal_wakeup):
* event-stream.c (event_stream_disable_wakeup):
* event-stream.c (event_stream_wakeup_pending_p):
* events.h (struct Lisp_Timeout):
* events.h (struct command_builder):
* extents-impl.h:
* extents-impl.h (struct extent_auxiliary):
* extents-impl.h (struct extent_info):
* extents-impl.h (set_extent_no_chase_aux_field):
* extents-impl.h (set_extent_no_chase_normal_field):
* extents.c:
* extents.c (gap_array_marker):
* extents.c (gap_array):
* extents.c (extent_list_marker):
* extents.c (extent_list):
* extents.c (stack_of_extents):
* extents.c (gap_array_make_marker):
* extents.c (extent_list_make_marker):
* extents.c (allocate_extent_list):
* extents.c (SLOT):
* extents.c (mark_extent_auxiliary):
* extents.c (allocate_extent_auxiliary):
* extents.c (attach_extent_auxiliary):
* extents.c (size_gap_array):
* extents.c (finalize_extent_info):
* extents.c (allocate_extent_info):
* extents.c (uninit_buffer_extents):
* extents.c (allocate_soe):
* extents.c (copy_extent):
* extents.c (vars_of_extents):
* extents.h:
* faces.c (allocate_face):
* faces.h (struct Lisp_Face):
* faces.h (struct face_cachel):
* file-coding.c:
* file-coding.c (finalize_coding_system):
* file-coding.c (sizeof_coding_system):
* file-coding.c (Fcopy_coding_system):
* file-coding.h (struct Lisp_Coding_System):
* file-coding.h (MARKED_SLOT):
* fns.c (size_bit_vector):
* font-mgr.c:
* font-mgr.c (finalize_fc_pattern):
* font-mgr.c (print_fc_pattern):
* font-mgr.c (Ffc_pattern_p):
* font-mgr.c (Ffc_pattern_create):
* font-mgr.c (Ffc_name_parse):
* font-mgr.c (Ffc_name_unparse):
* font-mgr.c (Ffc_pattern_duplicate):
* font-mgr.c (Ffc_pattern_add):
* font-mgr.c (Ffc_pattern_del):
* font-mgr.c (Ffc_pattern_get):
* font-mgr.c (fc_config_create_using):
* font-mgr.c (fc_strlist_to_lisp_using):
* font-mgr.c (fontset_to_list):
* font-mgr.c (Ffc_config_p):
* font-mgr.c (Ffc_config_up_to_date):
* font-mgr.c (Ffc_config_build_fonts):
* font-mgr.c (Ffc_config_get_cache):
* font-mgr.c (Ffc_config_get_fonts):
* font-mgr.c (Ffc_config_set_current):
* font-mgr.c (Ffc_config_get_blanks):
* font-mgr.c (Ffc_config_get_rescan_interval):
* font-mgr.c (Ffc_config_set_rescan_interval):
* font-mgr.c (Ffc_config_app_font_add_file):
* font-mgr.c (Ffc_config_app_font_add_dir):
* font-mgr.c (Ffc_config_app_font_clear):
* font-mgr.c (size):
* font-mgr.c (Ffc_config_substitute):
* font-mgr.c (Ffc_font_render_prepare):
* font-mgr.c (Ffc_font_match):
* font-mgr.c (Ffc_font_sort):
* font-mgr.c (finalize_fc_config):
* font-mgr.c (print_fc_config):
* font-mgr.h:
* font-mgr.h (struct fc_pattern):
* font-mgr.h (XFC_PATTERN):
* font-mgr.h (struct fc_config):
* font-mgr.h (XFC_CONFIG):
* frame-gtk.c (allocate_gtk_frame_struct):
* frame-impl.h (struct frame):
* frame-msw.c (mswindows_init_frame_1):
* frame-x.c (allocate_x_frame_struct):
* frame.c (nuke_all_frame_slots):
* frame.c (allocate_frame_core):
* gc.c:
* gc.c (GC_CHECK_NOT_FREE):
* glyphs.c (finalize_image_instance):
* glyphs.c (allocate_image_instance):
* glyphs.c (Fcolorize_image_instance):
* glyphs.c (allocate_glyph):
* glyphs.c (unmap_subwindow_instance_cache_mapper):
* glyphs.c (register_ignored_expose):
* glyphs.h (struct Lisp_Image_Instance):
* glyphs.h (struct Lisp_Glyph):
* glyphs.h (struct glyph_cachel):
* glyphs.h (struct expose_ignore):
* gui.c (allocate_gui_item):
* gui.h (struct Lisp_Gui_Item):
* keymap.c (struct Lisp_Keymap):
* keymap.c (make_keymap):
* lisp.h:
* lisp.h (struct Lisp_String_Direct_Data):
* lisp.h (struct Lisp_String_Indirect_Data):
* lisp.h (struct Lisp_Vector):
* lisp.h (struct Lisp_Bit_Vector):
* lisp.h (DECLARE_INLINE_LISP_BIT_VECTOR):
* lisp.h (struct weak_box):
* lisp.h (struct ephemeron):
* lisp.h (struct weak_list):
* lrecord.h:
* lrecord.h (struct lrecord_implementation):
* lrecord.h (MC_ALLOC_CALL_FINALIZER):
* lrecord.h (struct lcrecord_list):
* lstream.c (finalize_lstream):
* lstream.c (sizeof_lstream):
* lstream.c (Lstream_new):
* lstream.c (Lstream_delete):
* lstream.h (struct lstream):
* marker.c:
* marker.c (finalize_marker):
* marker.c (compute_buffer_marker_usage):
* mule-charset.c:
* mule-charset.c (make_charset):
* mule-charset.c (compute_charset_usage):
* objects-impl.h (struct Lisp_Color_Instance):
* objects-impl.h (struct Lisp_Font_Instance):
* objects-tty-impl.h (struct tty_color_instance_data):
* objects-tty-impl.h (struct tty_font_instance_data):
* objects-tty.c (tty_initialize_color_instance):
* objects-tty.c (tty_initialize_font_instance):
* objects.c (finalize_color_instance):
* objects.c (Fmake_color_instance):
* objects.c (finalize_font_instance):
* objects.c (Fmake_font_instance):
* objects.c (reinit_vars_of_objects):
* opaque.c:
* opaque.c (sizeof_opaque):
* opaque.c (make_opaque_ptr):
* opaque.c (free_opaque_ptr):
* opaque.h:
* opaque.h (Lisp_Opaque):
* opaque.h (Lisp_Opaque_Ptr):
* print.c (printing_unreadable_lcrecord):
* print.c (external_object_printer):
* print.c (debug_p4):
* process.c (finalize_process):
* process.c (make_process_internal):
* procimpl.h (struct Lisp_Process):
* rangetab.c (Fmake_range_table):
* rangetab.c (Fcopy_range_table):
* rangetab.h (struct Lisp_Range_Table):
* scrollbar.c:
* scrollbar.c (create_scrollbar_instance):
* scrollbar.c (compute_scrollbar_instance_usage):
* scrollbar.h (struct scrollbar_instance):
* specifier.c (finalize_specifier):
* specifier.c (sizeof_specifier):
* specifier.c (set_specifier_caching):
* specifier.h (struct Lisp_Specifier):
* specifier.h (struct specifier_caching):
* symeval.h:
* symeval.h (SYMBOL_VALUE_MAGIC_P):
* symeval.h (DEFVAR_SYMVAL_FWD):
* symsinit.h:
* syntax.c (init_buffer_syntax_cache):
* syntax.h (struct syntax_cache):
* toolbar.c:
* toolbar.c (allocate_toolbar_button):
* toolbar.c (update_toolbar_button):
* toolbar.h (struct toolbar_button):
* tooltalk.c (struct Lisp_Tooltalk_Message):
* tooltalk.c (make_tooltalk_message):
* tooltalk.c (struct Lisp_Tooltalk_Pattern):
* tooltalk.c (make_tooltalk_pattern):
* ui-gtk.c:
* ui-gtk.c (allocate_ffi_data):
* ui-gtk.c (emacs_gtk_object_finalizer):
* ui-gtk.c (allocate_emacs_gtk_object_data):
* ui-gtk.c (allocate_emacs_gtk_boxed_data):
* ui-gtk.h:
* window-impl.h (struct window):
* window-impl.h (struct window_mirror):
* window.c (finalize_window):
* window.c (allocate_window):
* window.c (new_window_mirror):
* window.c (mark_window_as_deleted):
* window.c (make_dummy_parent):
* window.c (compute_window_mirror_usage):
* window.c (compute_window_usage):
Overall point of this change and previous ones in this repository:
(1) Introduce new, clearer terminology: everything other than int
or char is a "record" object, which comes in two types: "normal
objects" and "frob-block objects". Fix up all places that
referred to frob-block objects as "simple", "basic", etc.
(2) Provide an advertised interface for doing operations on Lisp
objects, including creating new types, that is clean and
consistent in its naming, uses the above-referenced terms and
avoids referencing "lrecords", "old lcrecords", etc., which should
hide under the surface.
(3) Make the size_in_bytes and finalizer methods take a
Lisp_Object rather than a void * for consistency with other methods.
(4) Separate finalizer method into finalizer and disksaver, so
that normal finalize methods don't have to worry about disksaving.
Other specifics:
(1) Renaming:
LISP_OBJECT_HEADER -> NORMAL_LISP_OBJECT_HEADER
ALLOC_LISP_OBJECT -> ALLOC_NORMAL_LISP_OBJECT
implementation->basic_p -> implementation->frob_block_p
ALLOCATE_FIXED_TYPE_AND_SET_IMPL -> ALLOC_FROB_BLOCK_LISP_OBJECT
*FCCONFIG*, wrap_fcconfig -> *FC_CONFIG*, wrap_fc_config
*FCPATTERN*, wrap_fcpattern -> *FC_PATTERN*, wrap_fc_pattern
(the last two changes make the naming of these macros consistent
with the naming of all other macros, since the objects are named
fc-config and fc-pattern with a hyphen)
(2) Lots of documentation fixes in lrecord.h.
(3) Eliminate macros for copying, freeing, zeroing objects, getting
their storage size. Instead, new functions:
zero_sized_lisp_object()
zero_nonsized_lisp_object()
lisp_object_storage_size()
free_normal_lisp_object()
(copy_lisp_object() already exists)
LISP_OBJECT_FROB_BLOCK_P() (actually a macro)
Eliminated:
free_lrecord()
zero_lrecord()
copy_lrecord()
copy_sized_lrecord()
old_copy_lcrecord()
old_copy_sized_lcrecord()
old_zero_lcrecord()
old_zero_sized_lcrecord()
LISP_OBJECT_STORAGE_SIZE()
COPY_SIZED_LISP_OBJECT()
COPY_SIZED_LCRECORD()
COPY_LISP_OBJECT()
ZERO_LISP_OBJECT()
FREE_LISP_OBJECT()
(4) Catch the remaining places where lrecord stuff was used directly
and use the advertised interface, e.g. alloc_sized_lrecord() ->
ALLOC_SIZED_LISP_OBJECT().
(5) Make certain statically-declared pseudo-objects
(buffer_local_flags, console_local_flags) have their lheader
initialized correctly, so things like copy_lisp_object() can work
on them. Make extent_auxiliary_defaults a proper heap object
Vextent_auxiliary_defaults, and make extent auxiliaries dumpable
so that this object can be dumped. allocate_extent_auxiliary()
now just creates the object, and attach_extent_auxiliary()
creates an extent auxiliary and attaches to an extent, like the
old allocate_extent_auxiliary().
(6) Create EXTENT_AUXILIARY_SLOTS macro, similar to the foo-slots.h
files but in a macro instead of a file. The purpose is to avoid
duplication when iterating over all the slots in an extent auxiliary.
Use it.
(7) In lstream.c, don't zero out object after allocation because
allocation routines take care of this.
(8) In marker.c, fix a mistake in computing marker overhead.
(9) In print.c, clean up printing_unreadable_lcrecord(),
external_object_printer() to avoid lots of ifdef NEW_GC's.
(10) Separate toolbar-button allocation into a separate
allocate_toolbar_button() function for use in the example code
in lrecord.h.
| author | Ben Wing <ben@xemacs.org> |
|---|---|
| date | Fri, 05 Mar 2010 04:08:17 -0600 |
| parents | aa5ed11f473b |
| children | 308d34e9f07d |
| rev | line source |
|---|---|
| 428 | 1 /* syssignal.h - System-dependent definitions for signals. |
| 2 Copyright (C) 1992, 1993 Free Software Foundation, Inc. | |
| 814 | 3 Copyright (C) 1996 Ben Wing. |
| 4 | |
| 428 | 5 This file is part of XEmacs. |
| 6 | |
| 7 XEmacs is free software; you can redistribute it and/or modify it | |
| 8 under the terms of the GNU General Public License as published by the | |
| 9 Free Software Foundation; either version 2, or (at your option) any | |
| 10 later version. | |
| 11 | |
| 12 XEmacs is distributed in the hope that it will be useful, but WITHOUT | |
| 13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 15 for more details. | |
| 16 | |
| 17 You should have received a copy of the GNU General Public License | |
| 18 along with XEmacs; see the file COPYING. If not, write to | |
| 19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330, | |
| 20 Boston, MA 02111-1307, USA. */ | |
| 21 | |
| 22 /* Synched up with: FSF 19.30. */ | |
| 23 | |
| 440 | 24 #ifndef INCLUDED_syssignal_h_ |
| 25 #define INCLUDED_syssignal_h_ | |
| 428 | 26 |
| 27 /* In the old world, one could not #include <signal.h> here. The party line | |
| 28 was that that header should always be #included before <config.h>, because | |
| 29 some configuration files (like s/hpux.h) indicate that SIGIO doesn't work | |
| 30 by #undef-ing SIGIO, and if this file #includes <signal.h>, then that will | |
| 31 re-#define SIGIO and confuse things. | |
| 32 | |
| 33 This was, however, a completely fucked up state of affairs, because on some | |
| 34 systems it's necessary for the s/m files to #define things in order to get | |
| 35 <signal.h> to provide the right typedefs, etc. And it's generally a broken | |
| 36 concept for <config.h> to not be the very very first file included. | |
| 37 | |
| 38 So instead of #undef'ing SIGIO in the various s/m files, I've changed them | |
| 39 to define BROKEN_SIGIO instead, then we (syssignal.h) do an #undef SIGIO | |
| 40 at the end, after including signal.h. Therefore, it's important that | |
| 41 <signal.h> not be included after "syssignal.h", but that's the normal state: | |
| 42 nothing should be directly including <signal.h> these days. | |
| 43 -- jwz, 29-nov-93 | |
| 44 */ | |
| 45 | |
| 46 #include <signal.h> | |
| 47 #include <errno.h> | |
| 48 | |
| 49 /* SIGPOLL is the SVR4 signal. Those systems generally define | |
| 50 SIGIO as an alias for SIGPOLL, but just in case ... */ | |
| 51 | |
| 52 #if defined (BROKEN_SIGIO) | |
| 53 # if defined (SIGIO) && defined (SIGPOLL) | |
| 54 # if SIGIO == SIGPOLL | |
| 55 # undef SIGIO | |
| 56 # undef SIGPOLL | |
| 57 # else | |
| 58 # undef SIGIO | |
| 59 # endif | |
| 60 # endif | |
| 61 #else /* Not BROKEN_SIGIO */ | |
| 62 # if !defined (SIGIO) && defined (SIGPOLL) | |
| 63 # define SIGIO SIGPOLL | |
| 64 # endif | |
| 65 #endif | |
| 66 | |
| 67 /* Define SIGCHLD as an alias for SIGCLD. There are many conditionals | |
| 68 testing SIGCHLD. */ | |
| 69 #if defined (SIGCLD) && !defined (SIGCHLD) | |
| 70 # define SIGCHLD SIGCLD | |
| 71 #endif /* SIGCHLD */ | |
| 72 | |
| 73 #ifdef BROKEN_SIGCHLD | |
| 74 #undef SIGCHLD | |
| 75 #endif | |
| 76 | |
| 77 #ifdef SIGCHLD | |
| 78 #define EMACS_BLOCK_SIGCHLD EMACS_BLOCK_SIGNAL (SIGCHLD) | |
| 79 #define EMACS_UNBLOCK_SIGCHLD EMACS_UNBLOCK_SIGNAL (SIGCHLD) | |
| 80 #else | |
| 81 #define EMACS_BLOCK_SIGCHLD | |
| 82 #define EMACS_UNBLOCK_SIGCHLD | |
| 83 #endif | |
| 84 | |
| 85 /* According to W.R. Stevens __Advanced Programming in the Unix | |
| 86 Environment__, there are four different paradigms for handling | |
| 87 signals. We use autoconf to tell us which one applies. | |
| 88 | |
| 89 Note that on some systems, more than one paradigm is implemented | |
| 90 (typically, the POSIX sigaction/sigprocmask and either the older | |
| 91 SYSV or BSD way). In such a case, we prefer the POSIX way. | |
| 92 | |
| 613 | 93 We used to say this: |
| 94 | |
| 95 [[ NOTE: We use EMACS_* macros for most signal operations, but | |
| 428 | 96 just signal() for the standard signal-setting operation. |
| 97 Perhaps we should change this to EMACS_SIGNAL(), but that runs | |
| 98 the risk of someone forgetting this convention and calling | |
| 613 | 99 signal() directly. ]] |
| 100 | |
| 101 But current policy is to avoid playing with macros as much as | |
| 102 possible, since in the long run it really just ends up creating | |
| 103 unmaintainable code -- someone newly reading the code is never | |
| 104 going to realize exactly which calls are redirected, and on | |
| 105 which systems, and where the redirection occurs. | |
| 106 | |
| 107 Possibly we should use the new "qxe" convention. | |
| 108 */ | |
| 428 | 109 |
| 872 | 110 typedef RETSIGTYPE (XCDECL * signal_handler_t) (int); |
| 428 | 111 |
| 112 #if defined (HAVE_SIGPROCMASK) | |
| 113 | |
| 114 /* The POSIX way (sigaction, sigprocmask, sigpending, sigsuspend) */ | |
| 115 | |
| 613 | 116 signal_handler_t qxe_reliable_signal (int signal_number, |
| 117 signal_handler_t action); | |
| 118 | |
| 119 #define EMACS_SIGNAL qxe_reliable_signal | |
| 428 | 120 |
| 121 #define EMACS_BLOCK_SIGNAL(sig) do \ | |
| 122 { \ | |
| 123 sigset_t ES_mask; \ | |
| 124 sigemptyset (&ES_mask); \ | |
| 125 sigaddset (&ES_mask, sig); \ | |
| 126 sigprocmask (SIG_BLOCK, &ES_mask, NULL); \ | |
| 127 } while (0) | |
| 128 #define EMACS_UNBLOCK_SIGNAL(sig) do \ | |
| 129 { \ | |
| 130 sigset_t ES_mask; \ | |
| 131 sigemptyset (&ES_mask); \ | |
| 132 sigaddset (&ES_mask, sig); \ | |
| 133 sigprocmask (SIG_UNBLOCK, &ES_mask, NULL); \ | |
| 134 } while (0) | |
| 135 #define EMACS_UNBLOCK_ALL_SIGNALS() do \ | |
| 136 { \ | |
| 137 sigset_t ES_mask; \ | |
| 138 sigemptyset (&ES_mask); \ | |
| 139 sigprocmask (SIG_SETMASK, &ES_mask, NULL); \ | |
| 140 } while (0) | |
| 141 #define EMACS_WAIT_FOR_SIGNAL(sig) do \ | |
| 142 { \ | |
| 143 sigset_t ES_mask; \ | |
| 144 sigprocmask (0, NULL, &ES_mask); \ | |
| 145 sigdelset (&ES_mask, sig); \ | |
| 146 sigsuspend (&ES_mask); \ | |
| 147 } while (0) | |
| 148 #define EMACS_REESTABLISH_SIGNAL(sig, handler) | |
| 2286 | 149 #define SIG_ARG_MAYBE_UNUSED(decl) UNUSED (decl) |
| 428 | 150 |
| 151 #elif defined (HAVE_SIGBLOCK) | |
| 152 | |
| 153 /* The older BSD way (signal/sigvec, sigblock, sigsetmask, sigpause) */ | |
| 154 | |
| 155 /* It's OK to use signal() here directly. No unreliable signal | |
| 156 problems. However, we use sigvec() because it allows us to | |
| 157 request interruptible I/O. */ | |
| 158 | |
| 613 | 159 #define EMACS_SIGNAL qxe_reliable_signal |
| 428 | 160 |
| 161 /* Is it necessary to define sigmask like this? */ | |
| 162 #ifndef sigmask | |
| 163 # define sigmask(no) (1L << ((no) - 1)) | |
| 164 #endif | |
| 165 | |
| 166 #define EMACS_BLOCK_SIGNAL(sig) sigblock (sigmask (sig)) | |
| 167 #define EMACS_UNBLOCK_SIGNAL(sig) sigsetmask (sigblock (0) & ~sigmask (sig)) | |
| 168 #define EMACS_UNBLOCK_ALL_SIGNALS() sigsetmask (0) | |
| 169 #define EMACS_WAIT_FOR_SIGNAL(sig) do \ | |
| 170 { \ | |
| 171 int ES_mask = sigblock (0); \ | |
| 172 sigpause (ES_mask & ~sigmask (sig)); \ | |
| 173 } while (0) | |
| 174 #define EMACS_REESTABLISH_SIGNAL(sig, handler) | |
| 2286 | 175 #define SIG_ARG_MAYBE_UNUSED(decl) UNUSED (decl) |
| 428 | 176 |
| 177 #elif defined (HAVE_SIGHOLD) | |
| 178 | |
| 179 /* The older SYSV way (signal/sigset, sighold, sigrelse, sigignore, | |
| 180 sigpause) */ | |
| 181 | |
| 613 | 182 #define EMACS_SIGNAL sigset |
| 428 | 183 #define EMACS_BLOCK_SIGNAL(sig) sighold (sig) |
| 184 #define EMACS_UNBLOCK_SIGNAL(sig) sigrelse (sig) | |
| 185 /* #### There's not really any simple way to implement this. | |
| 186 Since EMACS_UNBLOCK_ALL_SIGNALS() is only called once (at startup), | |
| 187 it's probably OK to just ignore it. */ | |
| 188 #define EMACS_UNBLOCK_ALL_SIGNALS() 0 | |
| 189 #define EMACS_WAIT_FOR_SIGNAL(sig) sigpause (sig) | |
| 190 #define EMACS_REESTABLISH_SIGNAL(sig, handler) | |
| 2286 | 191 #define SIG_ARG_MAYBE_UNUSED(decl) UNUSED (decl) |
| 428 | 192 |
| 613 | 193 #elif defined (WIN32_NATIVE) |
| 194 | |
| 195 /* MS Windows signal emulation (in turns emulates the sigset/sighold | |
| 196 paradigm) */ | |
| 197 | |
| 198 #define EMACS_SIGNAL mswindows_sigset | |
| 199 #define EMACS_BLOCK_SIGNAL(sig) mswindows_sighold (sig) | |
| 200 #define EMACS_UNBLOCK_SIGNAL(sig) mswindows_sigrelse (sig) | |
| 201 /* #### There's not really any simple way to implement this. | |
| 202 Since EMACS_UNBLOCK_ALL_SIGNALS() is only called once (at startup), | |
| 203 it's probably OK to just ignore it. */ | |
| 204 #define EMACS_UNBLOCK_ALL_SIGNALS() 0 | |
| 205 #define EMACS_WAIT_FOR_SIGNAL(sig) mswindows_sigpause (sig) | |
| 206 #define EMACS_REESTABLISH_SIGNAL(sig, handler) | |
| 2286 | 207 #define SIG_ARG_MAYBE_UNUSED(decl) UNUSED (decl) |
| 613 | 208 |
| 209 /* Defines that we need that aren't in the standard signal.h */ | |
| 210 #define SIGHUP 1 /* Hang up */ | |
| 211 #define SIGQUIT 3 /* Quit process */ | |
| 212 #define SIGKILL 9 /* Die, die die */ | |
| 213 #define SIGALRM 14 /* Alarm */ | |
| 214 #define SIGPROF 29 /* Profiling timer exp */ | |
| 215 | |
| 428 | 216 #else |
| 217 | |
| 218 /* The oldest SYSV way (signal only; unreliable signals) */ | |
| 219 | |
| 220 /* Old USG systems don't really have signal blocking. | |
| 221 We indicate this by not defining EMACS_BLOCK_SIGNAL or | |
| 222 EMACS_WAIT_FOR_SIGNAL. */ | |
| 613 | 223 #define EMACS_SIGNAL signal |
| 428 | 224 #define EMACS_UNBLOCK_SIGNAL(sig) 0 |
| 225 #define EMACS_UNBLOCK_ALL_SIGNALS() 0 | |
| 226 #define EMACS_REESTABLISH_SIGNAL(sig, handler) do \ | |
| 227 { \ | |
| 228 int old_errno = errno; \ | |
| 229 signal (sig, handler); \ | |
| 230 errno = old_errno; \ | |
| 231 } while (0) | |
| 2286 | 232 #define SIG_ARG_MAYBE_UNUSED(decl) decl |
| 428 | 233 |
| 234 /* Under SYSV, setting a signal handler for SIGCLD causes | |
| 235 SIGCLD to immediately be sent if there any unwaited processes | |
| 236 out there. This means that the SIGCLD handler *must* call | |
| 237 wait() to reap the status of all processes -- it cannot | |
| 238 simply set a flag and then reestablish the handler, because | |
| 239 it will get called again, infinitely. We only need to | |
| 240 worry about this on systems where signals need to be | |
| 241 reestablished (SYSV Release 2 and earlier). */ | |
| 242 #define OBNOXIOUS_SYSV_SIGCLD_BEHAVIOR | |
| 243 | |
| 613 | 244 #endif /* different signalling methods */ |
| 428 | 245 |
| 246 /* On bsd, [man says] kill does not accept a negative number to kill a pgrp. | |
| 247 Must do that using the killpg call. */ | |
| 442 | 248 #ifdef HAVE_KILLPG |
| 249 #define EMACS_KILLPG(pid, signo) killpg (pid, signo) | |
| 814 | 250 #elif defined (WIN32_NATIVE) |
| 251 #define EMACS_KILLPG(pid, signo) should never be called | |
| 428 | 252 #else |
| 442 | 253 #define EMACS_KILLPG(pid, signo) kill (-(pid), signo) |
| 428 | 254 #endif |
| 255 | |
| 256 #ifndef NSIG | |
| 978 | 257 # ifdef USG5_4 |
| 258 /* Some SVr4s don't define NSIG in sys/signal.h for ANSI environments; | |
| 259 * instead, there's a system variable _sys_nsig. Unfortunately, we need the | |
| 260 * constant to dimension an array. So wire in the appropriate value here. | |
| 261 */ | |
| 262 # define NSIG 32 | |
| 263 # else | |
| 264 # define NSIG (SIGUSR2+1) /* guess how many elements are in sys_siglist... */ | |
| 265 # endif | |
| 428 | 266 #endif |
| 267 | |
| 2651 | 268 /* HAVE_DECL_SYS_SIGLIST is determined by configure. On Linux, it seems, |
| 428 | 269 configure incorrectly fails to find it, so s/linux.h defines |
| 270 HAVE_SYS_SIGLIST. */ | |
| 2655 | 271 #if (!defined(HAVE_DECL_SYS_SIGLIST) || !HAVE_DECL_SYS_SIGLIST ) && !defined (HAVE_SYS_SIGLIST) |
| 442 | 272 extern const char *sys_siglist[]; |
| 428 | 273 #endif |
| 274 | |
| 275 #ifdef SIGDANGER | |
| 276 SIGTYPE memory_warning_signal (int sig); | |
| 277 #endif | |
| 278 | |
| 613 | 279 #if defined (WIN32_NATIVE) || defined (CYGWIN_BROKEN_SIGNALS) |
| 442 | 280 typedef void (__cdecl *mswindows_sighandler) (int); |
| 613 | 281 |
| 282 /* Prototypes for signal functions, see win32.c */ | |
| 442 | 283 int mswindows_sighold (int nsig); |
| 284 int mswindows_sigrelse (int nsig); | |
| 285 int mswindows_sigpause (int nsig); | |
| 286 int mswindows_raise (int nsig); | |
| 613 | 287 mswindows_sighandler mswindows_sigset (int sig, mswindows_sighandler handler); |
| 288 | |
| 289 #endif /* defined (WIN32_NATIVE) || defined (CYGWIN_BROKEN_SIGNALS) */ | |
| 290 | |
| 291 signal_handler_t set_timeout_signal (int signal_number, | |
| 292 signal_handler_t action); | |
| 293 | |
| 428 | 294 |
| 440 | 295 #endif /* INCLUDED_syssignal_h_ */ |