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