Mercurial > hg > xemacs-beta
comparison src/eval.c @ 1204:e22b0213b713
[xemacs-hg @ 2003-01-12 11:07:58 by michaels]
modules/ChangeLog:
2002-12-16 Ben Wing <ben@xemacs.org>
* postgresql/postgresql.c:
remove ifdef USE_KKCC.
src/ChangeLog:
2003-01-08 Mike Sperber <mike@xemacs.org>
* console.h (CDFW_CONSOLE): Don't lead to a crash if we're dealing
with a dead window/frame/device/console.
2002-12-20 Mike Sperber <mike@xemacs.org>
* ui-gtk.c: Fix typo from Ben's patch: emacs_ffi_data is a
typedef, not a struct. emacs_gtk_object_data is a typedef, not a
struct.
* gtk-glue.c (gdk_event_to_emacs_event): Fix typos from Ben's
patch: le -> emacs_event + rearrange the code.
* event-gtk.c (gtk_event_to_emacs_event): Fix typos from Ben's
patch: ..._UNDERLYING_GDK_EVENT -> ..._GDK_EVENT, ev -> key_event.
* device-gtk.c: Fix typo from Ben's patch: x_keysym_map_hash_table
-> x_keysym_map_hashtable.
2002-12-19 Mike Sperber <mike@xemacs.org>
* menubar-x.c (set_frame_menubar): Initialize protect_me field of
popup_data.
2002-12-16 Ben Wing <ben@xemacs.org>
Major cleanup of KKCC, etc.
KKCC, pdump-related:
-- descriptions are written for all objects. this required some
changes in the format of some objects, e.g. extents, popup-data,
coding system, lstream, lcrecord-list.
-- KKCC now handles weakness in markers, hash tables, elsewhere
correctly (formerly, you'd eventually get a stack overflow due
to endlessly expanding markers).
-- textual changes: lrecord_description -> memory_description,
struct_description -> sized_memory_description.
-- extensive comment describing descriptions and pdump.
-- redo XD_UNION so it works inline and change its format to provide
sufficient info for pdump. implement XD_UNION in pdump. also add
XD_UNION_DYNAMIC_SIZE, which works like XD_UNION except for when
auto-computing structure sizes.
-- add support for XD_INDIRECT in description offsets (used by
extents).
-- add support for "description maps", allowing for indirect
descriptions that are retrieved from an object at run-time. this
generalizes XD_CODING_SYSTEM_END, XD_SPECIFIER_END, etc., which
have now been eliminated.
-- add a fifth field "flags" to memory_description, to support flags
that can be specified for this particular line. Currently defined
flags are XD_FLAG_NO_KKCC (KKCC should ignore this entry; useful
for the weakness above in markers, etc.), XD_FLAG_NO_PDUMP (pdump
should ignore this entry), XD_FLAG_UNION_DEFAULT_ENTRY (in
union maps, this specifies a "default" entry for all remaining
values), and XD_FLAG_FREE_LISP_OBJECT (for use with lcrecord-lists).
-- clean up the kkcc-itis in events, so that the differences
between event data as separate objects and as a union are now
minimized to a small number of places. with the new XD_UNION, we
no longer need event data as separate objects, so this code is no
longer ifdef USE_KKCC, but instead ifdef EVENT_DATA_AS_OBJECTS,
not used by default. make sure that we explicitly free the
separate event data objects when no longer in use, to maintain the
invariant the event processing causes no consing.
-- also remove other USE_KKCC ifdefs when not necessary.
-- allow for KKCC compilation under MS Windows.
-- fix README.kkcc.
-- dump_add_root_object -> dump_add_root_lisp_object.
-- implement dump_add_root_block and use this to handle
dump_add_opaque.
-- factor out some code duplicated in kkcc and pdump.
Other allocation/object-related:
-- change various *slots.h so MARKED_SLOT() call no longer
includes semicolon.
-- free_marker() takes a Lisp_Object not a direct pointer.
-- make bit vectors lcrecords, like vectors, and eliminate code
that essentially duplicated the lcrecord handling.
-- additional asserts in FREE_FIXED_TYPE, formerly duplicated in
the various callers of this.
-- all lcrecord allocation functions now zero out the returned
lcrecords. unnecessary calls to zero_lcrecord removed. add long
comment describing these functions.
-- extract out process and coding system slots, like for buffers,
frames, etc.
-- lcrecords now set the type of items sitting on the free list to
lcrecord_type_free.
-- changes to the way that gap arrays are allocated, for kkcc's
benefit -- now, one single memory block with a stretchy array on
the end, instead of a separate block holding the array.
Error-checking-related:
-- now can compile with C++ under MS Windows. clean up compile errors
discovered that way. (a few were real problems)
-- add C++ error-checking code to verify problems with mismatched
GCPRO/UNGCPRO. (there were a few in the kkcc code.) add long
comment about how to catch insufficient GCPRO (yes, it's possible
using C++).
-- add debug_p4(), a simple object printer, when debug_print()
doesn't work.
-- add dp() and db() as short synonyms of debug_print(),
debug_backtrace().
-- `print' tries EXTREMELY hard to avoid core dumping when printing
when crashing or from debug_print(), and tries as hard as it
reasonably can in other situations.
-- Correct the message output upon crashing to be more up-to-date.
Event-related:
-- document event-matches-key-specifier-p better.
-- generalize the dispatch queues formerly duplicated in the
various event implementations. add event methods to drain pending
events. generalize and clean up QUIT handling, removing
event-specific quit processing. allow arbitrary keystrokes, not
just ASCII, to be the QUIT char. among other things, this should
fix some longstanding bugs in X quit handling. long comment
describing the various event queues.
-- implement delaying of XFlush() if there are pending expose events.
SOMEONE PLEASE TRY THIS OUT.
-- Fix `xemacs -batch -l dunnet' under Cygwin. Try to fix under
MS Windows but not quite there yet.
Other:
-- class -> class_ and no more C++ games with this item.
new -> new_ in the lwlib code, so far not elsewhere.
-- use `struct htentry' not `struct hentry' in elhash.c to avoid
debugger confusion with hash.c.
-- new macros ALIST_LOOP_3, ALIST_LOOP_4.
* README.kkcc:
* alloc.c:
* alloc.c (deadbeef_memory):
* alloc.c (allocate_lisp_storage):
* alloc.c (copy_lisp_object):
* alloc.c (ALLOCATE_FIXED_TYPE_1):
* alloc.c (FREE_FIXED_TYPE):
* alloc.c (make_vector_internal):
* alloc.c (make_bit_vector_internal):
* 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 (struct string_chars_block):
* alloc.c (mark_lcrecord_list):
* alloc.c (make_lcrecord_list):
* alloc.c (alloc_managed_lcrecord):
* alloc.c (free_managed_lcrecord):
* alloc.c (alloc_automanaged_lcrecord):
* alloc.c (staticpro_1):
* alloc.c (staticpro):
* alloc.c (lispdesc_indirect_count_1):
* alloc.c (lispdesc_indirect_description_1):
* alloc.c (lispdesc_one_description_line_size):
* alloc.c (lispdesc_structure_size):
* alloc.c (mark_object_maybe_checking_free):
* alloc.c (mark_with_description):
* alloc.c (mark_struct_contents):
* alloc.c (mark_object):
* alloc.c (tick_lcrecord_stats):
* alloc.c (free_cons):
* alloc.c (free_key_data):
* alloc.c (free_button_data):
* alloc.c (free_motion_data):
* alloc.c (free_process_data):
* alloc.c (free_timeout_data):
* alloc.c (free_magic_data):
* alloc.c (free_magic_eval_data):
* alloc.c (free_eval_data):
* alloc.c (free_misc_user_data):
* alloc.c (free_marker):
* alloc.c (compact_string_chars):
* alloc.c (gc_sweep):
* alloc.c (garbage_collect_1):
* alloc.c (Fgarbage_collect):
* alloc.c (common_init_alloc_early):
* alloc.c (init_alloc_early):
* alloc.c (init_alloc_once_early):
* buffer.c:
* buffer.c (mark_buffer):
* buffer.c (MARKED_SLOT):
* buffer.c (cleanup_buffer_undo_lists):
* buffer.c (Fget_file_buffer):
* buffer.h (MARKED_SLOT):
* bufslots.h:
* bytecode.c:
* callint.c:
* casetab.c:
* chartab.c:
* chartab.c (symbol_to_char_table_type):
* cmdloop.c:
* cmdloop.c (Fcommand_loop_1):
* config.h.in (new):
* conslots.h:
* console-gtk-impl.h (struct gtk_frame):
* console-impl.h:
* console-impl.h (struct console):
* console-impl.h (MARKED_SLOT):
* console-impl.h (CONSOLE_QUIT_EVENT):
* console-msw-impl.h (XM_BUMPQUEUE):
* console-msw.c (write_string_to_mswindows_debugging_output):
* console-msw.h:
* console-stream-impl.h:
* console-stream-impl.h (struct stream_console):
* console-stream.c:
* console-stream.c (stream_init_console):
* console-stream.h:
* console-tty.c:
* console-tty.h:
* console-x.h:
* console.c:
* console.c (mark_console):
* console.c (MARKED_SLOT):
* console.c (allocate_console):
* console.c (get_console_variant):
* console.c (create_console):
* console.c (delete_console_internal):
* console.c (Fset_input_mode):
* console.c (Fcurrent_input_mode):
* console.c (common_init_complex_vars_of_console):
* console.h:
* console.h (console_variant):
* console.h (device_metrics):
* data.c:
* data.c (Faref):
* data.c (Faset):
* data.c (decode_weak_list_type):
* database.c:
* debug.c (xemacs_debug_loop):
* debug.c (FROB):
* debug.c (Fadd_debug_class_to_check):
* debug.c (Fdelete_debug_class_to_check):
* debug.c (Fset_debug_classes_to_check):
* debug.c (Fset_debug_class_types_to_check):
* debug.c (Fdebug_types_being_checked):
* debug.h (DASSERT):
* device-gtk.c:
* device-impl.h (struct device):
* device-impl.h (MARKED_SLOT):
* device-msw.c:
* device-x.c:
* device-x.c (x_init_device_class):
* device-x.c (x_comp_visual_info):
* device-x.c (x_try_best_visual_class):
* device-x.c (x_init_device):
* device-x.c (construct_name_list):
* device-x.c (x_get_resource_prefix):
* device-x.c (Fx_get_resource):
* device-x.c (Fx_display_visual_class):
* device.c:
* device.c (MARKED_SLOT):
* device.c (allocate_device):
* device.c (Fmake_device):
* device.c (delete_device_internal):
* device.c (Fset_device_class):
* device.h:
* devslots.h:
* devslots.h (MARKED_SLOT):
* dialog-msw.c:
* dired-msw.c (mswindows_ls_sort_fcn):
* dired-msw.c (mswindows_get_files):
* dired-msw.c (mswindows_format_file):
* doprnt.c (parse_doprnt_spec):
* dumper.c:
* dumper.c (struct):
* dumper.c (dump_add_root_block):
* dumper.c (dump_add_root_struct_ptr):
* dumper.c (dump_add_root_lisp_object):
* dumper.c (pdump_struct_list_elt):
* dumper.c (pdump_get_entry_list):
* dumper.c (pdump_backtrace):
* dumper.c (pdump_bump_depth):
* dumper.c (pdump_register_sub):
* dumper.c (pdump_register_object):
* dumper.c (pdump_register_struct_contents):
* dumper.c (pdump_register_struct):
* dumper.c (pdump_store_new_pointer_offsets):
* dumper.c (pdump_dump_data):
* dumper.c (pdump_reloc_one):
* dumper.c (pdump_allocate_offset):
* dumper.c (pdump_scan_by_alignment):
* dumper.c (pdump_dump_root_blocks):
* dumper.c (pdump_dump_rtables):
* dumper.c (pdump_dump_root_lisp_objects):
* dumper.c (pdump):
* dumper.c (pdump_load_finish):
* dumper.c (pdump_file_get):
* dumper.c (pdump_resource_get):
* dumper.c (pdump_load):
* editfns.c (save_excursion_restore):
* editfns.c (user_login_name):
* editfns.c (save_restriction_restore):
* elhash.c:
* elhash.c (htentry):
* elhash.c (struct Lisp_Hash_Table):
* elhash.c (HTENTRY_CLEAR_P):
* elhash.c (LINEAR_PROBING_LOOP):
* elhash.c (check_hash_table_invariants):
* elhash.c (mark_hash_table):
* elhash.c (hash_table_equal):
* elhash.c (print_hash_table_data):
* elhash.c (free_hentries):
* elhash.c (make_general_lisp_hash_table):
* elhash.c (decode_hash_table_weakness):
* elhash.c (decode_hash_table_test):
* elhash.c (Fcopy_hash_table):
* elhash.c (resize_hash_table):
* elhash.c (pdump_reorganize_hash_table):
* elhash.c (find_htentry):
* elhash.c (Fgethash):
* elhash.c (Fputhash):
* elhash.c (remhash_1):
* elhash.c (Fremhash):
* elhash.c (Fclrhash):
* elhash.c (copy_compress_hentries):
* elhash.c (elisp_maphash_unsafe):
* elhash.c (finish_marking_weak_hash_tables):
* elhash.c (prune_weak_hash_tables):
* elhash.h:
* emacs.c:
* emacs.c (main_1):
* emacs.c (main):
* emacs.c (shut_down_emacs):
* emodules.h (dump_add_root_lisp_object):
* eval.c:
* eval.c (unwind_to_catch):
* eval.c (maybe_signal_error_1):
* eval.c (maybe_signal_continuable_error_1):
* eval.c (maybe_signal_error):
* eval.c (maybe_signal_continuable_error):
* eval.c (maybe_signal_error_2):
* eval.c (maybe_signal_continuable_error_2):
* eval.c (maybe_signal_ferror):
* eval.c (maybe_signal_continuable_ferror):
* eval.c (maybe_signal_ferror_with_frob):
* eval.c (maybe_signal_continuable_ferror_with_frob):
* eval.c (maybe_syntax_error):
* eval.c (maybe_sferror):
* eval.c (maybe_invalid_argument):
* eval.c (maybe_invalid_constant):
* eval.c (maybe_invalid_operation):
* eval.c (maybe_invalid_change):
* eval.c (maybe_invalid_state):
* eval.c (Feval):
* eval.c (call_trapping_problems):
* eval.c (call_with_suspended_errors):
* eval.c (warn_when_safe_lispobj):
* eval.c (warn_when_safe):
* eval.c (vars_of_eval):
* event-Xt.c:
* event-Xt.c (maybe_define_x_key_as_self_inserting_character):
* event-Xt.c (x_to_emacs_keysym):
* event-Xt.c (x_event_to_emacs_event):
* event-Xt.c (emacs_Xt_enqueue_focus_event):
* event-Xt.c (emacs_Xt_format_magic_event):
* event-Xt.c (emacs_Xt_compare_magic_event):
* event-Xt.c (emacs_Xt_hash_magic_event):
* event-Xt.c (emacs_Xt_handle_magic_event):
* event-Xt.c (Xt_timeout_to_emacs_event):
* event-Xt.c (Xt_process_to_emacs_event):
* event-Xt.c (signal_special_Xt_user_event):
* event-Xt.c (emacs_Xt_next_event):
* event-Xt.c (emacs_Xt_event_handler):
* event-Xt.c (emacs_Xt_drain_queue):
* event-Xt.c (emacs_Xt_event_pending_p):
* event-Xt.c (check_if_pending_expose_event):
* event-Xt.c (reinit_vars_of_event_Xt):
* event-Xt.c (vars_of_event_Xt):
* event-gtk.c:
* event-gtk.c (IS_MODIFIER_KEY):
* event-gtk.c (emacs_gtk_format_magic_event):
* event-gtk.c (emacs_gtk_compare_magic_event):
* event-gtk.c (emacs_gtk_hash_magic_event):
* event-gtk.c (emacs_gtk_handle_magic_event):
* event-gtk.c (gtk_to_emacs_keysym):
* event-gtk.c (gtk_timeout_to_emacs_event):
* event-gtk.c (gtk_process_to_emacs_event):
* event-gtk.c (dragndrop_data_received):
* event-gtk.c (signal_special_gtk_user_event):
* event-gtk.c (emacs_gtk_next_event):
* event-gtk.c (gtk_event_to_emacs_event):
* event-gtk.c (generic_event_handler):
* event-gtk.c (emacs_shell_event_handler):
* event-gtk.c (emacs_gtk_drain_queue):
* event-gtk.c (emacs_gtk_event_pending_p):
* event-gtk.c (reinit_vars_of_event_gtk):
* event-gtk.c (vars_of_event_gtk):
* event-msw.c:
* event-msw.c (struct winsock_stream):
* event-msw.c (winsock_reader):
* event-msw.c (winsock_writer):
* event-msw.c (mswindows_enqueue_dispatch_event):
* event-msw.c (mswindows_enqueue_misc_user_event):
* event-msw.c (mswindows_enqueue_magic_event):
* event-msw.c (mswindows_enqueue_process_event):
* event-msw.c (mswindows_enqueue_mouse_button_event):
* event-msw.c (mswindows_enqueue_keypress_event):
* event-msw.c (mswindows_dequeue_dispatch_event):
* event-msw.c (emacs_mswindows_drain_queue):
* event-msw.c (mswindows_need_event_in_modal_loop):
* event-msw.c (mswindows_need_event):
* event-msw.c (mswindows_wm_timer_callback):
* event-msw.c (dde_eval_string):
* event-msw.c (Fdde_alloc_advise_item):
* event-msw.c (mswindows_dde_callback):
* event-msw.c (mswindows_wnd_proc):
* event-msw.c (remove_timeout_mapper):
* event-msw.c (emacs_mswindows_remove_timeout):
* event-msw.c (emacs_mswindows_event_pending_p):
* event-msw.c (emacs_mswindows_format_magic_event):
* event-msw.c (emacs_mswindows_compare_magic_event):
* event-msw.c (emacs_mswindows_hash_magic_event):
* event-msw.c (emacs_mswindows_handle_magic_event):
* event-msw.c (emacs_mswindows_select_console):
* event-msw.c (emacs_mswindows_unselect_console):
* event-msw.c (reinit_vars_of_event_mswindows):
* event-msw.c (vars_of_event_mswindows):
* event-stream.c:
* event-stream.c (mark_command_builder):
* event-stream.c (reset_command_builder_event_chain):
* event-stream.c (allocate_command_builder):
* event-stream.c (copy_command_builder):
* event-stream.c (command_builder_append_event):
* event-stream.c (event_stream_event_pending_p):
* event-stream.c (event_stream_force_event_pending):
* event-stream.c (maybe_read_quit_event):
* event-stream.c (event_stream_drain_queue):
* event-stream.c (remove_quit_p_event):
* event-stream.c (event_stream_quit_p):
* event-stream.c (echo_key_event):
* event-stream.c (maybe_kbd_translate):
* event-stream.c (execute_help_form):
* event-stream.c (event_stream_generate_wakeup):
* event-stream.c (enqueue_dispatch_event):
* event-stream.c (enqueue_magic_eval_event):
* event-stream.c (Fenqueue_eval_event):
* event-stream.c (enqueue_misc_user_event):
* event-stream.c (enqueue_misc_user_event_pos):
* event-stream.c (next_event_internal):
* event-stream.c (Fnext_event):
* event-stream.c (Faccept_process_output):
* event-stream.c (execute_internal_event):
* event-stream.c (munge_keymap_translate):
* event-stream.c (command_builder_find_leaf_no_mule_processing):
* event-stream.c (command_builder_find_leaf):
* event-stream.c (lookup_command_event):
* event-stream.c (is_scrollbar_event):
* event-stream.c (execute_command_event):
* event-stream.c (Fdispatch_event):
* event-stream.c (Fread_key_sequence):
* event-stream.c (dribble_out_event):
* event-stream.c (vars_of_event_stream):
* event-tty.c (tty_timeout_to_emacs_event):
* event-tty.c (emacs_tty_next_event):
* event-tty.c (emacs_tty_drain_queue):
* event-tty.c (reinit_vars_of_event_tty):
* event-unixoid.c:
* event-unixoid.c (find_tty_or_stream_console_from_fd):
* event-unixoid.c (read_event_from_tty_or_stream_desc):
* event-unixoid.c (drain_tty_devices):
* event-unixoid.c (poll_fds_for_input):
* events.c:
* events.c (deinitialize_event):
* events.c (zero_event):
* events.c (mark_event):
* events.c (print_event_1):
* events.c (print_event):
* events.c (event_equal):
* events.c (event_hash):
* events.c (Fmake_event):
* events.c (Fdeallocate_event):
* events.c (Fcopy_event):
* events.c (map_event_chain_remove):
* events.c (character_to_event):
* events.c (event_to_character):
* events.c (Fevent_to_character):
* events.c (format_event_object):
* events.c (upshift_event):
* events.c (downshift_event):
* events.c (event_upshifted_p):
* events.c (Fevent_live_p):
* events.c (Fevent_type):
* events.c (Fevent_timestamp):
* events.c (CHECK_EVENT_TYPE):
* events.c (CHECK_EVENT_TYPE2):
* events.c (CHECK_EVENT_TYPE3):
* events.c (Fevent_key):
* events.c (Fevent_button):
* events.c (Fevent_modifier_bits):
* events.c (event_x_y_pixel_internal):
* events.c (event_pixel_translation):
* events.c (Fevent_process):
* events.c (Fevent_function):
* events.c (Fevent_object):
* events.c (Fevent_properties):
* events.c (syms_of_events):
* events.c (vars_of_events):
* events.h:
* events.h (struct event_stream):
* events.h (struct Lisp_Key_Data):
* events.h (KEY_DATA_KEYSYM):
* events.h (EVENT_KEY_KEYSYM):
* events.h (struct Lisp_Button_Data):
* events.h (EVENT_BUTTON_BUTTON):
* events.h (struct Lisp_Motion_Data):
* events.h (EVENT_MOTION_X):
* events.h (struct Lisp_Process_Data):
* events.h (EVENT_PROCESS_PROCESS):
* events.h (struct Lisp_Timeout_Data):
* events.h (EVENT_TIMEOUT_INTERVAL_ID):
* events.h (struct Lisp_Eval_Data):
* events.h (EVENT_EVAL_FUNCTION):
* events.h (struct Lisp_Misc_User_Data):
* events.h (EVENT_MISC_USER_FUNCTION):
* events.h (struct Lisp_Magic_Eval_Data):
* events.h (EVENT_MAGIC_EVAL_INTERNAL_FUNCTION):
* events.h (struct Lisp_Magic_Data):
* events.h (EVENT_MAGIC_UNDERLYING):
* events.h (EVENT_MAGIC_GDK_EVENT):
* events.h (struct Lisp_Event):
* events.h (XEVENT_CHANNEL):
* events.h (SET_EVENT_TIMESTAMP_ZERO):
* events.h (SET_EVENT_CHANNEL):
* events.h (SET_EVENT_NEXT):
* events.h (XSET_EVENT_TYPE):
* events.h (struct command_builder):
* extents.c:
* extents.c (gap_array_adjust_markers):
* extents.c (gap_array_recompute_derived_values):
* extents.c (gap_array_move_gap):
* extents.c (gap_array_make_gap):
* extents.c (gap_array_insert_els):
* extents.c (gap_array_delete_els):
* extents.c (gap_array_make_marker):
* extents.c (gap_array_delete_marker):
* extents.c (gap_array_move_marker):
* extents.c (make_gap_array):
* extents.c (free_gap_array):
* extents.c (extent_list_num_els):
* extents.c (extent_list_insert):
* extents.c (mark_extent_auxiliary):
* extents.c (allocate_extent_auxiliary):
* extents.c (decode_extent_at_flag):
* extents.c (verify_extent_mapper):
* extents.c (symbol_to_glyph_layout):
* extents.c (syms_of_extents):
* faces.c:
* file-coding.c:
* file-coding.c (struct_detector_category_description =):
* file-coding.c (detector_category_dynarr_description_1):
* file-coding.c (struct_detector_description =):
* file-coding.c (detector_dynarr_description_1):
* file-coding.c (MARKED_SLOT):
* file-coding.c (mark_coding_system):
* file-coding.c (coding_system_extra_description_map):
* file-coding.c (coding_system_description):
* file-coding.c (allocate_coding_system):
* file-coding.c (symbol_to_eol_type):
* file-coding.c (Fcoding_system_aliasee):
* file-coding.c (set_coding_stream_coding_system):
* file-coding.c (struct convert_eol_coding_system):
* file-coding.c (struct undecided_coding_system):
* file-coding.c (undecided_mark_coding_stream):
* file-coding.c (coding_category_symbol_to_id):
* file-coding.c (struct gzip_coding_system):
* file-coding.c (coding_system_type_create):
* file-coding.h:
* file-coding.h (struct Lisp_Coding_System):
* file-coding.h (CODING_SYSTEM_SLOT_DECLARATION):
* file-coding.h (coding_system_variant):
* file-coding.h (struct coding_system_methods):
* file-coding.h (DEFINE_CODING_SYSTEM_TYPE_WITH_DATA):
* file-coding.h (INITIALIZE_CODING_SYSTEM_TYPE_WITH_DATA):
* file-coding.h (struct coding_stream):
* fileio.c (Fsubstitute_in_file_name):
* floatfns.c:
* fns.c:
* fns.c (base64_encode_1):
* frame-gtk.c:
* frame-gtk.c (Fgtk_start_drag_internal):
* frame-impl.h (struct frame):
* frame-impl.h (MARKED_SLOT):
* frame-msw.c:
* frame-x.c:
* frame-x.c (Fcde_start_drag_internal):
* frame-x.c (Foffix_start_drag_internal):
* frame.c:
* frame.c (MARKED_SLOT):
* frame.c (allocate_frame_core):
* frame.c (delete_frame_internal):
* frame.c (Fmouse_position_as_motion_event):
* frameslots.h:
* frameslots.h (MARKED_SLOT_ARRAY):
* free-hook.c:
* glyphs-msw.c (mswindows_widget_instantiate):
* glyphs-x.c:
* glyphs-x.c (convert_EImage_to_XImage):
* glyphs.c:
* glyphs.c (process_image_string_instantiator):
* glyphs.c (mark_image_instance):
* glyphs.c (allocate_image_instance):
* glyphs.c (unmap_subwindow):
* glyphs.c (map_subwindow):
* glyphs.c (syms_of_glyphs):
* glyphs.c (specifier_type_create_image):
* glyphs.h:
* glyphs.h (struct text_image_instance):
* glyphs.h (struct Lisp_Image_Instance):
* gmalloc.c:
* gmalloc.c ("C"):
* gpmevent.c (Freceive_gpm_event):
* gpmevent.c (gpm_next_event_cb):
* gpmevent.c (vars_of_gpmevent):
* gtk-glue.c (gdk_event_to_emacs_event):
* gtk-xemacs.c (gtk_xemacs_class_init):
* gui-msw.c:
* gui-msw.c (mswindows_handle_gui_wm_command):
* gui-msw.c (mswindows_translate_menu_or_dialog_item):
* gui-x.c:
* gui-x.c (mark_popup_data):
* gui-x.c (snarf_widget_value_mapper):
* gui-x.c (gcpro_popup_callbacks):
* gui-x.c (ungcpro_popup_callbacks):
* gui-x.c (free_popup_widget_value_tree):
* gui-x.c (popup_selection_callback):
* gui-x.h:
* gui-x.h (struct popup_data):
* gui.c:
* gui.c (allocate_gui_item):
* gutter.c (decode_gutter_position):
* hash.c (NULL_ENTRY):
* indent.c (vmotion_1):
* indent.c (vmotion_pixels):
* input-method-motif.c (res):
* input-method-xlib.c (IMInstantiateCallback):
* input-method-xlib.c (XIM_init_device):
* input-method-xlib.c (res):
* intl-encap-win32.c:
* intl-encap-win32.c (qxeSHGetDataFromIDList):
* intl-win32.c:
* intl-win32.c (mswindows_multibyte_cp_type):
* intl-win32.c (struct mswindows_multibyte_coding_system):
* keymap.c:
* keymap.c (make_key_description):
* keymap.c (keymap_store):
* keymap.c (get_keyelt):
* keymap.c (keymap_lookup_1):
* keymap.c (define_key_parser):
* keymap.c (key_desc_list_to_event):
* keymap.c (event_matches_key_specifier_p):
* keymap.c (meta_prefix_char_p):
* keymap.c (ensure_meta_prefix_char_keymapp):
* keymap.c (Fdefine_key):
* keymap.c (struct raw_lookup_key_mapper_closure):
* keymap.c (raw_lookup_key):
* keymap.c (raw_lookup_key_mapper):
* keymap.c (lookup_keys):
* keymap.c (lookup_events):
* keymap.c (Flookup_key):
* keymap.c (struct map_keymap_unsorted_closure):
* keymap.c (map_keymap_unsorted_mapper):
* keymap.c (map_keymap_sorted):
* keymap.c (map_keymap_mapper):
* keymap.c (map_keymap):
* keymap.c (accessible_keymaps_mapper_1):
* keymap.c (Faccessible_keymaps):
* keymap.c (Fsingle_key_description):
* keymap.c (raw_keys_to_keys):
* keymap.c (format_raw_keys):
* keymap.c (where_is_recursive_mapper):
* keymap.c (where_is_internal):
* keymap.c (describe_map_mapper_shadow_search):
* keymap.c (keymap_lookup_inherited_mapper):
* keymap.c (describe_map_mapper):
* keymap.h (event_matches_key_specifier_p):
* lisp.h:
* lisp.h (this):
* lisp.h (RETURN_NOT_REACHED):
* lisp.h (struct Lisp_Vector):
* lisp.h (struct Lisp_Bit_Vector):
* lisp.h (UNGCPRO_1):
* lisp.h (NUNGCPRO):
* lisp.h (NNUNGCPRO):
* lisp.h (DECLARE_INLINE_HEADER):
* lrecord.h:
* lrecord.h (struct lrecord_header):
* lrecord.h (struct lcrecord_header):
* lrecord.h (lrecord_type):
* lrecord.h (struct lrecord_implementation):
* lrecord.h (RECORD_DUMPABLE):
* lrecord.h (memory_description_type):
* lrecord.h (data_description_entry_flags):
* lrecord.h (struct memory_description):
* lrecord.h (struct sized_memory_description):
* lrecord.h (XD_INDIRECT):
* lrecord.h (XD_IS_INDIRECT):
* lrecord.h (XD_DYNARR_DESC):
* lrecord.h (DEFINE_BASIC_LRECORD_IMPLEMENTATION):
* lrecord.h (MAKE_LRECORD_IMPLEMENTATION):
* lrecord.h (MAKE_EXTERNAL_LRECORD_IMPLEMENTATION):
* lrecord.h (alloc_lcrecord_type):
* lstream.c:
* lstream.c (Lstream_new):
* lstream.c (lisp_buffer_marker):
* lstream.h:
* lstream.h (lstream_implementation):
* lstream.h (DEFINE_LSTREAM_IMPLEMENTATION):
* lstream.h (DEFINE_LSTREAM_IMPLEMENTATION_WITH_DATA):
* marker.c:
* marker.c (copy_marker_1):
* mem-limits.h:
* menubar-gtk.c:
* menubar-gtk.c (gtk_popup_menu):
* menubar-msw.c:
* menubar-msw.c (mswindows_popup_menu):
* menubar-x.c (make_dummy_xbutton_event):
* menubar-x.c (command_builder_operate_menu_accelerator):
* menubar-x.c (menu_accelerator_safe_compare):
* menubar-x.c (menu_accelerator_safe_mod_compare):
* mule-charset.c:
* mule-charset.c (make_charset):
* mule-charset.c (Fcharset_property):
* mule-coding.c:
* mule-coding.c (ccs_description_1):
* mule-coding.c (ccs_description =):
* mule-coding.c (ccsd_description_1):
* mule-coding.c (ccsd_description =):
* nt.c (getpwnam):
* nt.c (init_mswindows_environment):
* nt.c (get_cached_volume_information):
* nt.c (mswindows_is_executable):
* nt.c (read_unc_volume):
* nt.c (mswindows_access):
* nt.c (mswindows_link):
* nt.c (mswindows_fstat):
* nt.c (mswindows_stat):
* nt.c (mswindows_executable_type):
* nt.c (Fmswindows_short_file_name):
* nt.c (Fmswindows_long_file_name):
* objects-impl.h (struct Lisp_Color_Instance):
* objects-impl.h (struct Lisp_Font_Instance):
* objects-tty.c:
* objects-x.c (allocate_nearest_color):
* objects.c:
* objects.c (Fmake_color_instance):
* objects.c (Fmake_font_instance):
* objects.c (font_instantiate):
* opaque.c:
* opaque.c (make_opaque):
* opaque.c (make_opaque_ptr):
* opaque.c (reinit_opaque_early):
* opaque.c (init_opaque_once_early):
* print.c:
* print.c (printing_badness):
* print.c (printing_major_badness):
* print.c (print_internal):
* print.c (debug_p4):
* print.c (dp):
* print.c (debug_backtrace):
* process-nt.c (nt_create_process):
* process-nt.c (get_internet_address):
* process-unix.c:
* process-unix.c (struct unix_process_data):
* process-unix.c (get_internet_address):
* process-unix.c (unix_alloc_process_data):
* process-unix.c (unix_create_process):
* process-unix.c (try_to_initialize_subtty):
* process-unix.c (unix_kill_child_process):
* process-unix.c (process_type_create_unix):
* process.c:
* process.c (mark_process):
* process.c (MARKED_SLOT):
* process.c (make_process_internal):
* process.c (Fprocess_tty_name):
* process.c (decode_signal):
* process.h:
* procimpl.h:
* procimpl.h (struct process_methods):
* procimpl.h (struct Lisp_Process):
* rangetab.c:
* realpath.c (readlink_and_correct_case):
* redisplay-x.c (x_window_output_end):
* redisplay-x.c (x_redraw_exposed_area):
* redisplay-x.c (x_clear_frame):
* redisplay.c:
* redisplay.h:
* redisplay.h (struct rune_dglyph):
* redisplay.h (struct rune):
* scrollbar.c:
* scrollbar.c (create_scrollbar_instance):
* specifier.c:
* specifier.c (specifier_empty_extra_description_1):
* specifier.c (make_specifier_internal):
* specifier.c (decode_locale_type):
* specifier.c (decode_how_to_add_specification):
* specifier.h:
* specifier.h (struct specifier_methods):
* specifier.h (DEFINE_SPECIFIER_TYPE_WITH_DATA):
* specifier.h (INITIALIZE_SPECIFIER_TYPE_WITH_DATA):
* symbols.c:
* symbols.c (Fsetplist):
* symbols.c (default_value):
* symbols.c (decode_magic_handler_type):
* symbols.c (handler_type_from_function_symbol):
* symbols.c (Fdefvaralias):
* symbols.c (init_symbols_once_early):
* symbols.c (reinit_symbols_early):
* symsinit.h:
* sysdep.c (sys_subshell):
* sysdep.c (tty_init_sys_modes_on_device):
* syswindows.h:
* text.c (dfc_convert_to_external_format):
* text.c (dfc_convert_to_internal_format):
* text.c (reinit_eistring_early):
* text.c (init_eistring_once_early):
* text.c (reinit_vars_of_text):
* text.h:
* text.h (INC_IBYTEPTR_FMT):
* text.h (DEC_IBYTEPTR_FMT):
* toolbar.c:
* toolbar.c (decode_toolbar_position):
* tooltalk.c:
* ui-gtk.c:
* unexnt.c:
* unexnt.c (_start):
* unexnt.c (unexec):
* unexnt.c (get_section_info):
* unicode.c:
* unicode.c (vars_of_unicode):
* window.c:
* window.c (allocate_window):
* window.c (new_window_mirror):
* window.c (update_mirror_internal):
* winslots.h:
author | michaels |
---|---|
date | Sun, 12 Jan 2003 11:08:22 +0000 |
parents | ccd0667b4764 |
children | 465bd3c7d932 |
comparison
equal
deleted
inserted
replaced
1203:5f2f8dcbfb3e | 1204:e22b0213b713 |
---|---|
436 write_c_string (printcharfun, header); | 436 write_c_string (printcharfun, header); |
437 write_c_string (printcharfun, name); | 437 write_c_string (printcharfun, name); |
438 write_c_string (printcharfun, trailer); | 438 write_c_string (printcharfun, trailer); |
439 } | 439 } |
440 | 440 |
441 static const struct lrecord_description subr_description[] = { | 441 static const struct memory_description subr_description[] = { |
442 { XD_DOC_STRING, offsetof (Lisp_Subr, doc) }, | 442 { XD_DOC_STRING, offsetof (Lisp_Subr, doc) }, |
443 { XD_END } | 443 { XD_END } |
444 }; | 444 }; |
445 | 445 |
446 #ifdef USE_KKCC | |
447 DEFINE_BASIC_LRECORD_IMPLEMENTATION ("subr", subr, | 446 DEFINE_BASIC_LRECORD_IMPLEMENTATION ("subr", subr, |
448 1, /*dumpable-flag*/ | 447 1, /*dumpable-flag*/ |
449 0, print_subr, 0, 0, 0, | 448 0, print_subr, 0, 0, 0, |
450 subr_description, | 449 subr_description, |
451 Lisp_Subr); | 450 Lisp_Subr); |
452 #else /* not USE_KKCC */ | |
453 DEFINE_BASIC_LRECORD_IMPLEMENTATION ("subr", subr, | |
454 0, print_subr, 0, 0, 0, | |
455 subr_description, | |
456 Lisp_Subr); | |
457 #endif /* not USE_KKCC */ | |
458 | 451 |
459 /************************************************************************/ | 452 /************************************************************************/ |
460 /* Entering the debugger */ | 453 /* Entering the debugger */ |
461 /************************************************************************/ | 454 /************************************************************************/ |
462 | 455 |
1599 unbind_to (c->pdlcount); | 1592 unbind_to (c->pdlcount); |
1600 catchlist = c->next; | 1593 catchlist = c->next; |
1601 check_catchlist_sanity (); | 1594 check_catchlist_sanity (); |
1602 #endif /* Former code */ | 1595 #endif /* Former code */ |
1603 | 1596 |
1604 gcprolist = c->gcpro; | 1597 UNWIND_GCPRO_TO (c->gcpro); |
1605 backtrace_list = c->backlist; | 1598 backtrace_list = c->backlist; |
1606 lisp_eval_depth = c->lisp_eval_depth; | 1599 lisp_eval_depth = c->lisp_eval_depth; |
1607 | 1600 |
1608 #ifdef DEFEND_AGAINST_THROW_RECURSION | 1601 #ifdef DEFEND_AGAINST_THROW_RECURSION |
1609 throw_level = 0; | 1602 throw_level = 0; |
2161 void | 2154 void |
2162 signal_1 (void) | 2155 signal_1 (void) |
2163 { | 2156 { |
2164 } | 2157 } |
2165 | 2158 |
2159 #ifdef ERROR_CHECK_TRAPPING_PROBLEMS | |
2160 | |
2166 static void | 2161 static void |
2167 check_proper_critical_section_gc_protection (void) | 2162 check_proper_critical_section_gc_protection (void) |
2168 { | 2163 { |
2169 assert_with_message | 2164 assert_with_message |
2170 (!in_display || gc_currently_forbidden, | 2165 (!in_display || gc_currently_forbidden, |
2171 "Potential GC from within redisplay without being properly wrapped"); | 2166 "Potential GC from within redisplay without being properly wrapped"); |
2172 } | 2167 } |
2168 | |
2169 #endif /* ERROR_CHECK_TRAPPING_PROBLEMS */ | |
2173 | 2170 |
2174 static void | 2171 static void |
2175 check_proper_critical_section_nonlocal_exit_protection (void) | 2172 check_proper_critical_section_nonlocal_exit_protection (void) |
2176 { | 2173 { |
2177 assert_with_message | 2174 assert_with_message |
2444 according to ERRB. CLASS is the class of warning and should | 2441 according to ERRB. CLASS is the class of warning and should |
2445 refer to what sort of operation is being done (e.g. Qtoolbar, | 2442 refer to what sort of operation is being done (e.g. Qtoolbar, |
2446 Qresource, etc.). */ | 2443 Qresource, etc.). */ |
2447 | 2444 |
2448 void | 2445 void |
2449 maybe_signal_error_1 (Lisp_Object sig, Lisp_Object data, Lisp_Object class, | 2446 maybe_signal_error_1 (Lisp_Object sig, Lisp_Object data, Lisp_Object class_, |
2450 Error_Behavior errb) | 2447 Error_Behavior errb) |
2451 { | 2448 { |
2452 if (ERRB_EQ (errb, ERROR_ME_NOT)) | 2449 if (ERRB_EQ (errb, ERROR_ME_NOT)) |
2453 return; | 2450 return; |
2454 else if (ERRB_EQ (errb, ERROR_ME_DEBUG_WARN)) | 2451 else if (ERRB_EQ (errb, ERROR_ME_DEBUG_WARN)) |
2455 warn_when_safe_lispobj (class, Qdebug, Fcons (sig, data)); | 2452 warn_when_safe_lispobj (class_, Qdebug, Fcons (sig, data)); |
2456 else if (ERRB_EQ (errb, ERROR_ME_WARN)) | 2453 else if (ERRB_EQ (errb, ERROR_ME_WARN)) |
2457 warn_when_safe_lispobj (class, Qwarning, Fcons (sig, data)); | 2454 warn_when_safe_lispobj (class_, Qwarning, Fcons (sig, data)); |
2458 else | 2455 else |
2459 for (;;) | 2456 for (;;) |
2460 Fsignal (sig, data); | 2457 Fsignal (sig, data); |
2461 } | 2458 } |
2462 | 2459 |
2463 /* Signal a continuable error or display a warning or do nothing, | 2460 /* Signal a continuable error or display a warning or do nothing, |
2464 according to ERRB. */ | 2461 according to ERRB. */ |
2465 | 2462 |
2466 Lisp_Object | 2463 Lisp_Object |
2467 maybe_signal_continuable_error_1 (Lisp_Object sig, Lisp_Object data, | 2464 maybe_signal_continuable_error_1 (Lisp_Object sig, Lisp_Object data, |
2468 Lisp_Object class, Error_Behavior errb) | 2465 Lisp_Object class_, Error_Behavior errb) |
2469 { | 2466 { |
2470 if (ERRB_EQ (errb, ERROR_ME_NOT)) | 2467 if (ERRB_EQ (errb, ERROR_ME_NOT)) |
2471 return Qnil; | 2468 return Qnil; |
2472 else if (ERRB_EQ (errb, ERROR_ME_DEBUG_WARN)) | 2469 else if (ERRB_EQ (errb, ERROR_ME_DEBUG_WARN)) |
2473 { | 2470 { |
2474 warn_when_safe_lispobj (class, Qdebug, Fcons (sig, data)); | 2471 warn_when_safe_lispobj (class_, Qdebug, Fcons (sig, data)); |
2475 return Qnil; | 2472 return Qnil; |
2476 } | 2473 } |
2477 else if (ERRB_EQ (errb, ERROR_ME_WARN)) | 2474 else if (ERRB_EQ (errb, ERROR_ME_WARN)) |
2478 { | 2475 { |
2479 warn_when_safe_lispobj (class, Qwarning, Fcons (sig, data)); | 2476 warn_when_safe_lispobj (class_, Qwarning, Fcons (sig, data)); |
2480 return Qnil; | 2477 return Qnil; |
2481 } | 2478 } |
2482 else | 2479 else |
2483 return Fsignal (sig, data); | 2480 return Fsignal (sig, data); |
2484 } | 2481 } |
2520 signal_error_1 (type, build_error_data (reason, frob)); | 2517 signal_error_1 (type, build_error_data (reason, frob)); |
2521 } | 2518 } |
2522 | 2519 |
2523 void | 2520 void |
2524 maybe_signal_error (Lisp_Object type, const CIbyte *reason, | 2521 maybe_signal_error (Lisp_Object type, const CIbyte *reason, |
2525 Lisp_Object frob, Lisp_Object class, | 2522 Lisp_Object frob, Lisp_Object class_, |
2526 Error_Behavior errb) | 2523 Error_Behavior errb) |
2527 { | 2524 { |
2528 /* Optimization: */ | 2525 /* Optimization: */ |
2529 if (ERRB_EQ (errb, ERROR_ME_NOT)) | 2526 if (ERRB_EQ (errb, ERROR_ME_NOT)) |
2530 return; | 2527 return; |
2531 maybe_signal_error_1 (type, build_error_data (reason, frob), class, errb); | 2528 maybe_signal_error_1 (type, build_error_data (reason, frob), class_, errb); |
2532 } | 2529 } |
2533 | 2530 |
2534 Lisp_Object | 2531 Lisp_Object |
2535 signal_continuable_error (Lisp_Object type, const CIbyte *reason, | 2532 signal_continuable_error (Lisp_Object type, const CIbyte *reason, |
2536 Lisp_Object frob) | 2533 Lisp_Object frob) |
2538 return Fsignal (type, build_error_data (reason, frob)); | 2535 return Fsignal (type, build_error_data (reason, frob)); |
2539 } | 2536 } |
2540 | 2537 |
2541 Lisp_Object | 2538 Lisp_Object |
2542 maybe_signal_continuable_error (Lisp_Object type, const CIbyte *reason, | 2539 maybe_signal_continuable_error (Lisp_Object type, const CIbyte *reason, |
2543 Lisp_Object frob, Lisp_Object class, | 2540 Lisp_Object frob, Lisp_Object class_, |
2544 Error_Behavior errb) | 2541 Error_Behavior errb) |
2545 { | 2542 { |
2546 /* Optimization: */ | 2543 /* Optimization: */ |
2547 if (ERRB_EQ (errb, ERROR_ME_NOT)) | 2544 if (ERRB_EQ (errb, ERROR_ME_NOT)) |
2548 return Qnil; | 2545 return Qnil; |
2549 return maybe_signal_continuable_error_1 (type, | 2546 return maybe_signal_continuable_error_1 (type, |
2550 build_error_data (reason, frob), | 2547 build_error_data (reason, frob), |
2551 class, errb); | 2548 class_, errb); |
2552 } | 2549 } |
2553 | 2550 |
2554 | 2551 |
2555 /****************** Error functions class 3 ******************/ | 2552 /****************** Error functions class 3 ******************/ |
2556 | 2553 |
2569 } | 2566 } |
2570 | 2567 |
2571 void | 2568 void |
2572 maybe_signal_error_2 (Lisp_Object type, const CIbyte *reason, | 2569 maybe_signal_error_2 (Lisp_Object type, const CIbyte *reason, |
2573 Lisp_Object frob0, Lisp_Object frob1, | 2570 Lisp_Object frob0, Lisp_Object frob1, |
2574 Lisp_Object class, Error_Behavior errb) | 2571 Lisp_Object class_, Error_Behavior errb) |
2575 { | 2572 { |
2576 /* Optimization: */ | 2573 /* Optimization: */ |
2577 if (ERRB_EQ (errb, ERROR_ME_NOT)) | 2574 if (ERRB_EQ (errb, ERROR_ME_NOT)) |
2578 return; | 2575 return; |
2579 maybe_signal_error_1 (type, list3 (build_msg_string (reason), frob0, | 2576 maybe_signal_error_1 (type, list3 (build_msg_string (reason), frob0, |
2580 frob1), class, errb); | 2577 frob1), class_, errb); |
2581 } | 2578 } |
2582 | 2579 |
2583 Lisp_Object | 2580 Lisp_Object |
2584 signal_continuable_error_2 (Lisp_Object type, const CIbyte *reason, | 2581 signal_continuable_error_2 (Lisp_Object type, const CIbyte *reason, |
2585 Lisp_Object frob0, Lisp_Object frob1) | 2582 Lisp_Object frob0, Lisp_Object frob1) |
2589 } | 2586 } |
2590 | 2587 |
2591 Lisp_Object | 2588 Lisp_Object |
2592 maybe_signal_continuable_error_2 (Lisp_Object type, const CIbyte *reason, | 2589 maybe_signal_continuable_error_2 (Lisp_Object type, const CIbyte *reason, |
2593 Lisp_Object frob0, Lisp_Object frob1, | 2590 Lisp_Object frob0, Lisp_Object frob1, |
2594 Lisp_Object class, Error_Behavior errb) | 2591 Lisp_Object class_, Error_Behavior errb) |
2595 { | 2592 { |
2596 /* Optimization: */ | 2593 /* Optimization: */ |
2597 if (ERRB_EQ (errb, ERROR_ME_NOT)) | 2594 if (ERRB_EQ (errb, ERROR_ME_NOT)) |
2598 return Qnil; | 2595 return Qnil; |
2599 return maybe_signal_continuable_error_1 | 2596 return maybe_signal_continuable_error_1 |
2600 (type, list3 (build_msg_string (reason), frob0, frob1), | 2597 (type, list3 (build_msg_string (reason), frob0, frob1), |
2601 class, errb); | 2598 class_, errb); |
2602 } | 2599 } |
2603 | 2600 |
2604 | 2601 |
2605 /****************** Error functions class 4 ******************/ | 2602 /****************** Error functions class 4 ******************/ |
2606 | 2603 |
2621 /* Fsignal GC-protects its args */ | 2618 /* Fsignal GC-protects its args */ |
2622 signal_error (type, 0, obj); | 2619 signal_error (type, 0, obj); |
2623 } | 2620 } |
2624 | 2621 |
2625 void | 2622 void |
2626 maybe_signal_ferror (Lisp_Object type, Lisp_Object class, Error_Behavior errb, | 2623 maybe_signal_ferror (Lisp_Object type, Lisp_Object class_, Error_Behavior errb, |
2627 const CIbyte *fmt, ...) | 2624 const CIbyte *fmt, ...) |
2628 { | 2625 { |
2629 Lisp_Object obj; | 2626 Lisp_Object obj; |
2630 va_list args; | 2627 va_list args; |
2631 | 2628 |
2636 va_start (args, fmt); | 2633 va_start (args, fmt); |
2637 obj = emacs_vsprintf_string (CGETTEXT (fmt), args); | 2634 obj = emacs_vsprintf_string (CGETTEXT (fmt), args); |
2638 va_end (args); | 2635 va_end (args); |
2639 | 2636 |
2640 /* Fsignal GC-protects its args */ | 2637 /* Fsignal GC-protects its args */ |
2641 maybe_signal_error (type, 0, obj, class, errb); | 2638 maybe_signal_error (type, 0, obj, class_, errb); |
2642 } | 2639 } |
2643 | 2640 |
2644 Lisp_Object | 2641 Lisp_Object |
2645 signal_continuable_ferror (Lisp_Object type, const CIbyte *fmt, ...) | 2642 signal_continuable_ferror (Lisp_Object type, const CIbyte *fmt, ...) |
2646 { | 2643 { |
2654 /* Fsignal GC-protects its args */ | 2651 /* Fsignal GC-protects its args */ |
2655 return Fsignal (type, list1 (obj)); | 2652 return Fsignal (type, list1 (obj)); |
2656 } | 2653 } |
2657 | 2654 |
2658 Lisp_Object | 2655 Lisp_Object |
2659 maybe_signal_continuable_ferror (Lisp_Object type, Lisp_Object class, | 2656 maybe_signal_continuable_ferror (Lisp_Object type, Lisp_Object class_, |
2660 Error_Behavior errb, const CIbyte *fmt, ...) | 2657 Error_Behavior errb, const CIbyte *fmt, ...) |
2661 { | 2658 { |
2662 Lisp_Object obj; | 2659 Lisp_Object obj; |
2663 va_list args; | 2660 va_list args; |
2664 | 2661 |
2669 va_start (args, fmt); | 2666 va_start (args, fmt); |
2670 obj = emacs_vsprintf_string (CGETTEXT (fmt), args); | 2667 obj = emacs_vsprintf_string (CGETTEXT (fmt), args); |
2671 va_end (args); | 2668 va_end (args); |
2672 | 2669 |
2673 /* Fsignal GC-protects its args */ | 2670 /* Fsignal GC-protects its args */ |
2674 return maybe_signal_continuable_error (type, 0, obj, class, errb); | 2671 return maybe_signal_continuable_error (type, 0, obj, class_, errb); |
2675 } | 2672 } |
2676 | 2673 |
2677 | 2674 |
2678 /****************** Error functions class 5 ******************/ | 2675 /****************** Error functions class 5 ******************/ |
2679 | 2676 |
2704 signal_error_1 (type, Fcons (obj, build_error_data (0, frob))); | 2701 signal_error_1 (type, Fcons (obj, build_error_data (0, frob))); |
2705 } | 2702 } |
2706 | 2703 |
2707 void | 2704 void |
2708 maybe_signal_ferror_with_frob (Lisp_Object type, Lisp_Object frob, | 2705 maybe_signal_ferror_with_frob (Lisp_Object type, Lisp_Object frob, |
2709 Lisp_Object class, Error_Behavior errb, | 2706 Lisp_Object class_, Error_Behavior errb, |
2710 const CIbyte *fmt, ...) | 2707 const CIbyte *fmt, ...) |
2711 { | 2708 { |
2712 Lisp_Object obj; | 2709 Lisp_Object obj; |
2713 va_list args; | 2710 va_list args; |
2714 | 2711 |
2719 va_start (args, fmt); | 2716 va_start (args, fmt); |
2720 obj = emacs_vsprintf_string (CGETTEXT (fmt), args); | 2717 obj = emacs_vsprintf_string (CGETTEXT (fmt), args); |
2721 va_end (args); | 2718 va_end (args); |
2722 | 2719 |
2723 /* Fsignal GC-protects its args */ | 2720 /* Fsignal GC-protects its args */ |
2724 maybe_signal_error_1 (type, Fcons (obj, build_error_data (0, frob)), class, | 2721 maybe_signal_error_1 (type, Fcons (obj, build_error_data (0, frob)), class_, |
2725 errb); | 2722 errb); |
2726 } | 2723 } |
2727 | 2724 |
2728 Lisp_Object | 2725 Lisp_Object |
2729 signal_continuable_ferror_with_frob (Lisp_Object type, Lisp_Object frob, | 2726 signal_continuable_ferror_with_frob (Lisp_Object type, Lisp_Object frob, |
2740 return Fsignal (type, Fcons (obj, build_error_data (0, frob))); | 2737 return Fsignal (type, Fcons (obj, build_error_data (0, frob))); |
2741 } | 2738 } |
2742 | 2739 |
2743 Lisp_Object | 2740 Lisp_Object |
2744 maybe_signal_continuable_ferror_with_frob (Lisp_Object type, Lisp_Object frob, | 2741 maybe_signal_continuable_ferror_with_frob (Lisp_Object type, Lisp_Object frob, |
2745 Lisp_Object class, | 2742 Lisp_Object class_, |
2746 Error_Behavior errb, | 2743 Error_Behavior errb, |
2747 const CIbyte *fmt, ...) | 2744 const CIbyte *fmt, ...) |
2748 { | 2745 { |
2749 Lisp_Object obj; | 2746 Lisp_Object obj; |
2750 va_list args; | 2747 va_list args; |
2759 | 2756 |
2760 /* Fsignal GC-protects its args */ | 2757 /* Fsignal GC-protects its args */ |
2761 return maybe_signal_continuable_error_1 (type, | 2758 return maybe_signal_continuable_error_1 (type, |
2762 Fcons (obj, | 2759 Fcons (obj, |
2763 build_error_data (0, frob)), | 2760 build_error_data (0, frob)), |
2764 class, errb); | 2761 class_, errb); |
2765 } | 2762 } |
2766 | 2763 |
2767 | 2764 |
2768 /* This is what the QUIT macro calls to signal a quit */ | 2765 /* This is what the QUIT macro calls to signal a quit */ |
2769 void | 2766 void |
2843 signal_error_2 (Qsyntax_error, reason, frob1, frob2); | 2840 signal_error_2 (Qsyntax_error, reason, frob1, frob2); |
2844 } | 2841 } |
2845 | 2842 |
2846 void | 2843 void |
2847 maybe_syntax_error (const CIbyte *reason, Lisp_Object frob, | 2844 maybe_syntax_error (const CIbyte *reason, Lisp_Object frob, |
2848 Lisp_Object class, Error_Behavior errb) | 2845 Lisp_Object class_, Error_Behavior errb) |
2849 { | 2846 { |
2850 maybe_signal_error (Qsyntax_error, reason, frob, class, errb); | 2847 maybe_signal_error (Qsyntax_error, reason, frob, class_, errb); |
2851 } | 2848 } |
2852 | 2849 |
2853 DOESNT_RETURN | 2850 DOESNT_RETURN |
2854 sferror (const CIbyte *reason, Lisp_Object frob) | 2851 sferror (const CIbyte *reason, Lisp_Object frob) |
2855 { | 2852 { |
2862 signal_error_2 (Qstructure_formation_error, reason, frob1, frob2); | 2859 signal_error_2 (Qstructure_formation_error, reason, frob1, frob2); |
2863 } | 2860 } |
2864 | 2861 |
2865 void | 2862 void |
2866 maybe_sferror (const CIbyte *reason, Lisp_Object frob, | 2863 maybe_sferror (const CIbyte *reason, Lisp_Object frob, |
2867 Lisp_Object class, Error_Behavior errb) | 2864 Lisp_Object class_, Error_Behavior errb) |
2868 { | 2865 { |
2869 maybe_signal_error (Qstructure_formation_error, reason, frob, class, errb); | 2866 maybe_signal_error (Qstructure_formation_error, reason, frob, class_, errb); |
2870 } | 2867 } |
2871 | 2868 |
2872 DOESNT_RETURN | 2869 DOESNT_RETURN |
2873 invalid_argument (const CIbyte *reason, Lisp_Object frob) | 2870 invalid_argument (const CIbyte *reason, Lisp_Object frob) |
2874 { | 2871 { |
2882 signal_error_2 (Qinvalid_argument, reason, frob1, frob2); | 2879 signal_error_2 (Qinvalid_argument, reason, frob1, frob2); |
2883 } | 2880 } |
2884 | 2881 |
2885 void | 2882 void |
2886 maybe_invalid_argument (const CIbyte *reason, Lisp_Object frob, | 2883 maybe_invalid_argument (const CIbyte *reason, Lisp_Object frob, |
2887 Lisp_Object class, Error_Behavior errb) | 2884 Lisp_Object class_, Error_Behavior errb) |
2888 { | 2885 { |
2889 maybe_signal_error (Qinvalid_argument, reason, frob, class, errb); | 2886 maybe_signal_error (Qinvalid_argument, reason, frob, class_, errb); |
2890 } | 2887 } |
2891 | 2888 |
2892 DOESNT_RETURN | 2889 DOESNT_RETURN |
2893 invalid_constant (const CIbyte *reason, Lisp_Object frob) | 2890 invalid_constant (const CIbyte *reason, Lisp_Object frob) |
2894 { | 2891 { |
2902 signal_error_2 (Qinvalid_constant, reason, frob1, frob2); | 2899 signal_error_2 (Qinvalid_constant, reason, frob1, frob2); |
2903 } | 2900 } |
2904 | 2901 |
2905 void | 2902 void |
2906 maybe_invalid_constant (const CIbyte *reason, Lisp_Object frob, | 2903 maybe_invalid_constant (const CIbyte *reason, Lisp_Object frob, |
2907 Lisp_Object class, Error_Behavior errb) | 2904 Lisp_Object class_, Error_Behavior errb) |
2908 { | 2905 { |
2909 maybe_signal_error (Qinvalid_constant, reason, frob, class, errb); | 2906 maybe_signal_error (Qinvalid_constant, reason, frob, class_, errb); |
2910 } | 2907 } |
2911 | 2908 |
2912 DOESNT_RETURN | 2909 DOESNT_RETURN |
2913 invalid_operation (const CIbyte *reason, Lisp_Object frob) | 2910 invalid_operation (const CIbyte *reason, Lisp_Object frob) |
2914 { | 2911 { |
2922 signal_error_2 (Qinvalid_operation, reason, frob1, frob2); | 2919 signal_error_2 (Qinvalid_operation, reason, frob1, frob2); |
2923 } | 2920 } |
2924 | 2921 |
2925 void | 2922 void |
2926 maybe_invalid_operation (const CIbyte *reason, Lisp_Object frob, | 2923 maybe_invalid_operation (const CIbyte *reason, Lisp_Object frob, |
2927 Lisp_Object class, Error_Behavior errb) | 2924 Lisp_Object class_, Error_Behavior errb) |
2928 { | 2925 { |
2929 maybe_signal_error (Qinvalid_operation, reason, frob, class, errb); | 2926 maybe_signal_error (Qinvalid_operation, reason, frob, class_, errb); |
2930 } | 2927 } |
2931 | 2928 |
2932 DOESNT_RETURN | 2929 DOESNT_RETURN |
2933 invalid_change (const CIbyte *reason, Lisp_Object frob) | 2930 invalid_change (const CIbyte *reason, Lisp_Object frob) |
2934 { | 2931 { |
2941 signal_error_2 (Qinvalid_change, reason, frob1, frob2); | 2938 signal_error_2 (Qinvalid_change, reason, frob1, frob2); |
2942 } | 2939 } |
2943 | 2940 |
2944 void | 2941 void |
2945 maybe_invalid_change (const CIbyte *reason, Lisp_Object frob, | 2942 maybe_invalid_change (const CIbyte *reason, Lisp_Object frob, |
2946 Lisp_Object class, Error_Behavior errb) | 2943 Lisp_Object class_, Error_Behavior errb) |
2947 { | 2944 { |
2948 maybe_signal_error (Qinvalid_change, reason, frob, class, errb); | 2945 maybe_signal_error (Qinvalid_change, reason, frob, class_, errb); |
2949 } | 2946 } |
2950 | 2947 |
2951 DOESNT_RETURN | 2948 DOESNT_RETURN |
2952 invalid_state (const CIbyte *reason, Lisp_Object frob) | 2949 invalid_state (const CIbyte *reason, Lisp_Object frob) |
2953 { | 2950 { |
2960 signal_error_2 (Qinvalid_state, reason, frob1, frob2); | 2957 signal_error_2 (Qinvalid_state, reason, frob1, frob2); |
2961 } | 2958 } |
2962 | 2959 |
2963 void | 2960 void |
2964 maybe_invalid_state (const CIbyte *reason, Lisp_Object frob, | 2961 maybe_invalid_state (const CIbyte *reason, Lisp_Object frob, |
2965 Lisp_Object class, Error_Behavior errb) | 2962 Lisp_Object class_, Error_Behavior errb) |
2966 { | 2963 { |
2967 maybe_signal_error (Qinvalid_state, reason, frob, class, errb); | 2964 maybe_signal_error (Qinvalid_state, reason, frob, class_, errb); |
2968 } | 2965 } |
2969 | 2966 |
2970 DOESNT_RETURN | 2967 DOESNT_RETURN |
2971 wtaerror (const CIbyte *reason, Lisp_Object frob) | 2968 wtaerror (const CIbyte *reason, Lisp_Object frob) |
2972 { | 2969 { |
3469 while (!in_warnings && !NILP (Vpending_warnings) | 3466 while (!in_warnings && !NILP (Vpending_warnings) |
3470 /* well, perhaps not so safe after all! */ | 3467 /* well, perhaps not so safe after all! */ |
3471 && !(inhibit_flags & INHIBIT_ANY_CHANGE_AFFECTING_REDISPLAY)) | 3468 && !(inhibit_flags & INHIBIT_ANY_CHANGE_AFFECTING_REDISPLAY)) |
3472 { | 3469 { |
3473 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4; | 3470 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4; |
3474 Lisp_Object this_warning_cons, this_warning, class, level, messij; | 3471 Lisp_Object this_warning_cons, this_warning, class_, level, messij; |
3475 int speccount = internal_bind_int (&in_warnings, 1); | 3472 int speccount = internal_bind_int (&in_warnings, 1); |
3476 | 3473 |
3477 this_warning_cons = Vpending_warnings; | 3474 this_warning_cons = Vpending_warnings; |
3478 this_warning = XCAR (this_warning_cons); | 3475 this_warning = XCAR (this_warning_cons); |
3479 /* in case an error occurs in the warn function, at least | 3476 /* in case an error occurs in the warn function, at least |
3480 it won't happen infinitely */ | 3477 it won't happen infinitely */ |
3481 Vpending_warnings = XCDR (Vpending_warnings); | 3478 Vpending_warnings = XCDR (Vpending_warnings); |
3482 free_cons (this_warning_cons); | 3479 free_cons (this_warning_cons); |
3483 class = XCAR (this_warning); | 3480 class_ = XCAR (this_warning); |
3484 level = XCAR (XCDR (this_warning)); | 3481 level = XCAR (XCDR (this_warning)); |
3485 messij = XCAR (XCDR (XCDR (this_warning))); | 3482 messij = XCAR (XCDR (XCDR (this_warning))); |
3486 free_list (this_warning); | 3483 free_list (this_warning); |
3487 | 3484 |
3488 if (NILP (Vpending_warnings)) | 3485 if (NILP (Vpending_warnings)) |
3489 Vpending_warnings_tail = Qnil; /* perhaps not strictly necessary, | 3486 Vpending_warnings_tail = Qnil; /* perhaps not strictly necessary, |
3490 but safer */ | 3487 but safer */ |
3491 | 3488 |
3492 GCPRO4 (form, class, level, messij); | 3489 GCPRO4 (form, class_, level, messij); |
3493 if (!STRINGP (messij)) | 3490 if (!STRINGP (messij)) |
3494 messij = Fprin1_to_string (messij, Qnil); | 3491 messij = Fprin1_to_string (messij, Qnil); |
3495 call3 (Qdisplay_warning, class, messij, level); | 3492 call3 (Qdisplay_warning, class_, messij, level); |
3496 UNGCPRO; | 3493 UNGCPRO; |
3497 unbind_to (speccount); | 3494 unbind_to (speccount); |
3498 } | 3495 } |
3499 | 3496 |
3500 if (!CONSP (form)) | 3497 if (!CONSP (form)) |
5069 else | 5066 else |
5070 /* Nothing special. */ | 5067 /* Nothing special. */ |
5071 tem = (fun) (arg); | 5068 tem = (fun) (arg); |
5072 | 5069 |
5073 if (thrown && !EQ (thrown_tag, package.catchtag) | 5070 if (thrown && !EQ (thrown_tag, package.catchtag) |
5074 && (!flags & INHIBIT_WARNING_ISSUE) | 5071 && !(flags & INHIBIT_WARNING_ISSUE) |
5075 && !warning_will_be_discarded (current_warning_level ())) | 5072 && !warning_will_be_discarded (current_warning_level ())) |
5076 { | 5073 { |
5077 Lisp_Object errstr; | 5074 Lisp_Object errstr; |
5078 | 5075 |
5079 if (!(flags & INHIBIT_QUIT)) | 5076 if (!(flags & INHIBIT_QUIT)) |
5193 #### eliminate this or at least merge the ERROR_BEHAVIOR stuff into | 5190 #### eliminate this or at least merge the ERROR_BEHAVIOR stuff into |
5194 va_call_trapping_problems(). */ | 5191 va_call_trapping_problems(). */ |
5195 | 5192 |
5196 Lisp_Object | 5193 Lisp_Object |
5197 call_with_suspended_errors (lisp_fn_t fun, Lisp_Object retval, | 5194 call_with_suspended_errors (lisp_fn_t fun, Lisp_Object retval, |
5198 Lisp_Object class, Error_Behavior errb, | 5195 Lisp_Object class_, Error_Behavior errb, |
5199 int nargs, ...) | 5196 int nargs, ...) |
5200 { | 5197 { |
5201 va_list vargs; | 5198 va_list vargs; |
5202 Lisp_Object args[20]; | 5199 Lisp_Object args[20]; |
5203 int i; | 5200 int i; |
5204 struct va_call_trapping_problems fazer_invocacao_atrapalhando_problemas; | 5201 struct va_call_trapping_problems fazer_invocacao_atrapalhando_problemas; |
5205 int flags; | 5202 int flags; |
5206 struct gcpro gcpro1; | 5203 struct gcpro gcpro1; |
5207 | 5204 |
5208 assert (SYMBOLP (class)); /* sanity-check */ | 5205 assert (SYMBOLP (class_)); /* sanity-check */ |
5209 assert (!NILP (class)); | 5206 assert (!NILP (class_)); |
5210 assert (nargs >= 0 && nargs < 20); | 5207 assert (nargs >= 0 && nargs < 20); |
5211 | 5208 |
5212 va_start (vargs, nargs); | 5209 va_start (vargs, nargs); |
5213 for (i = 0; i < nargs; i++) | 5210 for (i = 0; i < nargs; i++) |
5214 args[i] = va_arg (vargs, Lisp_Object); | 5211 args[i] = va_arg (vargs, Lisp_Object); |
5241 | 5238 |
5242 GCPRO1_ARRAY (args, nargs); | 5239 GCPRO1_ARRAY (args, nargs); |
5243 { | 5240 { |
5244 Lisp_Object its_way_too_goddamn_late = | 5241 Lisp_Object its_way_too_goddamn_late = |
5245 call_trapping_problems | 5242 call_trapping_problems |
5246 (class, 0, flags, 0, va_call_trapping_problems_1, | 5243 (class_, 0, flags, 0, va_call_trapping_problems_1, |
5247 &fazer_invocacao_atrapalhando_problemas); | 5244 &fazer_invocacao_atrapalhando_problemas); |
5248 UNGCPRO; | 5245 UNGCPRO; |
5249 if (UNBOUNDP (its_way_too_goddamn_late)) | 5246 if (UNBOUNDP (its_way_too_goddamn_late)) |
5250 return retval; | 5247 return retval; |
5251 else | 5248 else |
6244 return (EQ (level, Qdebug) && !NILP (Vlog_warning_minimum_level) && | 6241 return (EQ (level, Qdebug) && !NILP (Vlog_warning_minimum_level) && |
6245 !EQ (Vlog_warning_minimum_level, Qdebug)); | 6242 !EQ (Vlog_warning_minimum_level, Qdebug)); |
6246 } | 6243 } |
6247 | 6244 |
6248 void | 6245 void |
6249 warn_when_safe_lispobj (Lisp_Object class, Lisp_Object level, | 6246 warn_when_safe_lispobj (Lisp_Object class_, Lisp_Object level, |
6250 Lisp_Object obj) | 6247 Lisp_Object obj) |
6251 { | 6248 { |
6252 if (warning_will_be_discarded (level)) | 6249 if (warning_will_be_discarded (level)) |
6253 return; | 6250 return; |
6254 | 6251 |
6255 obj = list1 (list3 (class, level, obj)); | 6252 obj = list1 (list3 (class_, level, obj)); |
6256 if (NILP (Vpending_warnings)) | 6253 if (NILP (Vpending_warnings)) |
6257 Vpending_warnings = Vpending_warnings_tail = obj; | 6254 Vpending_warnings = Vpending_warnings_tail = obj; |
6258 else | 6255 else |
6259 { | 6256 { |
6260 Fsetcdr (Vpending_warnings_tail, obj); | 6257 Fsetcdr (Vpending_warnings_tail, obj); |
6268 An alternative approach is to just pass some non-string type of | 6265 An alternative approach is to just pass some non-string type of |
6269 Lisp_Object to warn_when_safe_lispobj(); `prin1-to-string' will | 6266 Lisp_Object to warn_when_safe_lispobj(); `prin1-to-string' will |
6270 automatically be called when it is safe to do so. */ | 6267 automatically be called when it is safe to do so. */ |
6271 | 6268 |
6272 void | 6269 void |
6273 warn_when_safe (Lisp_Object class, Lisp_Object level, const CIbyte *fmt, ...) | 6270 warn_when_safe (Lisp_Object class_, Lisp_Object level, const CIbyte *fmt, ...) |
6274 { | 6271 { |
6275 Lisp_Object obj; | 6272 Lisp_Object obj; |
6276 va_list args; | 6273 va_list args; |
6277 | 6274 |
6278 if (warning_will_be_discarded (level)) | 6275 if (warning_will_be_discarded (level)) |
6280 | 6277 |
6281 va_start (args, fmt); | 6278 va_start (args, fmt); |
6282 obj = emacs_vsprintf_string (CGETTEXT (fmt), args); | 6279 obj = emacs_vsprintf_string (CGETTEXT (fmt), args); |
6283 va_end (args); | 6280 va_end (args); |
6284 | 6281 |
6285 warn_when_safe_lispobj (class, level, obj); | 6282 warn_when_safe_lispobj (class_, level, obj); |
6286 } | 6283 } |
6287 | 6284 |
6288 | 6285 |
6289 | 6286 |
6290 | 6287 |
6533 staticpro (&Vcatch_everything_tag); | 6530 staticpro (&Vcatch_everything_tag); |
6534 Vcatch_everything_tag = make_opaque (OPAQUE_CLEAR, 0); | 6531 Vcatch_everything_tag = make_opaque (OPAQUE_CLEAR, 0); |
6535 | 6532 |
6536 staticpro (&Vpending_warnings); | 6533 staticpro (&Vpending_warnings); |
6537 Vpending_warnings = Qnil; | 6534 Vpending_warnings = Qnil; |
6538 dump_add_root_object (&Vpending_warnings_tail); | 6535 dump_add_root_lisp_object (&Vpending_warnings_tail); |
6539 Vpending_warnings_tail = Qnil; | 6536 Vpending_warnings_tail = Qnil; |
6540 | 6537 |
6541 DEFVAR_LISP ("log-warning-minimum-level", &Vlog_warning_minimum_level); | 6538 DEFVAR_LISP ("log-warning-minimum-level", &Vlog_warning_minimum_level); |
6542 Vlog_warning_minimum_level = Qinfo; | 6539 Vlog_warning_minimum_level = Qinfo; |
6543 | 6540 |