Mercurial > hg > xemacs-beta
annotate lib-src/hexl.c @ 5169:6c6d78781d59
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).
| author | Ben Wing <ben@xemacs.org> |
|---|---|
| date | Wed, 24 Mar 2010 01:22:51 -0500 |
| parents | abe6d1db359e |
| children | 061f4f90f874 06dd936cde16 |
| rev | line source |
|---|---|
| 428 | 1 /* Synched up with: FSF 19.28. */ |
| 2 | |
| 438 | 3 #include <config.h> |
| 428 | 4 |
| 5 #include <stdio.h> | |
| 6 #include <ctype.h> | |
| 442 | 7 #ifdef WIN32_NATIVE |
| 440 | 8 #include <io.h> |
| 428 | 9 #include <fcntl.h> |
| 10 #endif | |
| 11 | |
| 12 #if __STDC__ || defined(STDC_HEADERS) | |
| 13 #include <stdlib.h> | |
| 442 | 14 #ifdef HAVE_UNISTD_H |
| 428 | 15 #include <unistd.h> |
| 442 | 16 #endif |
| 428 | 17 #include <string.h> |
| 18 #endif | |
| 19 | |
| 20 #define DEFAULT_GROUPING 0x01 | |
| 21 #define DEFAULT_BASE 16 | |
| 22 | |
| 23 #undef TRUE | |
| 24 #undef FALSE | |
| 25 #define TRUE (1) | |
| 26 #define FALSE (0) | |
| 27 | |
| 28 int base = DEFAULT_BASE, un_flag = FALSE, iso_flag = FALSE, endian = 1; | |
| 29 int group_by = DEFAULT_GROUPING; | |
| 30 char *progname; | |
| 31 | |
| 32 void usage (void); | |
| 33 | |
| 34 int | |
| 35 main (int argc, char *argv[]) | |
| 36 { | |
| 37 register long address; | |
| 38 char string[18]; | |
| 39 FILE *fp; | |
| 40 | |
| 41 progname = *argv++; --argc; | |
| 42 | |
| 43 /* | |
| 44 ** -hex hex dump | |
| 45 ** -oct Octal dump | |
| 46 ** -group-by-8-bits | |
| 47 ** -group-by-16-bits | |
| 48 ** -group-by-32-bits | |
| 49 ** -group-by-64-bits | |
| 50 ** -iso iso character set. | |
| 51 ** -big-endian Big Endian | |
| 52 ** -little-endian Little Endian | |
| 53 ** -un || -de from hexl format to binary. | |
| 54 ** -- End switch list. | |
| 55 ** <filename> dump filename | |
| 56 ** - (as filename == stdin) | |
| 57 */ | |
| 58 | |
| 59 while (*argv && *argv[0] == '-' && (*argv)[1]) | |
| 60 { | |
| 61 /* A switch! */ | |
| 62 if (!strcmp (*argv, "--")) | |
| 63 { | |
| 64 --argc; argv++; | |
| 65 break; | |
| 66 } | |
| 67 else if (!strcmp (*argv, "-un") || !strcmp (*argv, "-de")) | |
| 68 { | |
| 69 un_flag = TRUE; | |
| 70 --argc; argv++; | |
| 71 } | |
| 72 else if (!strcmp (*argv, "-hex")) | |
| 73 { | |
| 74 base = 16; | |
| 75 --argc; argv++; | |
| 76 } | |
| 77 else if (!strcmp (*argv, "-iso")) | |
| 78 { | |
| 79 iso_flag = TRUE; | |
| 80 --argc; argv++; | |
| 81 } | |
| 82 else if (!strcmp (*argv, "-oct")) | |
| 83 { | |
| 84 base = 8; | |
| 85 --argc; argv++; | |
| 86 } | |
| 87 else if (!strcmp (*argv, "-big-endian")) | |
| 88 { | |
| 89 endian = 1; | |
| 90 --argc; argv++; | |
| 91 } | |
| 92 else if (!strcmp (*argv, "-little-endian")) | |
| 93 { | |
| 94 endian = 0; | |
| 95 --argc; argv++; | |
| 96 } | |
| 97 else if (!strcmp (*argv, "-group-by-8-bits")) | |
| 98 { | |
| 99 group_by = 0x00; | |
| 100 --argc; argv++; | |
| 101 } | |
| 102 else if (!strcmp (*argv, "-group-by-16-bits")) | |
| 103 { | |
| 104 group_by = 0x01; | |
| 105 --argc; argv++; | |
| 106 } | |
| 107 else if (!strcmp (*argv, "-group-by-32-bits")) | |
| 108 { | |
| 109 group_by = 0x03; | |
| 110 --argc; argv++; | |
| 111 } | |
| 112 else if (!strcmp (*argv, "-group-by-64-bits")) | |
| 113 { | |
| 114 group_by = 0x07; | |
| 115 endian = 0; | |
| 116 --argc; argv++; | |
| 117 } | |
| 118 else | |
| 119 { | |
| 120 (void) fprintf (stderr, "%s: invalid switch: \"%s\".\n", progname, | |
| 121 *argv); | |
| 122 usage (); | |
| 123 } | |
| 124 } | |
| 125 | |
| 126 do | |
| 127 { | |
| 128 if (*argv == NULL) | |
| 129 fp = stdin; | |
| 130 else | |
| 131 { | |
| 132 char *filename = *argv++; | |
| 133 | |
| 134 if (!strcmp (filename, "-")) | |
| 135 fp = stdin; | |
| 136 else if ((fp = fopen (filename, "r")) == NULL) | |
| 137 { | |
| 138 perror (filename); | |
| 139 continue; | |
| 140 } | |
| 141 } | |
| 142 | |
| 143 if (un_flag) | |
| 144 { | |
| 145 char buf[18]; | |
| 146 | |
| 442 | 147 #ifdef WIN32_NATIVE |
| 440 | 148 _setmode (_fileno (stdout), O_BINARY); |
| 428 | 149 #endif |
| 150 for (;;) | |
| 151 { | |
| 442 | 152 register int i, c = 0, d; |
| 428 | 153 |
| 154 #define hexchar(x) (isdigit (x) ? x - '0' : x - 'a' + 10) | |
| 155 | |
| 156 fread (buf, 1, 10, fp); /* skip 10 bytes */ | |
| 157 | |
| 158 for (i=0; i < 16; ++i) | |
| 159 { | |
| 160 if ((c = getc (fp)) == ' ' || c == EOF) | |
| 161 break; | |
| 162 | |
| 163 d = getc (fp); | |
| 164 c = hexchar (c) * 0x10 + hexchar (d); | |
| 165 putchar (c); | |
| 166 | |
| 167 if ((i&group_by) == group_by) | |
| 168 getc (fp); | |
| 169 } | |
| 170 | |
| 171 if (c == ' ') | |
| 172 { | |
| 173 while ((c = getc (fp)) != '\n' && c != EOF) | |
| 174 ; | |
| 175 | |
| 176 if (c == EOF) | |
| 177 break; | |
| 178 } | |
| 179 else | |
| 180 { | |
| 181 if (i < 16) | |
| 182 break; | |
| 183 | |
| 184 fread (buf, 1, 18, fp); /* skip 18 bytes */ | |
| 185 } | |
| 186 } | |
| 187 } | |
| 188 else | |
| 189 { | |
| 442 | 190 #ifdef WIN32_NATIVE |
| 440 | 191 _setmode (_fileno (fp), O_BINARY); |
| 428 | 192 #endif |
| 193 address = 0; | |
| 194 string[0] = ' '; | |
| 195 string[17] = '\0'; | |
| 196 for (;;) | |
| 197 { | |
| 442 | 198 register int i, c = 0; |
| 428 | 199 |
| 200 for (i=0; i < 16; ++i) | |
| 201 { | |
| 202 if ((c = getc (fp)) == EOF) | |
| 203 { | |
| 204 if (!i) | |
| 205 break; | |
| 206 | |
| 207 fputs (" ", stdout); | |
| 208 string[i+1] = '\0'; | |
| 209 } | |
| 210 else | |
| 211 { | |
| 212 if (!i) | |
| 213 (void) printf ("%08lx: ", address); | |
| 214 | |
| 215 if (iso_flag) | |
| 216 string[i+1] = | |
| 217 (c < 0x20 || (c >= 0x7F && c < 0xa0)) ? '.' :c; | |
| 218 else | |
| 219 string[i+1] = (c < 0x20 || c >= 0x7F) ? '.' : c; | |
| 220 | |
| 221 (void) printf ("%02x", c); | |
| 222 } | |
| 223 | |
| 224 if ((i&group_by) == group_by) | |
| 225 putchar (' '); | |
| 226 } | |
| 227 | |
| 228 if (i) | |
| 229 puts (string); | |
| 230 | |
| 231 if (c == EOF) | |
| 232 break; | |
| 233 | |
| 234 address += 0x10; | |
| 235 | |
| 236 } | |
| 237 } | |
| 238 | |
| 239 if (fp != stdin) | |
| 240 (void) fclose (fp); | |
| 241 | |
| 242 } while (*argv != NULL); | |
| 243 return 0; | |
| 244 } | |
| 245 | |
| 246 void | |
| 442 | 247 usage (void) |
| 428 | 248 { |
| 442 | 249 fprintf (stderr, "Usage: %s [-de] [-iso]\n", progname); |
| 428 | 250 exit (1); |
| 251 } |