Mercurial > hg > xemacs-beta
view src/doc.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 | 804517e16990 |
| children | 4542b72c005e |
line wrap: on
line source
/* Record indices of function doc strings stored in a file. Copyright (C) 1985, 1986, 1992, 1993, 1994, 1995 Free Software Foundation, Inc. Copyright (C) 2001, 2002 Ben Wing. This file is part of XEmacs. XEmacs is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. XEmacs is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with XEmacs; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ /* Synched up with: FSF 19.30. */ /* This file has been Mule-ized. */ #include <config.h> #include "lisp.h" #include "buffer.h" #include "bytecode.h" #include "file-coding.h" #include "insdel.h" #include "keymap.h" #include "lstream.h" #include "sysfile.h" Lisp_Object Vinternal_doc_file_name; Lisp_Object QSsubstitute; /* Read and return doc string or instructions from open file descriptor FD at position POSITION. Does not close the file. Returns string; or if error, returns a cons holding the error data to pass to Fsignal. NAME_NONRELOC and NAME_RELOC are only used for the error messages. */ Lisp_Object unparesseuxify_doc_string (int fd, EMACS_INT position, Ibyte *name_nonreloc, Lisp_Object name_reloc, int standard_doc_file) { Ibyte buf[512 * 32 + 1]; Ibyte *buffer = buf; int buffer_size = sizeof (buf); Ibyte *from, *to; REGISTER Ibyte *p = buffer; Lisp_Object return_me; Lisp_Object fdstream = Qnil, instream = Qnil; struct gcpro gcpro1, gcpro2; GCPRO2 (fdstream, instream); if (0 > lseek (fd, position, 0)) { if (name_nonreloc) name_reloc = build_intstring (name_nonreloc); return_me = list3 (build_msg_string ("Position out of range in doc string file"), name_reloc, make_int (position)); goto done; } fdstream = make_filedesc_input_stream (fd, 0, -1, 0); Lstream_set_buffering (XLSTREAM (fdstream), LSTREAM_UNBUFFERED, 0); instream = make_coding_input_stream /* Major trouble if we are too clever when reading byte-code instructions! #### We should have a way of handling escape-quoted elc files (i.e. files with non-ASCII/Latin-1 chars in them). Currently this is "solved" in bytecomp.el by never inserting lazy references in such files. */ (XLSTREAM (fdstream), standard_doc_file ? Qescape_quoted : Qbinary, CODING_DECODE, 0); Lstream_set_buffering (XLSTREAM (instream), LSTREAM_UNBUFFERED, 0); /* Read the doc string into a buffer. Use the fixed buffer BUF if it is big enough; otherwise allocate one. We store the buffer in use in BUFFER and its size in BUFFER_SIZE. */ while (1) { int space_left = buffer_size - (p - buffer); int nread; /* Switch to a bigger buffer if we need one. */ if (space_left == 0) { Ibyte *old_buffer = buffer; if (buffer == buf) { buffer = (Ibyte *) xmalloc (buffer_size *= 2); memcpy (buffer, old_buffer, p - old_buffer); } else buffer = (Ibyte *) xrealloc (buffer, buffer_size *= 2); p += buffer - old_buffer; space_left = buffer_size - (p - buffer); } /* Don't read too much at one go. */ if (space_left > 1024 * 8) space_left = 1024 * 8; nread = Lstream_read (XLSTREAM (instream), p, space_left); if (nread < 0) { return_me = list1 (build_msg_string ("Read error on documentation file")); goto done; } p[nread] = 0; if (!nread) break; { Ibyte *p1 = qxestrchr (p, '\037'); /* End of doc string marker */ if (p1) { *p1 = 0; p = p1; break; } } p += nread; } /* Scan the text and remove quoting with ^A (char code 1). ^A^A becomes ^A, ^A0 becomes a null char, and ^A_ becomes a ^_. */ from = to = buffer; while (from < p) { if (*from != 1 /*^A*/) *to++ = *from++; else { int c = *(++from); from++; switch (c) { case 1: *to++ = c; break; case '0': *to++ = '\0'; break; case '_': *to++ = '\037'; break; default: return_me = list2 (build_msg_string ("Invalid data in documentation file -- ^A followed by weird code"), make_int (c)); goto done; } } } return_me = make_string (buffer, to - buffer); done: if (!NILP (instream)) { Lstream_delete (XLSTREAM (instream)); Lstream_delete (XLSTREAM (fdstream)); } UNGCPRO; if (buffer != buf) /* We must have allocated buffer above */ xfree (buffer); return return_me; } #define string_join(dest, s1, s2) \ memcpy (dest, XSTRING_DATA (s1), XSTRING_LENGTH (s1)); \ memcpy (dest + XSTRING_LENGTH (s1), XSTRING_DATA (s2), \ XSTRING_LENGTH (s2)); \ dest[XSTRING_LENGTH (s1) + XSTRING_LENGTH (s2)] = '\0' /* Extract a doc string from a file. FILEPOS says where to get it. (This could actually be byte code instructions/constants instead of a doc string.) If it is an integer, use that position in the standard DOC file. If it is (FILE . INTEGER), use FILE as the file name and INTEGER as the position in that file. But if INTEGER is negative, make it positive. (A negative integer is used for user variables, so we can distinguish them without actually fetching the doc string.) */ static Lisp_Object get_doc_string (Lisp_Object filepos) { REGISTER int fd; REGISTER Ibyte *name_nonreloc = 0; EMACS_INT position; Lisp_Object file, tem; Lisp_Object name_reloc = Qnil; int standard_doc_file = 0; if (INTP (filepos)) { file = Vinternal_doc_file_name; standard_doc_file = 1; position = XINT (filepos); } else if (CONSP (filepos) && INTP (XCDR (filepos))) { file = XCAR (filepos); position = XINT (XCDR (filepos)); if (position < 0) position = - position; } else return Qnil; if (!STRINGP (file)) return Qnil; /* Put the file name in NAME as a C string. If it is relative, combine it with Vdoc_directory. */ tem = Ffile_name_absolute_p (file); if (NILP (tem)) { Bytecount minsize; /* XEmacs: Move this check here. OK if called during loadup to load byte code instructions. */ if (!STRINGP (Vdoc_directory)) return Qnil; minsize = XSTRING_LENGTH (Vdoc_directory); /* sizeof ("../lib-src/") == 12 */ if (minsize < 12) minsize = 12; name_nonreloc = alloca_ibytes (minsize + XSTRING_LENGTH (file) + 8); string_join (name_nonreloc, Vdoc_directory, file); } else name_reloc = file; fd = qxe_open (name_nonreloc ? name_nonreloc : XSTRING_DATA (name_reloc), O_RDONLY | OPEN_BINARY, 0); if (fd < 0) { #ifndef CANNOT_DUMP if (purify_flag) { /* sizeof ("../lib-src/") == 12 */ name_nonreloc = (Ibyte *) ALLOCA (12 + XSTRING_LENGTH (file) + 8); /* Preparing to dump; DOC file is probably not installed. So check in ../lib-src. */ qxestrcpy (name_nonreloc, (Ibyte *) "../lib-src/"); qxestrcat (name_nonreloc, XSTRING_DATA (file)); fd = qxe_open (name_nonreloc, O_RDONLY | OPEN_BINARY, 0); } #endif /* CANNOT_DUMP */ if (fd < 0) report_file_error ("Cannot open doc string file", name_nonreloc ? build_intstring (name_nonreloc) : name_reloc); } tem = unparesseuxify_doc_string (fd, position, name_nonreloc, name_reloc, standard_doc_file); retry_close (fd); if (!STRINGP (tem)) signal_error_1 (Qinvalid_byte_code, tem); return tem; } /* Get a string from position FILEPOS and pass it through the Lisp reader. We use this for fetching the bytecode string and constants vector of a compiled function from the .elc file. */ Lisp_Object read_doc_string (Lisp_Object filepos) { Lisp_Object string = get_doc_string (filepos); if (!STRINGP (string)) invalid_state ("loading bytecode failed to return string", string); return Fread (string); } DEFUN ("documentation", Fdocumentation, 1, 2, 0, /* Return the documentation string of FUNCTION. Unless a non-nil second argument RAW is given, the string is passed through `substitute-command-keys'. */ (function, raw)) { /* This function can GC */ Lisp_Object fun; Lisp_Object doc; fun = Findirect_function (function); if (SUBRP (fun)) { if (XSUBR (fun)->doc == 0) return Qnil; if ((EMACS_INT) XSUBR (fun)->doc >= 0) doc = build_string (XSUBR (fun)->doc); else doc = get_doc_string (make_int (- (EMACS_INT) XSUBR (fun)->doc)); } else if (COMPILED_FUNCTIONP (fun)) { Lisp_Object tem; Lisp_Compiled_Function *f = XCOMPILED_FUNCTION (fun); if (! (f->flags.documentationp)) return Qnil; tem = compiled_function_documentation (f); if (STRINGP (tem)) doc = tem; else if (NATNUMP (tem) || CONSP (tem)) doc = get_doc_string (tem); else return Qnil; } else if (KEYMAPP (fun)) return build_msg_string ("Prefix command (definition is a keymap of subcommands)."); else if (STRINGP (fun) || VECTORP (fun)) return build_msg_string ("Keyboard macro."); else if (CONSP (fun)) { Lisp_Object funcar = Fcar (fun); if (!SYMBOLP (funcar)) return Fsignal (Qinvalid_function, list1 (fun)); else if (EQ (funcar, Qlambda) || EQ (funcar, Qautoload)) { Lisp_Object tem, tem1; tem1 = Fcdr (Fcdr (fun)); tem = Fcar (tem1); if (STRINGP (tem)) doc = tem; /* Handle a doc reference--but these never come last in the function body, so reject them if they are last. */ else if ((NATNUMP (tem) || CONSP (tem)) && ! NILP (XCDR (tem1))) doc = get_doc_string (tem); else return Qnil; } else if (EQ (funcar, Qmacro)) return Fdocumentation (Fcdr (fun), raw); else goto oops; } else { oops: return Fsignal (Qinvalid_function, list1 (fun)); } if (NILP (raw)) { struct gcpro gcpro1; #ifdef I18N3 Lisp_Object domain = Qnil; if (COMPILED_FUNCTIONP (fun)) domain = compiled_function_domain (XCOMPILED_FUNCTION (fun)); if (NILP (domain)) doc = Fgettext (doc); else doc = Fdgettext (domain, doc); #endif GCPRO1 (doc); doc = Fsubstitute_command_keys (doc); UNGCPRO; } return doc; } DEFUN ("documentation-property", Fdocumentation_property, 2, 3, 0, /* Return the documentation string that is SYMBOL's PROP property. This is like `get', but it can refer to strings stored in the `doc-directory/DOC' file; and if the value is a string, it is passed through `substitute-command-keys'. A non-nil third argument avoids this translation. */ (symbol, prop, raw)) { /* This function can GC */ REGISTER Lisp_Object doc = Qnil; #ifdef I18N3 REGISTER Lisp_Object domain; #endif struct gcpro gcpro1; GCPRO1 (doc); doc = Fget (symbol, prop, Qnil); if (INTP (doc)) doc = get_doc_string (XINT (doc) > 0 ? doc : make_int (- XINT (doc))); else if (CONSP (doc)) doc = get_doc_string (doc); #ifdef I18N3 if (!NILP (doc)) { domain = Fget (symbol, Qvariable_domain, Qnil); if (NILP (domain)) doc = Fgettext (doc); else doc = Fdgettext (domain, doc); } #endif if (NILP (raw) && STRINGP (doc)) doc = Fsubstitute_command_keys (doc); UNGCPRO; return doc; } static void weird_doc (Lisp_Object sym, const CIbyte *weirdness, const CIbyte *type, int pos) { if (!strcmp (weirdness, GETTEXT ("duplicate"))) return; message ("Note: Strange doc (%s) for %s %s @ %d", weirdness, type, XSTRING_DATA (XSYMBOL (sym)->name), pos); } DEFUN ("Snarf-documentation", Fsnarf_documentation, 1, 1, 0, /* Used during Emacs initialization, before dumping runnable Emacs, to find pointers to doc strings stored in `.../lib-src/DOC' and record them in function definitions. One arg, FILENAME, a string which does not include a directory. The file is written to `../lib-src', and later found in `exec-directory' when doc strings are referred to in the dumped Emacs. */ (filename)) { int fd; Ibyte buf[1024 + 1]; REGISTER int filled; REGISTER int pos; REGISTER Ibyte *p, *end; Lisp_Object sym, fun, tem; Ibyte *name; /* This function should not pass the data it's reading through a coding stream. The reason is that the only purpose of this function is to find the file offsets for the documentation of the various functions, not do anything with the documentation itself. If we pass through a coding stream, the pointers will get messed up when we start reading ISO 2022 data because our pointers will reflect internal format, not external format. */ #ifndef CANNOT_DUMP if (!purify_flag) invalid_operation ("Snarf-documentation can only be called in an undumped Emacs", Qunbound); #endif CHECK_STRING (filename); #ifdef CANNOT_DUMP if (!NILP (Vdoc_directory)) { CHECK_STRING (Vdoc_directory); name = alloca_ibytes (XSTRING_LENGTH (filename) + XSTRING_LENGTH (Vdoc_directory) + 1); qxestrcpy (name, XSTRING_DATA (Vdoc_directory)); } else #endif /* CANNOT_DUMP */ { name = alloca_ibytes (XSTRING_LENGTH (filename) + 14); qxestrcpy (name, (Ibyte *) "../lib-src/"); } qxestrcat (name, XSTRING_DATA (filename)); fd = qxe_open (name, O_RDONLY | OPEN_BINARY, 0); if (fd < 0) report_file_error ("Opening doc string file", build_intstring (name)); Vinternal_doc_file_name = filename; filled = 0; pos = 0; while (1) { if (filled < 512) filled += retry_read (fd, &buf[filled], sizeof (buf) - 1 - filled); if (!filled) break; buf[filled] = 0; p = buf; end = buf + (filled < 512 ? filled : filled - 128); while (p != end && *p != '\037') p++; /* p points to ^_Ffunctionname\n or ^_Vvarname\n. */ if (p != end) { end = qxestrchr (p, '\n'); sym = oblookup (Vobarray, p + 2, end - p - 2); if (SYMBOLP (sym)) { Lisp_Object offset = make_int (pos + end + 1 - buf); /* Attach a docstring to a variable */ if (p[1] == 'V') { /* Install file-position as variable-documentation property and make it negative for a user-variable (doc starts with a `*'). */ Lisp_Object old = Fget (sym, Qvariable_documentation, Qzero); if (!ZEROP (old)) { weird_doc (sym, GETTEXT ("duplicate"), GETTEXT ("variable"), pos); /* In the case of duplicate doc file entries, always take the later one. But if the doc is not an int (a string, say) leave it alone. */ if (!INTP (old)) goto weird; } Fput (sym, Qvariable_documentation, ((end[1] == '*') ? make_int (- XINT (offset)) : offset)); } /* Attach a docstring to a function. The type determines where the docstring is stored. */ else if (p[1] == 'F') { fun = indirect_function (sym,0); if (CONSP (fun) && EQ (XCAR (fun), Qmacro)) fun = XCDR (fun); if (UNBOUNDP (fun)) { #if 0 /* There are lots of legitimate cases where this message will appear (e.g. any function that's only defined when MULE is defined, provided that the function is used somewhere in a dumped Lisp file, so that the symbol is interned in the dumped XEmacs), and there's not a lot that can be done to eliminate the warning other than kludges like moving the function to a Mule-only source file, which often results in ugly code. Furthermore, the only point of this warning is to warn you when you have a DEFUN that you forget to DEFSUBR, but the compiler will also warn you, because the DEFUN declares a static object, and the object will be unused -- you'll get something like /src/xemacs/mule/src/abbrev.c:269: warning: `SFexpand_abbrev' defined but not used So I'm disabling this. --ben */ /* May have been #if'ed out or something */ weird_doc (sym, GETTEXT ("not fboundp"), GETTEXT ("function"), pos); #endif goto weird; } else if (SUBRP (fun)) { /* Lisp_Subrs have a slot for it. */ if (XSUBR (fun)->doc) { weird_doc (sym, GETTEXT ("duplicate"), GETTEXT ("subr"), pos); goto weird; } XSUBR (fun)->doc = (char *) (- XINT (offset)); } else if (CONSP (fun)) { /* If it's a lisp form, stick it in the form. */ tem = XCAR (fun); if (EQ (tem, Qlambda) || EQ (tem, Qautoload)) { tem = Fcdr (Fcdr (fun)); if (CONSP (tem) && INTP (XCAR (tem))) { Lisp_Object old = XCAR (tem); if (!ZEROP (old)) { weird_doc (sym, GETTEXT ("duplicate"), (EQ (tem, Qlambda) ? GETTEXT ("lambda") : GETTEXT ("autoload")), pos); /* In the case of duplicate doc file entries, always take the later one. But if the doc is not an int (a string, say) leave it alone. */ if (!INTP (old)) goto weird; } XCAR (tem) = offset; } else if (!CONSP (tem)) { weird_doc (sym, GETTEXT ("!CONSP(tem)"), GETTEXT ("function"), pos); goto cont; } else { /* DOC string is a string not integer 0 */ #if 0 weird_doc (sym, GETTEXT ("!INTP(XCAR(tem))"), GETTEXT ("function"), pos); #endif goto cont; } } else { weird_doc (sym, GETTEXT ("not lambda or autoload"), GETTEXT ("function"), pos); goto cont; } } else if (COMPILED_FUNCTIONP (fun)) { /* Compiled-Function objects sometimes have slots for it. */ Lisp_Compiled_Function *f = XCOMPILED_FUNCTION (fun); /* This compiled-function object must have a slot for the docstring, since we've found a docstring for it. Unless there were multiple definitions of it, and the latter one didn't have any doc, which is a legal if slightly bogus situation, so don't blow up. */ if (! (f->flags.documentationp)) { weird_doc (sym, GETTEXT ("no doc slot"), GETTEXT ("bytecode"), pos); goto weird; } else { Lisp_Object old = compiled_function_documentation (f); if (!ZEROP (old)) { weird_doc (sym, GETTEXT ("duplicate"), GETTEXT ("bytecode"), pos); /* In the case of duplicate doc file entries, always take the later one. But if the doc is not an int (a string, say) leave it alone. */ if (!INTP (old)) goto weird; } set_compiled_function_documentation (f, offset); } } else { /* Otherwise the function is undefined or otherwise weird. Ignore it. */ weird_doc (sym, GETTEXT ("weird function"), GETTEXT ("function"), pos); goto weird; } } else { /* lose: */ signal_error (Qfile_error, "DOC file invalid at position", make_int (pos)); weird: /* goto lose */; } } } cont: pos += end - buf; filled -= end - buf; memmove (buf, end, filled); } retry_close (fd); return Qnil; } #if 1 /* Don't warn about functions whose doc was lost because they were wrapped by advice-freeze.el... */ static int kludgily_ignore_lost_doc_p (Lisp_Object sym) { # define kludge_prefix "ad-Orig-" Lisp_Object name = XSYMBOL (sym)->name; return (XSTRING_LENGTH (name) > (Bytecount) (sizeof (kludge_prefix)) && !qxestrncmp_c (XSTRING_DATA (name), kludge_prefix, sizeof (kludge_prefix) - 1)); # undef kludge_prefix } #else # define kludgily_ignore_lost_doc_p(sym) 0 #endif static int verify_doc_mapper (Lisp_Object sym, void *arg) { Lisp_Object closure = * (Lisp_Object *) arg; if (!NILP (Ffboundp (sym))) { int doc = 0; Lisp_Object fun = XSYMBOL (sym)->function; if (CONSP (fun) && EQ (XCAR (fun), Qmacro)) fun = XCDR (fun); if (SUBRP (fun)) doc = (EMACS_INT) XSUBR (fun)->doc; else if (SYMBOLP (fun)) doc = -1; else if (KEYMAPP (fun)) doc = -1; else if (CONSP (fun)) { Lisp_Object tem = XCAR (fun); if (EQ (tem, Qlambda) || EQ (tem, Qautoload)) { doc = -1; tem = Fcdr (Fcdr (fun)); if (CONSP (tem) && INTP (XCAR (tem))) doc = XINT (XCAR (tem)); } } else if (COMPILED_FUNCTIONP (fun)) { Lisp_Compiled_Function *f = XCOMPILED_FUNCTION (fun); if (! (f->flags.documentationp)) doc = -1; else { Lisp_Object tem = compiled_function_documentation (f); if (INTP (tem)) doc = XINT (tem); } } if (doc == 0 && !kludgily_ignore_lost_doc_p (sym)) { message ("Warning: doc lost for function %s.", XSTRING_DATA (XSYMBOL (sym)->name)); XCDR (closure) = Qt; } } if (!NILP (Fboundp (sym))) { Lisp_Object doc = Fget (sym, Qvariable_documentation, Qnil); if (ZEROP (doc)) { message ("Warning: doc lost for variable %s.", XSTRING_DATA (XSYMBOL (sym)->name)); XCDR (closure) = Qt; } } return 0; /* Never stop */ } DEFUN ("Verify-documentation", Fverify_documentation, 0, 0, 0, /* Used to make sure everything went well with Snarf-documentation. Writes to stderr if not. */ ()) { Lisp_Object closure = Fcons (Qnil, Qnil); struct gcpro gcpro1; GCPRO1 (closure); map_obarray (Vobarray, verify_doc_mapper, &closure); if (!NILP (Fcdr (closure))) message ("\n" "This is usually because some files were preloaded by loaddefs.el or\n" "site-load.el, but were not passed to make-docfile by Makefile.\n"); UNGCPRO; return NILP (Fcdr (closure)) ? Qt : Qnil; } DEFUN ("substitute-command-keys", Fsubstitute_command_keys, 1, 1, 0, /* Substitute key descriptions for command names in STRING. Return a new string which is STRING with substrings of the form \\=\\[COMMAND] replaced by either: a keystroke sequence that will invoke COMMAND, or "M-x COMMAND" if COMMAND is not on any keys. Substrings of the form \\=\\{MAPVAR} are replaced by summaries \(made by `describe-bindings') of the value of MAPVAR, taken as a keymap. Substrings of the form \\=\\<MAPVAR> specify to use the value of MAPVAR as the keymap for future \\=\\[COMMAND] substrings. \\=\\= quotes the following character and is discarded; thus, \\=\\=\\=\\= puts \\=\\= into the output, and \\=\\=\\=\\[ puts \\=\\[ into the output. */ (string)) { /* This function can GC */ Ibyte *buf; int changed = 0; REGISTER Ibyte *strdata; REGISTER Ibyte *bufp; Bytecount strlength; Bytecount idx; Bytecount bsize; Ibyte *new; Lisp_Object tem = Qnil; Lisp_Object keymap = Qnil; Lisp_Object name = Qnil; Ibyte *start; Bytecount length; struct gcpro gcpro1, gcpro2, gcpro3, gcpro4; if (NILP (string)) return Qnil; CHECK_STRING (string); GCPRO4 (string, tem, keymap, name); /* There is the possibility that the string is not destined for a translating stream, and it could be argued that we should do the same thing here as in Fformat(), but there are very few times when this will be the case and many calls to this function would have to have `gettext' calls added. (I18N3) */ string = LISP_GETTEXT (string); /* KEYMAP is either nil (which means search all the active keymaps) or a specified local map (which means search just that and the global map). If non-nil, it might come from Voverriding_local_map, or from a \\<mapname> construct in STRING itself.. */ #if 0 /* FSFmacs */ /* This is really weird and garbagey. If keymap is nil and there's an overriding-local-map, `where-is-internal' will correctly note this, so there's no reason to do it here. Maybe FSFmacs `where-is-internal' is broken. */ /* keymap = current_kboard->Voverriding_terminal_local_map; if (NILP (keymap)) keymap = Voverriding_local_map; */ #endif strlength = XSTRING_LENGTH (string); bsize = 1 + strlength; buf = (Ibyte *) xmalloc (bsize); bufp = buf; /* Have to reset strdata every time GC might be called */ strdata = XSTRING_DATA (string); for (idx = 0; idx < strlength; ) { Ibyte *strp = strdata + idx; if (strp[0] != '\\') { /* just copy other chars */ /* As it happens, this will work with Mule even if the character quoted is multi-byte; the remaining multi-byte characters will just be copied by this loop. */ *bufp++ = *strp; idx++; } else switch (strp[1]) { default: { /* just copy unknown escape sequences */ *bufp++ = *strp; idx++; break; } case '=': { /* \= quotes the next character; thus, to put in \[ without its special meaning, use \=\[. */ /* As it happens, this will work with Mule even if the character quoted is multi-byte; the remaining multi-byte characters will just be copied by this loop. */ changed = 1; *bufp++ = strp[2]; idx += 3; break; } case '[': { changed = 1; idx += 2; /* skip \[ */ strp += 2; start = strp; while ((idx < strlength) && *strp != ']') { strp++; idx++; } length = strp - start; idx++; /* skip ] */ tem = Fintern (make_string (start, length), Qnil); tem = Fwhere_is_internal (tem, keymap, Qt, Qnil, Qnil); #if 0 /* FSFmacs */ /* Disregard menu bar bindings; it is positively annoying to mention them when there's no menu bar, and it isn't terribly useful even when there is a menu bar. */ if (!NILP (tem)) { firstkey = Faref (tem, Qzero); if (EQ (firstkey, Qmenu_bar)) tem = Qnil; } #endif if (NILP (tem)) /* but not on any keys */ { new = (Ibyte *) xrealloc (buf, bsize += 4); bufp += new - buf; buf = new; memcpy (bufp, "M-x ", 4); bufp += 4; goto subst; } else { /* function is on a key */ tem = Fkey_description (tem); goto subst_string; } } case '{': case '<': { Lisp_Object buffer = Fget_buffer_create (QSsubstitute); struct buffer *buf_ = XBUFFER (buffer); Fbuffer_disable_undo (buffer); Ferase_buffer (buffer); /* \{foo} is replaced with a summary of keymap (symbol-value foo). \<foo> just sets the keymap used for \[cmd]. */ changed = 1; idx += 2; /* skip \{ or \< */ strp += 2; start = strp; while ((idx < strlength) && *strp != '}' && *strp != '>') { strp++; idx++; } length = strp - start; idx++; /* skip } or > */ /* Get the value of the keymap in TEM, or nil if undefined. Do this while still in the user's current buffer in case it is a local variable. */ name = Fintern (make_string (start, length), Qnil); tem = Fboundp (name); if (! NILP (tem)) { tem = Fsymbol_value (name); if (! NILP (tem)) tem = get_keymap (tem, 0, 1); } if (NILP (tem)) { buffer_insert_c_string (buf_, "(uses keymap \""); buffer_insert_lisp_string (buf_, Fsymbol_name (name)); buffer_insert_c_string (buf_, "\", which is not currently defined) "); if (start[-1] == '<') keymap = Qnil; } else if (start[-1] == '<') keymap = tem; else describe_map_tree (tem, 1, Qnil, Qnil, 0, buffer); tem = make_string_from_buffer (buf_, BUF_BEG (buf_), BUF_Z (buf_) - BUF_BEG (buf_)); Ferase_buffer (buffer); } goto subst_string; subst_string: start = XSTRING_DATA (tem); length = XSTRING_LENGTH (tem); subst: bsize += length; new = (Ibyte *) xrealloc (buf, bsize); bufp += new - buf; buf = new; memcpy (bufp, start, length); bufp += length; /* Reset STRDATA in case gc relocated it. */ strdata = XSTRING_DATA (string); break; } } if (changed) /* don't bother if nothing substituted */ tem = make_string (buf, bufp - buf); else tem = string; xfree (buf); UNGCPRO; return tem; } /************************************************************************/ /* initialization */ /************************************************************************/ void syms_of_doc (void) { DEFSUBR (Fdocumentation); DEFSUBR (Fdocumentation_property); DEFSUBR (Fsnarf_documentation); DEFSUBR (Fverify_documentation); DEFSUBR (Fsubstitute_command_keys); } void vars_of_doc (void) { DEFVAR_LISP ("internal-doc-file-name", &Vinternal_doc_file_name /* Name of file containing documentation strings of built-in symbols. */ ); Vinternal_doc_file_name = Qnil; QSsubstitute = build_string (" *substitute*"); staticpro (&QSsubstitute); }