cleanup of code related to xfree(), better KKCC backtrace capabilities, document XD_INLINE_LISP_OBJECT_BLOCK_PTR, fix some memory leaks, other code cleanup -------------------- ChangeLog entries follow: -------------------- src/ChangeLog addition: 2010-03-24 Ben Wing <ben@xemacs.org> * array.h: * array.h (XD_LISP_DYNARR_DESC): * dumper.c (pdump_register_sub): * dumper.c (pdump_store_new_pointer_offsets): * dumper.c (pdump_reloc_one_mc): * elhash.c: * gc.c (lispdesc_one_description_line_size): * gc.c (kkcc_marking): * lrecord.h: * lrecord.h (IF_NEW_GC): * lrecord.h (enum memory_description_type): * lrecord.h (enum data_description_entry_flags): * lrecord.h (struct opaque_convert_functions): Rename XD_LISP_OBJECT_BLOCK_PTR to XD_INLINE_LISP_OBJECT_BLOCK_PTR and document it in lrecord.h. * data.c: * data.c (finish_marking_weak_lists): * data.c (continue_marking_ephemerons): * data.c (finish_marking_ephemerons): * elhash.c (MARK_OBJ): * gc.c: * gc.c (lispdesc_indirect_count_1): * gc.c (struct): * gc.c (kkcc_bt_push): * gc.c (kkcc_gc_stack_push): * gc.c (kkcc_gc_stack_push_lisp_object): * gc.c (kkcc_gc_stack_repush_dirty_object): * gc.c (KKCC_DO_CHECK_FREE): * gc.c (mark_object_maybe_checking_free): * gc.c (mark_struct_contents): * gc.c (mark_lisp_object_block_contents): * gc.c (register_for_finalization): * gc.c (mark_object): * gc.h: * lisp.h: * profile.c: * profile.c (mark_profiling_info_maphash): Clean up KKCC code related to DEBUG_XEMACS. Rename kkcc_backtrace() to kkcc_backtrace_1() and add two params: a `size' arg to control how many stack elements to print and a `detailed' arg to control whether Lisp objects are printed using `debug_print()'. Create front-ends to kkcc_backtrace_1() -- kkcc_detailed_backtrace(), kkcc_short_backtrace(), kkcc_detailed_backtrace_full(), kkcc_short_backtrace_full(), as well as shortened versions kbt(), kbts(), kbtf(), kbtsf() -- to call it with various parameter values. Add an `is_lisp' field to the stack and backtrace structures and use it to keep track of whether an object pushed onto the stack is a Lisp object or a non-Lisp structure; in kkcc_backtrace_1(), don't try to print a non-Lisp structure as a Lisp object. * elhash.c: * extents.c: * file-coding.c: * lrecord.h: * lrecord.h (IF_NEW_GC): * marker.c: * marker.c (Fmarker_buffer): * mule-coding.c: * number.c: * rangetab.c: * specifier.c: New macros IF_OLD_GC(), IF_NEW_GC() to simplify declaration of Lisp objects when a finalizer may exist in one but not the other. Use them appropriately. * extents.c (finalize_extent_info): Don't zero out data->soe and data->extents before trying to free, else we get memory leaks. * lrecord.h (enum lrecord_type): Make the first lrecord type have value 1 not 0 so that 0 remains without implementation and attempts to interpret zeroed memory as a Lisp object will be more obvious. * array.c (Dynarr_free): * device-msw.c (msprinter_delete_device): * device-tty.c (free_tty_device_struct): * device-tty.c (tty_delete_device): * dialog-msw.c (handle_directory_dialog_box): * dialog-x.c: * emacs.c (free_argc_argv): * emodules.c (attempt_module_delete): * file-coding.c (chain_finalize_coding_stream_1): * file-coding.c (chain_finalize_coding_stream): * glyphs-eimage.c: * glyphs-eimage.c (jpeg_instantiate_unwind): * glyphs-eimage.c (gif_instantiate_unwind): * glyphs-eimage.c (png_instantiate_unwind): * glyphs-eimage.c (tiff_instantiate_unwind): * imgproc.c: * imgproc.c (build_EImage_quantable): * insdel.c (uninit_buffer_text): * mule-coding.c (iso2022_finalize_detection_state): * objects-tty.c (tty_finalize_color_instance): * objects-tty.c (tty_finalize_font_instance): * objects-tty.c (tty_font_list): * process.c: * process.c (finalize_process): * redisplay.c (add_propagation_runes): * scrollbar-gtk.c: * scrollbar-gtk.c (gtk_free_scrollbar_instance): * scrollbar-gtk.c (gtk_release_scrollbar_instance): * scrollbar-msw.c: * scrollbar-msw.c (mswindows_free_scrollbar_instance): * scrollbar-msw.c (unshow_that_mofo): * scrollbar-x.c (x_free_scrollbar_instance): * scrollbar-x.c (x_release_scrollbar_instance): * select-x.c: * select-x.c (x_handle_selection_request): * syntax.c: * syntax.c (uninit_buffer_syntax_cache): * text.h (eifree): If possible, whenever we call xfree() on a field in a structure, set the field to 0 afterwards. A lot of code is written so that it checks the value being freed to see if it is non-zero before freeing it -- doing this and setting the value to 0 afterwards ensures (a) we won't try to free twice if the cleanup code is called twice; (b) if the object itself stays around, KKCC won't crash when attempting to mark the freed field. * rangetab.c: Add a finalization method when not NEW_GC to avoid memory leaks. (#### We still get memory leaks when NEW_GC; need to convert gap array to Lisp object).

@comment  node-name,  next,  previous,  up
@node Search and Replace, , Select and Move, Top
@chapter Searching and Replacing
@cindex searching
@cindex replace
@vindex case-fold-search

   Emacs provides commands for searching for occurrences of a particular
string. The search is incremental i.e. it begins even before you
complete typing the whole string. All searches in Emacs ignore the case
of the text they are searching, i.e. if you are searching for "String",
then "string" will also be one of the selections. If you want a case
sensitive search select the @b{Case Sensitive Search} from the
@b{Option} menu. You can also set the variable @code{case-fold-search} to
@code{nil} for making searches case-sensitive. For information on setting
variables, @xref{Setting Variables}. The two commands for searching for
strings in XEmacs are:

@table @kbd
@item C-s
@findex isearch-forward
@kindex C-s
This command will prompt you for a string to search :

@example
I-search:
@end example

@noindent
If you type "myname" as the string to be searched, then Emacs will start
searching for "m", "my", "myn", etc as you go on typing the whole
string in the forward direction. The cursor will be on the matching
string which has been found so far. If you find the correct match just
hit @key{RET} or type @kbd{C-f} or @kbd{C-b} to set the cursor's
position. If you find a matching string "myname" but you were looking
for a different occurrence of it, use @kbd{C-s} again. If the search is
unable to find the string, it will give you an error message.

@item C-r
@findex isearch-backward
@kindex C-r
This command will perform an incremental search in the backward
direction. It will prompt you for a string name:

@example
I-search backward:
@end example

@noindent
After you start typing the string name, it will search for the string in
the same fashion as it does for @kbd{C-s} except that it will search in
the backward direction. If it cannot find the string name, it will give
you an error message.
@end table

   If you make a mistake while typing the string names when you use the
above commands, you can use the @key{DEL} key to erase characters. Each
@key{DEL} will erase the last character. At any time if you want to quit
the search, just type @kbd{C-g}.

   To do a non-incremental search i.e. to start the search only after
you have typed the whole string you can use the following commands:

@table @kbd
@item C-s RET @dfn{string} RET
This command will search for the specified string in the forward
direction and will give an error message if the string is not found.

@item C-r RET @dfn{string} RET
This command will search for the specified string in the backward
direction.
@end table

  For information on how Emacs searches for words and regular
expressions, @xref{Search,,,xemacs,XEmacs User's Manual}.

  To replace all occurrences of a string in Emacs, you can use the
following command:
@findex replace-string
@example
M-x replace-string
@end example

@noindent
After you type @kbd{M-x replace-string}, you will be prompted for a
string name to replace:

@example
Replace string:
@end example

@noindent
After you type in a string name, for example "FOO" and press @key{RET},
you will see another prompt:

@example
Replace string FOO with:
@end example

@noindent
Now type the string which you want to replace "FOO" with and press
@key{RET}. After all the occurrences are replaced you will see the
message "Done" in the echo area.  If you want only some occurrences of
the string to be replaced, use @kbd{M-x query-replace RET <string> RET
<newstring> RET}. For more information, @xref{Query
Replace,,,xemacs,XEmacs User's Manual}.

   XEmacs also provides a utility for checking spellings. Use @kbd{M-x
ispell-buffer} to check for spellings in the whole buffer. You can also
check the spelling of a word or a region. You can use menus to
check for spellings:

@noindent
Evaluate the expression @code{(load "big-menubar")}. To evaluate this
expression you need to hit the @key{META} or the @key{ESC} key twice and
type in the expression in the echo area before hitting @key{RET}. You
will get an extensive menubar. Select the @b{Spell Check} menu item from
the @b{Utilities} menu for checking spellings.