Mercurial > hg > xemacs-beta
annotate src/lrecord.h @ 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 | ab9ee10a53e4 |
| children | 5ddbab03b0e6 |
| rev | line source |
|---|---|
| 428 | 1 /* The "lrecord" structure (header of a compound lisp object). |
| 2 Copyright (C) 1993, 1994, 1995 Free Software Foundation, Inc. | |
| 5125 | 3 Copyright (C) 1996, 2001, 2002, 2004, 2005, 2009, 2010 Ben Wing. |
| 428 | 4 |
| 5 This file is part of XEmacs. | |
| 6 | |
| 7 XEmacs is free software; you can redistribute it and/or modify it | |
| 8 under the terms of the GNU General Public License as published by the | |
| 9 Free Software Foundation; either version 2, or (at your option) any | |
| 10 later version. | |
| 11 | |
| 12 XEmacs is distributed in the hope that it will be useful, but WITHOUT | |
| 13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 15 for more details. | |
| 16 | |
| 17 You should have received a copy of the GNU General Public License | |
| 18 along with XEmacs; see the file COPYING. If not, write to | |
| 19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330, | |
| 20 Boston, MA 02111-1307, USA. */ | |
| 21 | |
| 22 /* Synched up with: Not in FSF. */ | |
| 23 | |
| 2367 | 24 /* This file has been Mule-ized, Ben Wing, 10-13-04. */ |
| 25 | |
| 440 | 26 #ifndef INCLUDED_lrecord_h_ |
| 27 #define INCLUDED_lrecord_h_ | |
| 428 | 28 |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
29 /* All objects other than char and int are implemented as structures and |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
30 passed by reference. Such objects are called "record objects" ("record" |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
31 is another term for "structure"). The "wrapped" value of such an object |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
32 (i.e. when stored in a variable of type Lisp_Object) is simply the raw |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
33 pointer coerced to an integral type the same size as the pointer |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
34 (usually `long'). |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
35 |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
36 Under old-GC (i.e. when NEW_GC is not defined), there are two kinds of |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
37 record objects: normal objects (those allocated on their own with |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
38 xmalloc()) and frob-block objects (those allocated as pieces of large, |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
39 usually 2K, chunks of memory known as "frob blocks"). Under NEW_GC, |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
40 there is only one type of record object. Stuff below that applies to |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
41 frob-block objects is assumed to apply to the same type of object as |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
42 normal objects under NEW_GC. |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
43 |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
44 Record objects have a header at the beginning of their structure, which |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
45 is used internally to identify the type of the object (so that an |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
46 object's type can be recovered from its pointer); in addition, it holds |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
47 a few flags and a "UID", which for most objects is shown when it is |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
48 printed, and is primarily useful for debugging purposes. The header of |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
49 a normal object is declared as NORMAL_LISP_OBJECT_HEADER and that of a |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
50 frob-block object FROB_BLOCK_LISP_OBJECT_HEADER. |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
51 |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
52 FROB_BLOCK_LISP_OBJECT_HEADER boils down to a `struct lrecord_header'. |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
53 This is a 32-bit value made up of bit fields, where 8 bits are used to |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
54 hold the type, 2 or 3 bits are used for flags associated with the |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
55 garbage collector, and the remaining 21 or 22 bits hold the UID. |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
56 |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
57 Under NEW_GC, NORMAL_LISP_OBJECT_HEADER also resolves to `struct |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
58 lrecord_header'. Under old-GC, however, NORMAL_LISP_OBJECT_HEADER |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
59 resolves to a `struct old_lcrecord_header' (note the `c'), which is a |
|
5142
f965e31a35f0
reduce lcrecord headers to 2 words, rename printing_unreadable_object
Ben Wing <ben@xemacs.org>
parents:
5128
diff
changeset
|
60 larger structure -- on 32-bit machines it occupies 2 machine words |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
61 instead of 1. Such an object is known internally as an "lcrecord". The |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
62 first word of `struct old_lcrecord_header' is an embedded `struct |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
63 lrecord_header' with the same information as for frob-block objects; |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
64 that way, all objects can be cast to a `struct lrecord_header' to |
|
5142
f965e31a35f0
reduce lcrecord headers to 2 words, rename printing_unreadable_object
Ben Wing <ben@xemacs.org>
parents:
5128
diff
changeset
|
65 determine their type or other info. The other word is a pointer, used |
|
f965e31a35f0
reduce lcrecord headers to 2 words, rename printing_unreadable_object
Ben Wing <ben@xemacs.org>
parents:
5128
diff
changeset
|
66 to thread all lcrecords together in one big linked list. |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
67 |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
68 Under old-GC, normal objects (i.e. lcrecords) are allocated in |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
69 individual chunks using the underlying allocator (i.e. xmalloc(), which |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
70 is a thin wrapper around malloc()). Frob-block objects are more |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
71 efficient than normal objects, as they have a smaller header and don't |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
72 have the additional memory overhead associated with malloc() -- instead, |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
73 as mentioned above, they are carved out of 2K chunks of memory called |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
74 "frob blocks"). However, it is slightly more tricky to create such |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
75 objects, as they require special routines in alloc.c to create an object |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
76 of each such type and to sweep them during garbage collection. In |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
77 addition, there is currently no mechanism for handling variable-sized |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
78 frob-block objects (e.g. vectors), whereas variable-sized normal objects |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
79 are not a problem. Frob-block objects are typically used for basic |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
80 objects that exist in large numbers, such as `cons' or `string'. |
| 2720 | 81 |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
82 Note that strings are an apparent exception to the statement above that |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
83 variable-sized objects can't be handled. Under old-GC strings work as |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
84 follows. A string consists of two parts -- a fixed-size "string header" |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
85 that is allocated as a standard frob-block object, and a "string-chars" |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
86 structure that is allocated out of special 8K-sized frob blocks that |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
87 have a dedicated garbage-collection handler that compacts the blocks |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
88 during the sweep stage, relocating the string-chars data (but not the |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
89 string headers) to eliminate gaps. Strings larger than 8K are not |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
90 placed in frob blocks, but instead are stored as individually malloc()ed |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
91 blocks of memory. Strings larger than 8K are called "big strings" and |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
92 those smaller than 8K are called "small strings". |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
93 |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
94 Under new-GC, there is no difference between big and small strings, |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
95 just as there is no difference between normal and frob-block objects. |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
96 There is only one allocation method, which is capable of handling |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
97 variable-sized objects. This apparently allocates all objects in |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
98 frob blocks according to the size of the object. |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
99 |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
100 To create a new normal Lisp object, see the toolbar-button example |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
101 below. To create a new frob-block Lisp object, follow the lead of |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
102 one of the existing frob-block objects, such as extents or events. |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
103 Note that you do not need to supply all the methods (see below); |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
104 reasonable defaults are provided for many of them. Alternatively, if |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
105 you're just looking for a way of encapsulating data (which possibly |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
106 could contain Lisp_Objects in it), you may well be able to use the |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
107 opaque type. |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
108 */ |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
109 |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
110 /* |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
111 How to declare a Lisp object: |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
112 |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
113 NORMAL_LISP_OBJECT_HEADER: |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
114 Header for normal objects |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
115 |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
116 FROB_BLOCK_LISP_OBJECT_HEADER: |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
117 Header for frob-block objects |
| 428 | 118 |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
119 How to allocate a Lisp object: |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
120 |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
121 - For normal objects of a fixed size, simply call |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
122 ALLOC_NORMAL_LISP_OBJECT (type), where TYPE is the name of the type |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
123 (e.g. toolbar_button). Such objects can be freed manually using |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
124 free_normal_lisp_object. |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
125 |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
126 - For normal objects whose size can vary (and hence which have a |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
127 size_in_bytes_method rather than a static_size), call |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
128 ALLOC_SIZED_LISP_OBJECT (size, type), where TYPE is the |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
129 name of the type. NOTE: You cannot call free_normal_lisp_object() on such |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
130 on object! (At least when not NEW_GC) |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
131 |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
132 - For frob-block objects, use |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
133 ALLOC_FROB_BLOCK_LISP_OBJECT (type, lisp_type, var, lrec_ptr). |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
134 But these objects need special handling; if you don't understand this, |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
135 just ignore it. |
| 428 | 136 |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
137 - Some lrecords, which are used totally internally, use the |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
138 noseeum-* functions for debugging reasons. |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
139 |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
140 Other operations: |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
141 |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
142 - copy_lisp_object (dst, src) |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
143 |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
144 - zero_nonsized_lisp_object (obj), zero_sized_lisp_object (obj, size): |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
145 BUT NOTE, it is not necessary to zero out newly allocated Lisp objects. |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
146 This happens automatically. |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
147 |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
148 - lisp_object_size (obj): Return the size of a Lisp object. NOTE: This |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
149 requires that the object is properly initialized. |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
150 |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
151 - lisp_object_storage_size (obj, stats): Return the storage size of a |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
152 Lisp objcet, including malloc or frob-block overhead; also, if STATS |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
153 is non-NULL, accumulate info about the size and overhead into STATS. |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
154 */ |
|
4930
9f04877ce07e
fix up comments about finalizers and NEWGC internal objects
Ben Wing <ben@xemacs.org>
parents:
4844
diff
changeset
|
155 |
|
9f04877ce07e
fix up comments about finalizers and NEWGC internal objects
Ben Wing <ben@xemacs.org>
parents:
4844
diff
changeset
|
156 #ifdef NEW_GC |
|
9f04877ce07e
fix up comments about finalizers and NEWGC internal objects
Ben Wing <ben@xemacs.org>
parents:
4844
diff
changeset
|
157 /* |
|
9f04877ce07e
fix up comments about finalizers and NEWGC internal objects
Ben Wing <ben@xemacs.org>
parents:
4844
diff
changeset
|
158 There are some limitations under New-GC that lead to the creation of a |
|
9f04877ce07e
fix up comments about finalizers and NEWGC internal objects
Ben Wing <ben@xemacs.org>
parents:
4844
diff
changeset
|
159 large number of new internal object types. I'm not completely sure what |
|
9f04877ce07e
fix up comments about finalizers and NEWGC internal objects
Ben Wing <ben@xemacs.org>
parents:
4844
diff
changeset
|
160 all of them are, but they are at least partially related to limitations |
|
9f04877ce07e
fix up comments about finalizers and NEWGC internal objects
Ben Wing <ben@xemacs.org>
parents:
4844
diff
changeset
|
161 on finalizers. Something else must be going on as well, because |
|
9f04877ce07e
fix up comments about finalizers and NEWGC internal objects
Ben Wing <ben@xemacs.org>
parents:
4844
diff
changeset
|
162 non-dumpable, non-finalizable objects like devices and frames also have |
|
9f04877ce07e
fix up comments about finalizers and NEWGC internal objects
Ben Wing <ben@xemacs.org>
parents:
4844
diff
changeset
|
163 their window-system-specific substructures converted into Lisp objects. |
|
9f04877ce07e
fix up comments about finalizers and NEWGC internal objects
Ben Wing <ben@xemacs.org>
parents:
4844
diff
changeset
|
164 It must have something to do with the fact that these substructures |
|
9f04877ce07e
fix up comments about finalizers and NEWGC internal objects
Ben Wing <ben@xemacs.org>
parents:
4844
diff
changeset
|
165 contain pointers to Lisp objects, but it's not completely clear why -- |
|
9f04877ce07e
fix up comments about finalizers and NEWGC internal objects
Ben Wing <ben@xemacs.org>
parents:
4844
diff
changeset
|
166 object descriptions exist to indicate the size of these structures and |
|
9f04877ce07e
fix up comments about finalizers and NEWGC internal objects
Ben Wing <ben@xemacs.org>
parents:
4844
diff
changeset
|
167 the Lisp object pointers within them. |
|
9f04877ce07e
fix up comments about finalizers and NEWGC internal objects
Ben Wing <ben@xemacs.org>
parents:
4844
diff
changeset
|
168 |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
169 At least one definite issue is that under New-GC dumpable objects cannot |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
170 contain any finalizers (see pdump_register_object()). This means that |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
171 any substructures in dumpable objects that are allocated separately and |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
172 normally freed in a finalizer need instead to be made into actual Lisp |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
173 objects. If those structures are Dynarrs, they need to be made into |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
174 Dynarr Lisp objects (e.g. face-cachel-dynarr or glyph-cachel-dynarr), |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
175 which are created using Dynarr_lisp_new() or Dynarr_new_new2(). |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
176 Furthermore, the objects contained in the Dynarr also need to be Lisp |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
177 objects (e.g. face-cachel or glyph-cachel). |
|
4930
9f04877ce07e
fix up comments about finalizers and NEWGC internal objects
Ben Wing <ben@xemacs.org>
parents:
4844
diff
changeset
|
178 |
|
9f04877ce07e
fix up comments about finalizers and NEWGC internal objects
Ben Wing <ben@xemacs.org>
parents:
4844
diff
changeset
|
179 --ben |
|
9f04877ce07e
fix up comments about finalizers and NEWGC internal objects
Ben Wing <ben@xemacs.org>
parents:
4844
diff
changeset
|
180 */ |
|
9f04877ce07e
fix up comments about finalizers and NEWGC internal objects
Ben Wing <ben@xemacs.org>
parents:
4844
diff
changeset
|
181 #endif |
|
9f04877ce07e
fix up comments about finalizers and NEWGC internal objects
Ben Wing <ben@xemacs.org>
parents:
4844
diff
changeset
|
182 |
| 3263 | 183 #ifdef NEW_GC |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
184 #define ALLOC_NORMAL_LISP_OBJECT(type) alloc_lrecord (&lrecord_##type) |
|
5117
3742ea8250b5
Checking in final CVS version of workspace 'ben-lisp-object'
Ben Wing <ben@xemacs.org>
parents:
3063
diff
changeset
|
185 #define ALLOC_SIZED_LISP_OBJECT(size, type) \ |
|
3742ea8250b5
Checking in final CVS version of workspace 'ben-lisp-object'
Ben Wing <ben@xemacs.org>
parents:
3063
diff
changeset
|
186 alloc_sized_lrecord (size, &lrecord_##type) |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
187 #define NORMAL_LISP_OBJECT_HEADER struct lrecord_header |
|
5120
d1247f3cc363
latest work on lisp-object workspace;
Ben Wing <ben@xemacs.org>
parents:
5118
diff
changeset
|
188 #define FROB_BLOCK_LISP_OBJECT_HEADER struct lrecord_header |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
189 #define LISP_OBJECT_FROB_BLOCK_P(obj) 0 |
|
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
Ben Wing <ben@xemacs.org>
parents:
5160
diff
changeset
|
190 #define IF_NEW_GC(x) x |
|
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
Ben Wing <ben@xemacs.org>
parents:
5160
diff
changeset
|
191 #define IF_OLD_GC(x) 0 |
| 3263 | 192 #else /* not NEW_GC */ |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
193 #define ALLOC_NORMAL_LISP_OBJECT(type) alloc_automanaged_lcrecord (&lrecord_##type) |
|
5117
3742ea8250b5
Checking in final CVS version of workspace 'ben-lisp-object'
Ben Wing <ben@xemacs.org>
parents:
3063
diff
changeset
|
194 #define ALLOC_SIZED_LISP_OBJECT(size, type) \ |
|
3742ea8250b5
Checking in final CVS version of workspace 'ben-lisp-object'
Ben Wing <ben@xemacs.org>
parents:
3063
diff
changeset
|
195 old_alloc_sized_lcrecord (size, &lrecord_##type) |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
196 #define NORMAL_LISP_OBJECT_HEADER struct old_lcrecord_header |
|
5120
d1247f3cc363
latest work on lisp-object workspace;
Ben Wing <ben@xemacs.org>
parents:
5118
diff
changeset
|
197 #define FROB_BLOCK_LISP_OBJECT_HEADER struct lrecord_header |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
198 #define LISP_OBJECT_FROB_BLOCK_P(obj) (XRECORD_LHEADER_IMPLEMENTATION(obj)->frob_block_p) |
|
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
Ben Wing <ben@xemacs.org>
parents:
5160
diff
changeset
|
199 #define IF_NEW_GC(x) 0 |
|
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
Ben Wing <ben@xemacs.org>
parents:
5160
diff
changeset
|
200 #define IF_OLD_GC(x) x |
| 3263 | 201 #endif /* not NEW_GC */ |
| 3024 | 202 |
|
5146
88bd4f3ef8e4
make lrecord UID's have a separate UID space for each object, resurrect debug SOE code in extents.c
Ben Wing <ben@xemacs.org>
parents:
5142
diff
changeset
|
203 #define LISP_OBJECT_UID(obj) (XRECORD_LHEADER (obj)->uid) |
|
88bd4f3ef8e4
make lrecord UID's have a separate UID space for each object, resurrect debug SOE code in extents.c
Ben Wing <ben@xemacs.org>
parents:
5142
diff
changeset
|
204 |
| 1743 | 205 BEGIN_C_DECLS |
| 1650 | 206 |
| 428 | 207 struct lrecord_header |
| 208 { | |
| 1204 | 209 /* Index into lrecord_implementations_table[]. Objects that have been |
| 210 explicitly freed using e.g. free_cons() have lrecord_type_free in this | |
| 211 field. */ | |
| 442 | 212 unsigned int type :8; |
| 213 | |
| 3263 | 214 #ifdef NEW_GC |
| 2720 | 215 /* 1 if the object is readonly from lisp */ |
| 216 unsigned int lisp_readonly :1; | |
| 217 | |
| 218 /* The `free' field is a flag that indicates whether this lrecord | |
| 219 is currently free or not. This is used for error checking and | |
| 220 debugging. */ | |
| 221 unsigned int free :1; | |
| 222 | |
| 3063 | 223 /* The `uid' field is just for debugging/printing convenience. Having |
| 224 this slot doesn't hurt us spacewise, since the bits are unused | |
| 225 anyway. (The bits are used for strings, though.) */ | |
| 2720 | 226 unsigned int uid :22; |
| 227 | |
| 3263 | 228 #else /* not NEW_GC */ |
| 442 | 229 /* If `mark' is 0 after the GC mark phase, the object will be freed |
| 230 during the GC sweep phase. There are 2 ways that `mark' can be 1: | |
| 231 - by being referenced from other objects during the GC mark phase | |
| 232 - because it is permanently on, for c_readonly objects */ | |
| 233 unsigned int mark :1; | |
| 234 | |
| 235 /* 1 if the object resides in logically read-only space, and does not | |
| 236 reference other non-c_readonly objects. | |
| 237 Invariant: if (c_readonly == 1), then (mark == 1 && lisp_readonly == 1) */ | |
| 238 unsigned int c_readonly :1; | |
| 239 | |
| 428 | 240 /* 1 if the object is readonly from lisp */ |
| 442 | 241 unsigned int lisp_readonly :1; |
| 771 | 242 |
|
5142
f965e31a35f0
reduce lcrecord headers to 2 words, rename printing_unreadable_object
Ben Wing <ben@xemacs.org>
parents:
5128
diff
changeset
|
243 /* The `free' field is currently used only for lcrecords under old-GC. |
|
f965e31a35f0
reduce lcrecord headers to 2 words, rename printing_unreadable_object
Ben Wing <ben@xemacs.org>
parents:
5128
diff
changeset
|
244 It is a flag that indicates whether this lcrecord is on a "free list". |
|
f965e31a35f0
reduce lcrecord headers to 2 words, rename printing_unreadable_object
Ben Wing <ben@xemacs.org>
parents:
5128
diff
changeset
|
245 Free lists are used to minimize the number of calls to malloc() when |
|
f965e31a35f0
reduce lcrecord headers to 2 words, rename printing_unreadable_object
Ben Wing <ben@xemacs.org>
parents:
5128
diff
changeset
|
246 we're repeatedly allocating and freeing a number of the same sort of |
|
f965e31a35f0
reduce lcrecord headers to 2 words, rename printing_unreadable_object
Ben Wing <ben@xemacs.org>
parents:
5128
diff
changeset
|
247 lcrecord. Lcrecords on a free list always get marked in a different |
|
f965e31a35f0
reduce lcrecord headers to 2 words, rename printing_unreadable_object
Ben Wing <ben@xemacs.org>
parents:
5128
diff
changeset
|
248 fashion, so we can use this flag as a sanity check to make sure that |
|
f965e31a35f0
reduce lcrecord headers to 2 words, rename printing_unreadable_object
Ben Wing <ben@xemacs.org>
parents:
5128
diff
changeset
|
249 free lists only have freed lcrecords and there are no freed lcrecords |
|
f965e31a35f0
reduce lcrecord headers to 2 words, rename printing_unreadable_object
Ben Wing <ben@xemacs.org>
parents:
5128
diff
changeset
|
250 elsewhere. */ |
|
f965e31a35f0
reduce lcrecord headers to 2 words, rename printing_unreadable_object
Ben Wing <ben@xemacs.org>
parents:
5128
diff
changeset
|
251 unsigned int free :1; |
|
f965e31a35f0
reduce lcrecord headers to 2 words, rename printing_unreadable_object
Ben Wing <ben@xemacs.org>
parents:
5128
diff
changeset
|
252 |
| 3063 | 253 /* The `uid' field is just for debugging/printing convenience. Having |
| 254 this slot doesn't hurt us spacewise, since the bits are unused | |
| 255 anyway. (The bits are used for strings, though.) */ | |
|
5142
f965e31a35f0
reduce lcrecord headers to 2 words, rename printing_unreadable_object
Ben Wing <ben@xemacs.org>
parents:
5128
diff
changeset
|
256 unsigned int uid :20; |
| 934 | 257 |
| 3263 | 258 #endif /* not NEW_GC */ |
| 428 | 259 }; |
| 260 | |
| 261 struct lrecord_implementation; | |
| 442 | 262 int lrecord_type_index (const struct lrecord_implementation *implementation); |
|
5146
88bd4f3ef8e4
make lrecord UID's have a separate UID space for each object, resurrect debug SOE code in extents.c
Ben Wing <ben@xemacs.org>
parents:
5142
diff
changeset
|
263 extern int lrecord_uid_counter[]; |
| 428 | 264 |
| 3263 | 265 #ifdef NEW_GC |
|
5146
88bd4f3ef8e4
make lrecord UID's have a separate UID space for each object, resurrect debug SOE code in extents.c
Ben Wing <ben@xemacs.org>
parents:
5142
diff
changeset
|
266 #define set_lheader_implementation(header,imp) do { \ |
|
88bd4f3ef8e4
make lrecord UID's have a separate UID space for each object, resurrect debug SOE code in extents.c
Ben Wing <ben@xemacs.org>
parents:
5142
diff
changeset
|
267 struct lrecord_header* SLI_header = (header); \ |
|
88bd4f3ef8e4
make lrecord UID's have a separate UID space for each object, resurrect debug SOE code in extents.c
Ben Wing <ben@xemacs.org>
parents:
5142
diff
changeset
|
268 SLI_header->type = (imp)->lrecord_type_index; \ |
|
88bd4f3ef8e4
make lrecord UID's have a separate UID space for each object, resurrect debug SOE code in extents.c
Ben Wing <ben@xemacs.org>
parents:
5142
diff
changeset
|
269 SLI_header->lisp_readonly = 0; \ |
|
88bd4f3ef8e4
make lrecord UID's have a separate UID space for each object, resurrect debug SOE code in extents.c
Ben Wing <ben@xemacs.org>
parents:
5142
diff
changeset
|
270 SLI_header->free = 0; \ |
|
88bd4f3ef8e4
make lrecord UID's have a separate UID space for each object, resurrect debug SOE code in extents.c
Ben Wing <ben@xemacs.org>
parents:
5142
diff
changeset
|
271 SLI_header->uid = lrecord_uid_counter[(imp)->lrecord_type_index]++; \ |
| 2720 | 272 } while (0) |
| 3263 | 273 #else /* not NEW_GC */ |
|
5146
88bd4f3ef8e4
make lrecord UID's have a separate UID space for each object, resurrect debug SOE code in extents.c
Ben Wing <ben@xemacs.org>
parents:
5142
diff
changeset
|
274 #define set_lheader_implementation(header,imp) do { \ |
|
88bd4f3ef8e4
make lrecord UID's have a separate UID space for each object, resurrect debug SOE code in extents.c
Ben Wing <ben@xemacs.org>
parents:
5142
diff
changeset
|
275 struct lrecord_header* SLI_header = (header); \ |
|
88bd4f3ef8e4
make lrecord UID's have a separate UID space for each object, resurrect debug SOE code in extents.c
Ben Wing <ben@xemacs.org>
parents:
5142
diff
changeset
|
276 SLI_header->type = (imp)->lrecord_type_index; \ |
|
88bd4f3ef8e4
make lrecord UID's have a separate UID space for each object, resurrect debug SOE code in extents.c
Ben Wing <ben@xemacs.org>
parents:
5142
diff
changeset
|
277 SLI_header->mark = 0; \ |
|
88bd4f3ef8e4
make lrecord UID's have a separate UID space for each object, resurrect debug SOE code in extents.c
Ben Wing <ben@xemacs.org>
parents:
5142
diff
changeset
|
278 SLI_header->c_readonly = 0; \ |
|
88bd4f3ef8e4
make lrecord UID's have a separate UID space for each object, resurrect debug SOE code in extents.c
Ben Wing <ben@xemacs.org>
parents:
5142
diff
changeset
|
279 SLI_header->lisp_readonly = 0; \ |
|
88bd4f3ef8e4
make lrecord UID's have a separate UID space for each object, resurrect debug SOE code in extents.c
Ben Wing <ben@xemacs.org>
parents:
5142
diff
changeset
|
280 SLI_header->free = 0; \ |
|
88bd4f3ef8e4
make lrecord UID's have a separate UID space for each object, resurrect debug SOE code in extents.c
Ben Wing <ben@xemacs.org>
parents:
5142
diff
changeset
|
281 SLI_header->uid = lrecord_uid_counter[(imp)->lrecord_type_index]++; \ |
| 428 | 282 } while (0) |
| 3263 | 283 #endif /* not NEW_GC */ |
| 428 | 284 |
| 3263 | 285 #ifndef NEW_GC |
| 3024 | 286 struct old_lcrecord_header |
| 428 | 287 { |
| 288 struct lrecord_header lheader; | |
| 289 | |
| 442 | 290 /* The `next' field is normally used to chain all lcrecords together |
| 428 | 291 so that the GC can find (and free) all of them. |
|
5117
3742ea8250b5
Checking in final CVS version of workspace 'ben-lisp-object'
Ben Wing <ben@xemacs.org>
parents:
3063
diff
changeset
|
292 `old_alloc_sized_lcrecord' threads lcrecords together. |
| 428 | 293 |
| 294 The `next' field may be used for other purposes as long as some | |
| 295 other mechanism is provided for letting the GC do its work. | |
| 296 | |
| 297 For example, the event and marker object types allocate members | |
| 298 out of memory chunks, and are able to find all unmarked members | |
| 299 by sweeping through the elements of the list of chunks. */ | |
| 3024 | 300 struct old_lcrecord_header *next; |
| 428 | 301 }; |
| 302 | |
| 303 /* Used for lcrecords in an lcrecord-list. */ | |
| 304 struct free_lcrecord_header | |
| 305 { | |
| 3024 | 306 struct old_lcrecord_header lcheader; |
| 428 | 307 Lisp_Object chain; |
| 308 }; | |
| 3263 | 309 #endif /* not NEW_GC */ |
| 428 | 310 |
| 3931 | 311 /* DON'T FORGET to update .gdbinit.in if you change this list. */ |
| 442 | 312 enum lrecord_type |
| 313 { | |
| 314 /* Symbol value magic types come first to make SYMBOL_VALUE_MAGIC_P fast. | |
| 315 #### This should be replaced by a symbol_value_magic_p flag | |
| 316 in the Lisp_Symbol lrecord_header. */ | |
|
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
Ben Wing <ben@xemacs.org>
parents:
5160
diff
changeset
|
317 /* Don't assign any type to 0, so in case we come across zeroed memory |
|
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
Ben Wing <ben@xemacs.org>
parents:
5160
diff
changeset
|
318 it will be more obvious when printed */ |
|
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
Ben Wing <ben@xemacs.org>
parents:
5160
diff
changeset
|
319 lrecord_type_symbol_value_forward = 1, |
| 3092 | 320 lrecord_type_symbol_value_varalias, |
| 321 lrecord_type_symbol_value_lisp_magic, | |
| 322 lrecord_type_symbol_value_buffer_local, | |
| 442 | 323 lrecord_type_max_symbol_value_magic = lrecord_type_symbol_value_buffer_local, |
| 3092 | 324 lrecord_type_symbol, |
| 325 lrecord_type_subr, | |
|
4677
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3931
diff
changeset
|
326 lrecord_type_multiple_value, |
| 3092 | 327 lrecord_type_cons, |
| 328 lrecord_type_vector, | |
| 329 lrecord_type_string, | |
| 3263 | 330 #ifndef NEW_GC |
| 442 | 331 lrecord_type_lcrecord_list, |
| 3263 | 332 #endif /* not NEW_GC */ |
| 3092 | 333 lrecord_type_compiled_function, |
| 334 lrecord_type_weak_list, | |
| 335 lrecord_type_bit_vector, | |
| 336 lrecord_type_float, | |
| 337 lrecord_type_hash_table, | |
| 338 lrecord_type_lstream, | |
| 339 lrecord_type_process, | |
| 340 lrecord_type_charset, | |
| 341 lrecord_type_coding_system, | |
| 342 lrecord_type_char_table, | |
| 343 lrecord_type_char_table_entry, | |
| 344 lrecord_type_range_table, | |
| 345 lrecord_type_opaque, | |
| 346 lrecord_type_opaque_ptr, | |
| 347 lrecord_type_buffer, | |
| 348 lrecord_type_extent, | |
| 349 lrecord_type_extent_info, | |
| 350 lrecord_type_extent_auxiliary, | |
| 351 lrecord_type_marker, | |
| 352 lrecord_type_event, | |
| 2720 | 353 #ifdef EVENT_DATA_AS_OBJECTS /* not defined */ |
| 934 | 354 lrecord_type_key_data, |
| 355 lrecord_type_button_data, | |
| 356 lrecord_type_motion_data, | |
| 357 lrecord_type_process_data, | |
| 358 lrecord_type_timeout_data, | |
| 359 lrecord_type_eval_data, | |
| 360 lrecord_type_misc_user_data, | |
| 361 lrecord_type_magic_eval_data, | |
| 362 lrecord_type_magic_data, | |
| 1204 | 363 #endif /* EVENT_DATA_AS_OBJECTS */ |
| 3092 | 364 lrecord_type_keymap, |
| 365 lrecord_type_command_builder, | |
| 366 lrecord_type_timeout, | |
| 367 lrecord_type_specifier, | |
| 368 lrecord_type_console, | |
| 369 lrecord_type_device, | |
| 370 lrecord_type_frame, | |
| 371 lrecord_type_window, | |
| 372 lrecord_type_window_mirror, | |
| 373 lrecord_type_gui_item, | |
| 374 lrecord_type_toolbar_button, | |
| 375 lrecord_type_scrollbar_instance, | |
| 376 lrecord_type_color_instance, | |
| 377 lrecord_type_font_instance, | |
| 378 lrecord_type_image_instance, | |
| 379 lrecord_type_glyph, | |
| 380 lrecord_type_face, | |
| 3931 | 381 lrecord_type_fc_config, |
| 3094 | 382 lrecord_type_fc_pattern, |
| 3092 | 383 lrecord_type_database, |
| 384 lrecord_type_tooltalk_message, | |
| 385 lrecord_type_tooltalk_pattern, | |
| 386 lrecord_type_ldap, | |
| 387 lrecord_type_pgconn, | |
| 388 lrecord_type_pgresult, | |
| 389 lrecord_type_devmode, | |
| 390 lrecord_type_mswindows_dialog_id, | |
| 391 lrecord_type_case_table, | |
| 392 lrecord_type_emacs_ffi, | |
| 393 lrecord_type_emacs_gtk_object, | |
| 394 lrecord_type_emacs_gtk_boxed, | |
| 395 lrecord_type_weak_box, | |
| 396 lrecord_type_ephemeron, | |
| 397 lrecord_type_bignum, | |
| 398 lrecord_type_ratio, | |
| 399 lrecord_type_bigfloat, | |
| 3263 | 400 #ifndef NEW_GC |
| 454 | 401 lrecord_type_free, /* only used for "free" lrecords */ |
| 402 lrecord_type_undefined, /* only used for debugging */ | |
| 3263 | 403 #endif /* not NEW_GC */ |
| 3092 | 404 #ifdef NEW_GC |
|
4930
9f04877ce07e
fix up comments about finalizers and NEWGC internal objects
Ben Wing <ben@xemacs.org>
parents:
4844
diff
changeset
|
405 /* See comment up top explaining why these extra object types must exist. */ |
| 3092 | 406 lrecord_type_string_indirect_data, |
| 407 lrecord_type_string_direct_data, | |
| 408 lrecord_type_hash_table_entry, | |
| 409 lrecord_type_syntax_cache, | |
| 410 lrecord_type_buffer_text, | |
| 411 lrecord_type_compiled_function_args, | |
| 412 lrecord_type_tty_console, | |
| 413 lrecord_type_stream_console, | |
| 414 lrecord_type_dynarr, | |
| 415 lrecord_type_face_cachel, | |
| 416 lrecord_type_face_cachel_dynarr, | |
| 417 lrecord_type_glyph_cachel, | |
| 418 lrecord_type_glyph_cachel_dynarr, | |
| 419 lrecord_type_x_device, | |
| 420 lrecord_type_gtk_device, | |
| 421 lrecord_type_tty_device, | |
| 422 lrecord_type_mswindows_device, | |
| 423 lrecord_type_msprinter_device, | |
| 424 lrecord_type_x_frame, | |
| 425 lrecord_type_gtk_frame, | |
| 426 lrecord_type_mswindows_frame, | |
| 427 lrecord_type_gap_array_marker, | |
| 428 lrecord_type_gap_array, | |
| 429 lrecord_type_extent_list_marker, | |
| 430 lrecord_type_extent_list, | |
| 431 lrecord_type_stack_of_extents, | |
| 432 lrecord_type_tty_color_instance_data, | |
| 433 lrecord_type_tty_font_instance_data, | |
| 434 lrecord_type_specifier_caching, | |
| 435 lrecord_type_expose_ignore, | |
| 436 #endif /* NEW_GC */ | |
| 437 lrecord_type_last_built_in_type /* must be last */ | |
| 442 | 438 }; |
| 439 | |
| 1632 | 440 extern MODULE_API int lrecord_type_count; |
| 428 | 441 |
| 442 struct lrecord_implementation | |
| 443 { | |
| 2367 | 444 const Ascbyte *name; |
| 442 | 445 |
| 934 | 446 /* information for the dumper: is the object dumpable and should it |
| 447 be dumped. */ | |
| 448 unsigned int dumpable :1; | |
| 449 | |
| 442 | 450 /* `marker' is called at GC time, to make sure that all Lisp_Objects |
| 428 | 451 pointed to by this object get properly marked. It should call |
| 452 the mark_object function on all Lisp_Objects in the object. If | |
| 453 the return value is non-nil, it should be a Lisp_Object to be | |
| 454 marked (don't call the mark_object function explicitly on it, | |
| 455 because the GC routines will do this). Doing it this way reduces | |
| 456 recursion, so the object returned should preferably be the one | |
| 457 with the deepest level of Lisp_Object pointers. This function | |
| 1204 | 458 can be NULL, meaning no GC marking is necessary. |
| 459 | |
| 460 NOTE NOTE NOTE: This is not used by KKCC (which uses the data | |
| 461 description below instead), unless the data description is missing. | |
| 462 Yes, this currently means there is logic duplication. Eventually the | |
| 463 mark methods will be removed. */ | |
| 428 | 464 Lisp_Object (*marker) (Lisp_Object); |
| 442 | 465 |
|
5124
623d57b7fbe8
separate regular and disksave finalization, print method fixes.
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
466 /* `printer' converts the object to a printed representation. `printer' |
|
623d57b7fbe8
separate regular and disksave finalization, print method fixes.
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
467 should never be NULL (if so, you will get an assertion failure when |
|
623d57b7fbe8
separate regular and disksave finalization, print method fixes.
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
468 trying to print such an object). Either supply a specific printing |
|
623d57b7fbe8
separate regular and disksave finalization, print method fixes.
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
469 method, or use the default methods internal_object_printer() (for |
|
623d57b7fbe8
separate regular and disksave finalization, print method fixes.
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
470 internal objects that should not be visible at Lisp level) or |
|
623d57b7fbe8
separate regular and disksave finalization, print method fixes.
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
471 external_object_printer() (for objects visible at Lisp level). */ |
| 428 | 472 void (*printer) (Lisp_Object, Lisp_Object printcharfun, int escapeflag); |
| 442 | 473 |
|
5124
623d57b7fbe8
separate regular and disksave finalization, print method fixes.
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
474 /* `finalizer' is called at GC time when the object is about to be freed. |
|
623d57b7fbe8
separate regular and disksave finalization, print method fixes.
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
475 It should perform any necessary cleanup, such as freeing malloc()ed |
|
623d57b7fbe8
separate regular and disksave finalization, print method fixes.
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
476 memory or releasing pointers or handles to objects created in external |
|
623d57b7fbe8
separate regular and disksave finalization, print method fixes.
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
477 libraries, such as window-system windows or file handles. This can be |
|
623d57b7fbe8
separate regular and disksave finalization, print method fixes.
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
478 NULL, meaning no special finalization is necessary. */ |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
479 void (*finalizer) (Lisp_Object obj); |
| 442 | 480 |
| 428 | 481 /* This can be NULL, meaning compare objects with EQ(). */ |
|
4906
6ef8256a020a
implement equalp in C, fix case-folding, add equal() method for keymaps
Ben Wing <ben@xemacs.org>
parents:
4844
diff
changeset
|
482 int (*equal) (Lisp_Object obj1, Lisp_Object obj2, int depth, |
|
6ef8256a020a
implement equalp in C, fix case-folding, add equal() method for keymaps
Ben Wing <ben@xemacs.org>
parents:
4844
diff
changeset
|
483 int foldcase); |
| 442 | 484 |
| 485 /* `hash' generates hash values for use with hash tables that have | |
| 486 `equal' as their test function. This can be NULL, meaning use | |
| 487 the Lisp_Object itself as the hash. But, you must still satisfy | |
| 488 the constraint that if two objects are `equal', then they *must* | |
| 489 hash to the same value in order for hash tables to work properly. | |
| 490 This means that `hash' can be NULL only if the `equal' method is | |
| 491 also NULL. */ | |
| 2515 | 492 Hashcode (*hash) (Lisp_Object, int); |
| 428 | 493 |
| 1204 | 494 /* Data layout description for your object. See long comment below. */ |
| 495 const struct memory_description *description; | |
| 428 | 496 |
|
5117
3742ea8250b5
Checking in final CVS version of workspace 'ben-lisp-object'
Ben Wing <ben@xemacs.org>
parents:
3063
diff
changeset
|
497 /* Only one of `static_size' and `size_in_bytes_method' is non-0. If |
|
3742ea8250b5
Checking in final CVS version of workspace 'ben-lisp-object'
Ben Wing <ben@xemacs.org>
parents:
3063
diff
changeset
|
498 `static_size' is 0, this type is not instantiable by |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
499 ALLOC_NORMAL_LISP_OBJECT(). If both are 0 (this should never happen), |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
500 this object cannot be instantiated; you will get an abort() if you |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
501 try.*/ |
| 665 | 502 Bytecount static_size; |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
503 Bytecount (*size_in_bytes_method) (Lisp_Object); |
| 442 | 504 |
| 505 /* The (constant) index into lrecord_implementations_table */ | |
| 506 enum lrecord_type lrecord_type_index; | |
| 507 | |
| 3263 | 508 #ifndef NEW_GC |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
509 /* A "frob-block" lrecord is any lrecord that's not an lcrecord, i.e. |
| 3024 | 510 one that does not have an old_lcrecord_header at the front and which |
| 1204 | 511 is (usually) allocated in frob blocks. */ |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
512 unsigned int frob_block_p :1; |
| 3263 | 513 #endif /* not NEW_GC */ |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
514 |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
515 /**********************************************************************/ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
516 /* Remaining stuff is not assignable statically using |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
517 DEFINE_*_LISP_OBJECT, but must be assigned with OBJECT_HAS_METHOD |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
518 or the like. */ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
519 |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
520 /* These functions allow any object type to have builtin property |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
521 lists that can be manipulated from the lisp level with |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
522 `get', `put', `remprop', and `object-plist'. */ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
523 Lisp_Object (*getprop) (Lisp_Object obj, Lisp_Object prop); |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
524 int (*putprop) (Lisp_Object obj, Lisp_Object prop, Lisp_Object val); |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
525 int (*remprop) (Lisp_Object obj, Lisp_Object prop); |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
526 Lisp_Object (*plist) (Lisp_Object obj); |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
527 |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
528 /* `disksave' is called at dump time. It is used for objects that |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
529 contain pointers or handles to objects created in external libraries, |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
530 such as window-system windows or file handles. Such external objects |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
531 cannot be dumped, so it is necessary to release them at dump time and |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
532 arrange somehow or other for them to be resurrected if necessary later |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
533 on. |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
534 |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
535 It seems that even non-dumpable objects may be around at dump time, |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
536 and a disksave may be provided. (In fact, the only object currently |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
537 with a disksave, lstream, is non-dumpable.) |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
538 |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
539 Objects rarely need to provide this method; most of the time it will |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
540 be NULL. */ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
541 void (*disksave) (Lisp_Object); |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
542 |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
543 #ifdef MEMORY_USAGE_STATS |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
544 /* Return memory-usage information about the object in question, stored |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
545 into STATS. */ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
546 void (*memory_usage) (Lisp_Object obj, struct generic_usage_stats *stats); |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
547 |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
548 /* Number of additional type-specific statistics related to memory usage. |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
549 Automatically calculated (see compute_memusage_stats_length()) based |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
550 on the value placed in `memusage_stats_list'. */ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
551 Elemcount num_extra_memusage_stats; |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
552 |
|
5158
9e0b43d3095c
more cleanups to object-memory-usage stuff
Ben Wing <ben@xemacs.org>
parents:
5157
diff
changeset
|
553 /* Number of additional type-specific statistics related to |
|
9e0b43d3095c
more cleanups to object-memory-usage stuff
Ben Wing <ben@xemacs.org>
parents:
5157
diff
changeset
|
554 non-Lisp-Object memory usage for this object. Automatically |
|
9e0b43d3095c
more cleanups to object-memory-usage stuff
Ben Wing <ben@xemacs.org>
parents:
5157
diff
changeset
|
555 calculated (see compute_memusage_stats_length()) based on the value |
|
9e0b43d3095c
more cleanups to object-memory-usage stuff
Ben Wing <ben@xemacs.org>
parents:
5157
diff
changeset
|
556 placed in `memusage_stats_list'. */ |
|
9e0b43d3095c
more cleanups to object-memory-usage stuff
Ben Wing <ben@xemacs.org>
parents:
5157
diff
changeset
|
557 Elemcount num_extra_nonlisp_memusage_stats; |
|
9e0b43d3095c
more cleanups to object-memory-usage stuff
Ben Wing <ben@xemacs.org>
parents:
5157
diff
changeset
|
558 |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
559 /* List of tags to be given to the extra statistics, one per statistic. |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
560 Qnil or Qt can be present to separate off different slices. Qnil |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
561 separates different slices within the same type of statistics. |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
562 Qt separates slices corresponding to different types of statistics. |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
563 If Qt is not present, all slices describe extra non-Lisp-Object memory |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
564 associated with a Lisp object. If Qt is present, slices after Qt |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
565 describe non-Lisp-Object memory and slices before Qt describe |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
566 Lisp-Object memory logically associated with the object. For example, |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
567 if the object is a table, then Lisp-Object memory might be the entries |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
568 in the table. This info is only advisory since it will duplicate |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
569 memory described elsewhere and since it may not be possible to be |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
570 completely accurate if the same object occurs multiple times in the |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
571 table. */ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
572 Lisp_Object memusage_stats_list; |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
573 #endif /* MEMORY_USAGE_STATS */ |
| 428 | 574 }; |
| 575 | |
| 617 | 576 /* All the built-in lisp object types are enumerated in `enum lrecord_type'. |
| 442 | 577 Additional ones may be defined by a module (none yet). We leave some |
| 578 room in `lrecord_implementations_table' for such new lisp object types. */ | |
| 579 #define MODULE_DEFINABLE_TYPE_COUNT 32 | |
| 580 | |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
581 extern MODULE_API struct lrecord_implementation * |
| 1632 | 582 lrecord_implementations_table[lrecord_type_last_built_in_type + MODULE_DEFINABLE_TYPE_COUNT]; |
| 428 | 583 |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
584 /* Given a Lisp object, return its implementation |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
585 (struct lrecord_implementation) */ |
| 428 | 586 #define XRECORD_LHEADER_IMPLEMENTATION(obj) \ |
| 442 | 587 LHEADER_IMPLEMENTATION (XRECORD_LHEADER (obj)) |
| 588 #define LHEADER_IMPLEMENTATION(lh) lrecord_implementations_table[(lh)->type] | |
| 428 | 589 |
| 3092 | 590 #include "gc.h" |
| 591 | |
| 592 #ifdef NEW_GC | |
| 593 #include "vdb.h" | |
| 594 #endif /* NEW_GC */ | |
| 595 | |
| 428 | 596 extern int gc_in_progress; |
| 597 | |
| 3263 | 598 #ifdef NEW_GC |
| 2720 | 599 #include "mc-alloc.h" |
| 600 | |
| 2994 | 601 #ifdef ALLOC_TYPE_STATS |
| 2720 | 602 void init_lrecord_stats (void); |
| 603 void inc_lrecord_stats (Bytecount size, const struct lrecord_header *h); | |
| 604 void dec_lrecord_stats (Bytecount size_including_overhead, | |
| 605 const struct lrecord_header *h); | |
| 3092 | 606 int lrecord_stats_heap_size (void); |
| 2994 | 607 #endif /* ALLOC_TYPE_STATS */ |
| 2720 | 608 |
| 609 /* Tell mc-alloc how to call a finalizer. */ | |
| 3092 | 610 #define MC_ALLOC_CALL_FINALIZER(ptr) \ |
| 611 { \ | |
| 612 Lisp_Object MCACF_obj = wrap_pointer_1 (ptr); \ | |
| 613 struct lrecord_header *MCACF_lheader = XRECORD_LHEADER (MCACF_obj); \ | |
| 614 if (XRECORD_LHEADER (MCACF_obj) && LRECORDP (MCACF_obj) \ | |
| 615 && !LRECORD_FREE_P (MCACF_lheader) ) \ | |
| 616 { \ | |
| 617 const struct lrecord_implementation *MCACF_implementation \ | |
| 618 = LHEADER_IMPLEMENTATION (MCACF_lheader); \ | |
| 619 if (MCACF_implementation && MCACF_implementation->finalizer) \ | |
| 620 { \ | |
| 621 GC_STAT_FINALIZED; \ | |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
622 MCACF_implementation->finalizer (MCACF_obj); \ |
| 3092 | 623 } \ |
| 624 } \ | |
| 625 } while (0) | |
| 2720 | 626 |
| 627 /* Tell mc-alloc how to call a finalizer for disksave. */ | |
| 628 #define MC_ALLOC_CALL_FINALIZER_FOR_DISKSAVE(ptr) \ | |
| 629 { \ | |
| 630 Lisp_Object MCACF_obj = wrap_pointer_1 (ptr); \ | |
| 631 struct lrecord_header *MCACF_lheader = XRECORD_LHEADER (MCACF_obj); \ | |
| 632 if (XRECORD_LHEADER (MCACF_obj) && LRECORDP (MCACF_obj) \ | |
| 633 && !LRECORD_FREE_P (MCACF_lheader) ) \ | |
| 634 { \ | |
| 635 const struct lrecord_implementation *MCACF_implementation \ | |
| 636 = LHEADER_IMPLEMENTATION (MCACF_lheader); \ | |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
637 if (MCACF_implementation && MCACF_implementation->disksave) \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
638 MCACF_implementation->disksave (MCACF_obj); \ |
| 2720 | 639 } \ |
| 640 } while (0) | |
| 641 | |
| 642 #define LRECORD_FREE_P(ptr) \ | |
| 643 (((struct lrecord_header *) ptr)->free) | |
| 644 | |
| 645 #define MARK_LRECORD_AS_FREE(ptr) \ | |
| 646 ((void) (((struct lrecord_header *) ptr)->free = 1)) | |
| 647 | |
| 648 #define MARK_LRECORD_AS_NOT_FREE(ptr) \ | |
| 649 ((void) (((struct lrecord_header *) ptr)->free = 0)) | |
| 650 | |
| 651 #define MARKED_RECORD_P(obj) MARKED_P (obj) | |
| 652 #define MARKED_RECORD_HEADER_P(lheader) MARKED_P (lheader) | |
| 653 #define MARK_RECORD_HEADER(lheader) MARK (lheader) | |
| 654 #define UNMARK_RECORD_HEADER(lheader) UNMARK (lheader) | |
| 655 | |
| 656 #define LISP_READONLY_RECORD_HEADER_P(lheader) ((lheader)->lisp_readonly) | |
| 657 #define SET_LISP_READONLY_RECORD_HEADER(lheader) \ | |
| 658 ((void) ((lheader)->lisp_readonly = 1)) | |
| 659 #define MARK_LRECORD_AS_LISP_READONLY(ptr) \ | |
| 660 ((void) (((struct lrecord_header *) ptr)->lisp_readonly = 1)) | |
| 661 | |
| 3263 | 662 #else /* not NEW_GC */ |
| 2720 | 663 |
|
5059
c8f90d61dcf3
fix memory usage stats to include pdumped objects
Ben Wing <ben@xemacs.org>
parents:
4967
diff
changeset
|
664 enum lrecord_alloc_status |
|
c8f90d61dcf3
fix memory usage stats to include pdumped objects
Ben Wing <ben@xemacs.org>
parents:
4967
diff
changeset
|
665 { |
|
c8f90d61dcf3
fix memory usage stats to include pdumped objects
Ben Wing <ben@xemacs.org>
parents:
4967
diff
changeset
|
666 ALLOC_IN_USE, |
|
c8f90d61dcf3
fix memory usage stats to include pdumped objects
Ben Wing <ben@xemacs.org>
parents:
4967
diff
changeset
|
667 ALLOC_FREE, |
|
c8f90d61dcf3
fix memory usage stats to include pdumped objects
Ben Wing <ben@xemacs.org>
parents:
4967
diff
changeset
|
668 ALLOC_ON_FREE_LIST |
|
c8f90d61dcf3
fix memory usage stats to include pdumped objects
Ben Wing <ben@xemacs.org>
parents:
4967
diff
changeset
|
669 }; |
|
c8f90d61dcf3
fix memory usage stats to include pdumped objects
Ben Wing <ben@xemacs.org>
parents:
4967
diff
changeset
|
670 |
|
c8f90d61dcf3
fix memory usage stats to include pdumped objects
Ben Wing <ben@xemacs.org>
parents:
4967
diff
changeset
|
671 void tick_lrecord_stats (const struct lrecord_header *h, |
|
c8f90d61dcf3
fix memory usage stats to include pdumped objects
Ben Wing <ben@xemacs.org>
parents:
4967
diff
changeset
|
672 enum lrecord_alloc_status status); |
|
c8f90d61dcf3
fix memory usage stats to include pdumped objects
Ben Wing <ben@xemacs.org>
parents:
4967
diff
changeset
|
673 |
| 2720 | 674 #define LRECORD_FREE_P(ptr) \ |
| 675 (((struct lrecord_header *) ptr)->type == lrecord_type_free) | |
| 676 | |
| 677 #define MARK_LRECORD_AS_FREE(ptr) \ | |
| 678 ((void) (((struct lrecord_header *) ptr)->type = lrecord_type_free)) | |
| 679 | |
| 442 | 680 #define MARKED_RECORD_P(obj) (XRECORD_LHEADER (obj)->mark) |
| 428 | 681 #define MARKED_RECORD_HEADER_P(lheader) ((lheader)->mark) |
| 682 #define MARK_RECORD_HEADER(lheader) ((void) ((lheader)->mark = 1)) | |
| 683 #define UNMARK_RECORD_HEADER(lheader) ((void) ((lheader)->mark = 0)) | |
| 684 | |
| 685 #define C_READONLY_RECORD_HEADER_P(lheader) ((lheader)->c_readonly) | |
| 686 #define LISP_READONLY_RECORD_HEADER_P(lheader) ((lheader)->lisp_readonly) | |
| 442 | 687 #define SET_C_READONLY_RECORD_HEADER(lheader) do { \ |
| 688 struct lrecord_header *SCRRH_lheader = (lheader); \ | |
| 689 SCRRH_lheader->c_readonly = 1; \ | |
| 690 SCRRH_lheader->lisp_readonly = 1; \ | |
| 691 SCRRH_lheader->mark = 1; \ | |
| 692 } while (0) | |
| 428 | 693 #define SET_LISP_READONLY_RECORD_HEADER(lheader) \ |
| 694 ((void) ((lheader)->lisp_readonly = 1)) | |
| 3263 | 695 #endif /* not NEW_GC */ |
| 1676 | 696 |
| 697 #ifdef USE_KKCC | |
| 698 #define RECORD_DESCRIPTION(lheader) lrecord_memory_descriptions[(lheader)->type] | |
| 699 #else /* not USE_KKCC */ | |
| 442 | 700 #define RECORD_MARKER(lheader) lrecord_markers[(lheader)->type] |
| 1676 | 701 #endif /* not USE_KKCC */ |
| 428 | 702 |
| 934 | 703 #define RECORD_DUMPABLE(lheader) (lrecord_implementations_table[(lheader)->type])->dumpable |
| 1204 | 704 |
| 705 /* Data description stuff | |
| 934 | 706 |
| 1204 | 707 Data layout descriptions describe blocks of memory (in particular, Lisp |
| 708 objects and other objects on the heap, and global objects with pointers | |
| 709 to such heap objects), including their size and a list of the elements | |
| 710 that need relocating, marking or other special handling. They are | |
| 711 currently used in two places: by pdump [the new, portable dumper] and | |
| 712 KKCC [the new garbage collector]. The two subsystems use the | |
| 713 descriptions in different ways, and as a result some of the descriptions | |
| 714 are appropriate only for one or the other, when it is known that only | |
| 715 that subsystem will use the description. (This is particularly the case | |
| 716 with objects that can't be dumped, because pdump needs more info than | |
| 717 KKCC.) However, properly written descriptions are appropriate for both, | |
| 718 and you should strive to write your descriptions that way, since the | |
| 719 dumpable status of an object may change and new uses for the | |
| 720 descriptions may be created. (An example that comes to mind is a | |
| 721 facility for determining the memory usage of XEmacs data structures -- | |
| 722 like `buffer-memory-usage', `window-memory-usage', etc. but more | |
| 723 general.) | |
| 724 | |
| 725 More specifically: | |
| 428 | 726 |
| 1204 | 727 Pdump (the portable dumper) needs to write out all objects in heap |
| 728 space, and later on (in another invocation of XEmacs) load them back | |
| 729 into the heap, relocating all pointers to the heap objects in the global | |
| 730 data space. ("Heap" means anything malloc()ed, including all Lisp | |
| 731 objects, and "global data" means anything declared globally or | |
| 732 `static'.) Pdump, then, needs to be told about the location of all | |
| 733 global pointers to heap objects, all the description of all such | |
| 734 objects, including their size and any pointers to other heap (aka | |
| 735 "relocatable") objects. (Pdump assumes that the heap may occur in | |
| 736 different places in different invocations -- therefore, it is not enough | |
| 737 simply to write out the entire heap and later reload it at the same | |
| 738 location -- but that global data is always in the same place, and hence | |
| 739 pointers to it do not need to be relocated. This assumption holds true | |
| 740 in general for modern operating systems, but would be broken, for | |
| 741 example, in a system without virtual memory, or when dealing with shared | |
| 742 libraries. Also, unlike unexec, pdump does not usually write out or | |
| 743 restore objects in the global data space, and thus they need to be | |
| 744 initialized every time XEmacs is loaded. This is the purpose of the | |
| 745 reinit_*() functions throughout XEmacs. [It's possible, however, to make | |
| 746 pdump restore global data. This must be done, of course, for heap | |
| 747 pointers, but is also done for other values that are not easy to | |
| 748 recompute -- in particular, values established by the Lisp code loaded | |
| 749 at dump time.]) Note that the data type `Lisp_Object' is basically just | |
| 750 a relocatable pointer disguised as a long, and in general pdump treats | |
| 751 the Lisp_Object values and pointers to Lisp objects (e.g. Lisp_Object | |
| 752 vs. `struct frame *') identically. (NOTE: This equivalence depends | |
| 753 crucially on the current "minimal tagbits" implementation of Lisp_Object | |
| 754 pointers.) | |
| 428 | 755 |
| 1204 | 756 Descriptions are used by pdump in three places: (a) descriptions of Lisp |
| 757 objects, referenced in the DEFINE_*LRECORD_*IMPLEMENTATION*() call; (b) | |
| 758 descriptions of global objects to be dumped, registered by | |
| 759 dump_add_root_block(); (c) descriptions of global pointers to | |
| 2367 | 760 non-Lisp_Object heap objects, registered by dump_add_root_block_ptr(). |
| 1204 | 761 The descriptions need to tell pdump which elements of your structure are |
| 762 Lisp_Objects or structure pointers, plus the descriptions in turn of the | |
| 763 non-Lisp_Object structures pointed to. If these structures are you own | |
| 764 private ones, you will have to write these recursive descriptions | |
| 765 yourself; otherwise, you are reusing a structure already in existence | |
| 766 elsewhere and there is probably already a description for it. | |
| 767 | |
| 768 Pdump does not care about Lisp objects that cannot be dumped (the | |
| 769 dumpable flag to DEFINE_*LRECORD_*IMPLEMENTATION*() is 0). | |
| 770 | |
| 771 KKCC also uses data layout descriptions, but differently. It cares | |
| 772 about all objects, dumpable or not, but specifically only wants to know | |
| 773 about Lisp_Objects in your object and in structures pointed to. Thus, | |
| 774 it doesn't care about things like pointers to structures ot other blocks | |
| 775 of memory with no Lisp Objects in them, which pdump would care a lot | |
| 776 about. | |
| 777 | |
| 778 Technically, then, you could write your description differently | |
| 779 depending on whether your object is dumpable -- the full pdump | |
| 780 description if so, the abbreviated KKCC description if not. In fact, | |
| 781 some descriptions are written this way. This is dangerous, though, | |
| 782 because another use might come along for the data descriptions, that | |
| 783 doesn't care about the dumper flag and makes use of some of the stuff | |
| 784 normally omitted from the "abbreviated" description -- see above. | |
| 785 | |
| 5094 | 786 A memory_description is an array of values. The first value of each |
| 787 line is a type, the second the offset in the lrecord structure. The | |
| 788 third and following elements are parameters; their presence, type and | |
| 789 number is type-dependent. | |
| 771 | 790 |
| 1204 | 791 The description ends with an "XD_END" record. |
| 771 | 792 |
| 793 The top-level description of an lrecord or lcrecord does not need | |
| 794 to describe every element, just the ones that need to be relocated, | |
| 795 since the size of the lrecord is known. (The same goes for nested | |
| 796 structures, whenever the structure size is given, rather than being | |
| 797 defaulted by specifying 0 for the size.) | |
| 798 | |
| 1204 | 799 A sized_memory_description is a memory_description plus the size of the |
| 800 block of memory. The size field in a sized_memory_description can be | |
| 801 given as zero, i.e. unspecified, meaning that the last element in the | |
| 802 structure is described in the description and the size of the block can | |
| 803 therefore be computed from it. (This is useful for stretchy arrays.) | |
| 804 | |
| 805 memory_descriptions are used to describe lrecords (the size of the | |
| 806 lrecord is elsewhere in its description, attached to its methods, so it | |
| 807 does not need to be given here) and global objects, where the size is an | |
| 808 argument to the call to dump_add_root_block(). | |
| 809 sized_memory_descriptions are used for pointers and arrays in | |
| 2367 | 810 memory_descriptions and for calls to dump_add_root_block_ptr(). (#### |
| 1204 | 811 It is not obvious why this is so in the latter case. Probably, calls to |
| 2367 | 812 dump_add_root_block_ptr() should use plain memory_descriptions and have |
| 1204 | 813 the size be an argument to the call.) |
| 814 | |
| 815 NOTE: Anywhere that a sized_memory_description occurs inside of a plain | |
| 816 memory_description, a "description map" can be substituted. Rather than | |
| 817 being an actual description, this describes how to find the description | |
| 818 by looking inside of the object being described. This is a convenient | |
| 819 way to describe Lisp objects with subtypes and corresponding | |
| 820 type-specific data. | |
| 428 | 821 |
| 822 Some example descriptions : | |
| 440 | 823 |
| 814 | 824 struct Lisp_String |
| 825 { | |
| 826 struct lrecord_header lheader; | |
| 827 Bytecount size; | |
| 867 | 828 Ibyte *data; |
| 814 | 829 Lisp_Object plist; |
| 830 }; | |
| 831 | |
| 1204 | 832 static const struct memory_description cons_description[] = { |
| 440 | 833 { XD_LISP_OBJECT, offsetof (Lisp_Cons, car) }, |
| 834 { XD_LISP_OBJECT, offsetof (Lisp_Cons, cdr) }, | |
| 428 | 835 { XD_END } |
| 836 }; | |
| 837 | |
| 440 | 838 Which means "two lisp objects starting at the 'car' and 'cdr' elements" |
| 428 | 839 |
| 1204 | 840 static const struct memory_description string_description[] = { |
| 814 | 841 { XD_BYTECOUNT, offsetof (Lisp_String, size) }, |
| 1204 | 842 { XD_OPAQUE_DATA_PTR, offsetof (Lisp_String, data), XD_INDIRECT (0, 1) }, |
| 814 | 843 { XD_LISP_OBJECT, offsetof (Lisp_String, plist) }, |
| 844 { XD_END } | |
| 845 }; | |
| 846 | |
| 847 "A pointer to string data at 'data', the size of the pointed array being | |
| 848 the value of the size variable plus 1, and one lisp object at 'plist'" | |
| 849 | |
| 850 If your object has a pointer to an array of Lisp_Objects in it, something | |
| 851 like this: | |
| 852 | |
| 853 struct Lisp_Foo | |
| 854 { | |
| 855 ...; | |
| 856 int count; | |
| 857 Lisp_Object *objects; | |
| 858 ...; | |
| 859 } | |
| 860 | |
| 2367 | 861 You'd use XD_BLOCK_PTR, something like: |
| 814 | 862 |
| 1204 | 863 static const struct memory_description foo_description[] = { |
| 864 ... | |
| 865 { XD_INT, offsetof (Lisp_Foo, count) }, | |
| 2367 | 866 { XD_BLOCK_PTR, offsetof (Lisp_Foo, objects), |
| 2551 | 867 XD_INDIRECT (0, 0), { &lisp_object_description } }, |
| 1204 | 868 ... |
| 869 }; | |
| 870 | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4937
diff
changeset
|
871 lisp_object_description is declared in gc.c, like this: |
| 1204 | 872 |
| 873 static const struct memory_description lisp_object_description_1[] = { | |
| 814 | 874 { XD_LISP_OBJECT, 0 }, |
| 875 { XD_END } | |
| 876 }; | |
| 877 | |
| 1204 | 878 const struct sized_memory_description lisp_object_description = { |
| 814 | 879 sizeof (Lisp_Object), |
| 1204 | 880 lisp_object_description_1 |
| 814 | 881 }; |
| 882 | |
| 2367 | 883 Another example of XD_BLOCK_PTR: |
| 428 | 884 |
| 1204 | 885 typedef struct htentry |
| 814 | 886 { |
| 887 Lisp_Object key; | |
| 888 Lisp_Object value; | |
| 1204 | 889 } htentry; |
| 814 | 890 |
| 891 struct Lisp_Hash_Table | |
| 892 { | |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
893 NORMAL_LISP_OBJECT_HEADER header; |
| 814 | 894 Elemcount size; |
| 895 Elemcount count; | |
| 896 Elemcount rehash_count; | |
| 897 double rehash_size; | |
| 898 double rehash_threshold; | |
| 899 Elemcount golden_ratio; | |
| 900 hash_table_hash_function_t hash_function; | |
| 901 hash_table_test_function_t test_function; | |
| 1204 | 902 htentry *hentries; |
| 814 | 903 enum hash_table_weakness weakness; |
| 904 Lisp_Object next_weak; // Used to chain together all of the weak | |
| 905 // hash tables. Don't mark through this. | |
| 906 }; | |
| 907 | |
| 1204 | 908 static const struct memory_description htentry_description_1[] = { |
| 909 { XD_LISP_OBJECT, offsetof (htentry, key) }, | |
| 910 { XD_LISP_OBJECT, offsetof (htentry, value) }, | |
| 814 | 911 { XD_END } |
| 912 }; | |
| 913 | |
| 1204 | 914 static const struct sized_memory_description htentry_description = { |
| 915 sizeof (htentry), | |
| 916 htentry_description_1 | |
| 814 | 917 }; |
| 918 | |
| 1204 | 919 const struct memory_description hash_table_description[] = { |
| 814 | 920 { XD_ELEMCOUNT, offsetof (Lisp_Hash_Table, size) }, |
| 2367 | 921 { XD_BLOCK_PTR, offsetof (Lisp_Hash_Table, hentries), XD_INDIRECT (0, 1), |
| 2551 | 922 { &htentry_description } }, |
| 814 | 923 { XD_LO_LINK, offsetof (Lisp_Hash_Table, next_weak) }, |
| 924 { XD_END } | |
| 925 }; | |
| 926 | |
| 927 Note that we don't need to declare all the elements in the structure, just | |
| 928 the ones that need to be relocated (Lisp_Objects and structures) or that | |
| 929 need to be referenced as counts for relocated objects. | |
| 930 | |
| 1204 | 931 A description map looks like this: |
| 932 | |
| 933 static const struct sized_memory_description specifier_extra_description_map [] = { | |
| 934 { offsetof (Lisp_Specifier, methods) }, | |
| 935 { offsetof (struct specifier_methods, extra_description) }, | |
| 936 { -1 } | |
| 937 }; | |
| 938 | |
| 939 const struct memory_description specifier_description[] = { | |
| 940 ... | |
| 2367 | 941 { XD_BLOCK_ARRAY, offset (Lisp_Specifier, data), 1, |
| 2551 | 942 { specifier_extra_description_map } }, |
| 1204 | 943 ... |
| 944 { XD_END } | |
| 945 }; | |
| 946 | |
| 947 This would be appropriate for an object that looks like this: | |
| 948 | |
| 949 struct specifier_methods | |
| 950 { | |
| 951 ... | |
| 952 const struct sized_memory_description *extra_description; | |
| 953 ... | |
| 954 }; | |
| 955 | |
| 956 struct Lisp_Specifier | |
| 957 { | |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
958 NORMAL_LISP_OBJECT_HEADER header; |
| 1204 | 959 struct specifier_methods *methods; |
| 960 | |
| 961 ... | |
| 962 // type-specific extra data attached to a specifier | |
| 963 max_align_t data[1]; | |
| 964 }; | |
| 965 | |
| 966 The description map means "retrieve a pointer into the object at offset | |
| 967 `offsetof (Lisp_Specifier, methods)' , then in turn retrieve a pointer | |
| 968 into that object at offset `offsetof (struct specifier_methods, | |
| 969 extra_description)', and that is the sized_memory_description to use." | |
| 970 There can be any number of indirections, which can be either into | |
| 971 straight pointers or Lisp_Objects. The way that description maps are | |
| 972 distinguished from normal sized_memory_descriptions is that in the | |
| 973 former, the memory_description pointer is NULL. | |
| 974 | |
| 975 --ben | |
| 976 | |
| 814 | 977 |
| 978 The existing types : | |
| 979 | |
| 980 | |
| 428 | 981 XD_LISP_OBJECT |
| 1204 | 982 |
|
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
Ben Wing <ben@xemacs.org>
parents:
5160
diff
changeset
|
983 A Lisp_Object. This is also the type to use for pointers to other lrecords |
| 1204 | 984 (e.g. struct frame *). |
| 428 | 985 |
| 440 | 986 XD_LISP_OBJECT_ARRAY |
| 1204 | 987 |
|
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
Ben Wing <ben@xemacs.org>
parents:
5160
diff
changeset
|
988 An array of Lisp_Objects or (equivalently) pointers to lrecords. |
| 771 | 989 The parameter (i.e. third element) is the count. This would be declared |
| 990 as Lisp_Object foo[666]. For something declared as Lisp_Object *foo, | |
| 2367 | 991 use XD_BLOCK_PTR, whose description parameter is a sized_memory_description |
| 771 | 992 consisting of only XD_LISP_OBJECT and XD_END. |
| 440 | 993 |
|
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
Ben Wing <ben@xemacs.org>
parents:
5160
diff
changeset
|
994 XD_INLINE_LISP_OBJECT_BLOCK_PTR |
|
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
Ben Wing <ben@xemacs.org>
parents:
5160
diff
changeset
|
995 |
|
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
Ben Wing <ben@xemacs.org>
parents:
5160
diff
changeset
|
996 An pointer to a contiguous block of inline Lisp objects -- i.e., the Lisp |
|
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
Ben Wing <ben@xemacs.org>
parents:
5160
diff
changeset
|
997 object itself rather than a Lisp_Object pointer is stored in the block. |
|
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
Ben Wing <ben@xemacs.org>
parents:
5160
diff
changeset
|
998 This is used only under NEW_GC and is useful for increased efficiency when |
|
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
Ben Wing <ben@xemacs.org>
parents:
5160
diff
changeset
|
999 an array of the same kind of object is needed. Examples of the use of this |
|
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
Ben Wing <ben@xemacs.org>
parents:
5160
diff
changeset
|
1000 type are Lisp dynarrs, where the array elements are inline Lisp objects |
|
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
Ben Wing <ben@xemacs.org>
parents:
5160
diff
changeset
|
1001 rather than non-Lisp structures, as is normally the case; and hash tables, |
|
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
Ben Wing <ben@xemacs.org>
parents:
5160
diff
changeset
|
1002 where the key/value pairs are encapsulated as hash-table-entry objects and |
|
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
Ben Wing <ben@xemacs.org>
parents:
5160
diff
changeset
|
1003 an array of inline hash-table-entry objects is stored. |
|
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
Ben Wing <ben@xemacs.org>
parents:
5160
diff
changeset
|
1004 |
| 428 | 1005 XD_LO_LINK |
| 1204 | 1006 |
| 771 | 1007 Weak link in a linked list of objects of the same type. This is a |
| 1008 link that does NOT generate a GC reference. Thus the pdumper will | |
| 1009 not automatically add the referenced object to the table of all | |
| 1010 objects to be dumped, and when storing and loading the dumped data | |
| 1011 will automatically prune unreferenced objects in the chain and link | |
| 1012 each referenced object to the next referenced object, even if it's | |
| 1013 many links away. We also need to special handling of a similar | |
| 1014 nature for the root of the chain, which will be a staticpro()ed | |
| 1015 object. | |
| 432 | 1016 |
| 428 | 1017 XD_OPAQUE_PTR |
| 1204 | 1018 |
| 428 | 1019 Pointer to undumpable data. Must be NULL when dumping. |
| 1020 | |
| 2551 | 1021 XD_OPAQUE_PTR_CONVERTIBLE |
| 1022 | |
| 1023 Pointer to data which is not directly dumpable but can be converted | |
| 1024 to a dumpable, opaque external representation. The parameter is | |
| 1025 a pointer to an opaque_convert_functions struct. | |
| 1026 | |
| 1027 XD_OPAQUE_DATA_CONVERTIBLE | |
| 1028 | |
| 1029 Data which is not directly dumpable but can be converted to a | |
| 1030 dumpable, opaque external representation. The parameter is a | |
| 1031 pointer to an opaque_convert_functions struct. | |
| 1032 | |
| 2367 | 1033 XD_BLOCK_PTR |
| 1204 | 1034 |
| 771 | 1035 Pointer to block of described memory. (This is misnamed: It is NOT |
| 1036 necessarily a pointer to a struct foo.) Parameters are number of | |
| 1204 | 1037 contiguous blocks and sized_memory_description. |
| 771 | 1038 |
| 2367 | 1039 XD_BLOCK_ARRAY |
| 1204 | 1040 |
| 771 | 1041 Array of blocks of described memory. Parameters are number of |
| 2367 | 1042 structures and sized_memory_description. This differs from XD_BLOCK_PTR |
| 771 | 1043 in that the parameter is declared as struct foo[666] instead of |
| 1044 struct *foo. In other words, the block of memory holding the | |
| 1045 structures is within the containing structure, rather than being | |
| 1046 elsewhere, with a pointer in the containing structure. | |
| 428 | 1047 |
| 1204 | 1048 NOTE NOTE NOTE: Be sure that you understand the difference between |
| 2367 | 1049 XD_BLOCK_PTR and XD_BLOCK_ARRAY: |
| 1204 | 1050 - struct foo bar[666], i.e. 666 inline struct foos |
| 2367 | 1051 --> XD_BLOCK_ARRAY, argument 666, pointing to a description of |
| 1204 | 1052 struct foo |
| 1053 - struct foo *bar, i.e. pointer to a block of 666 struct foos | |
| 2367 | 1054 --> XD_BLOCK_PTR, argument 666, pointing to a description of |
| 1204 | 1055 struct foo |
| 1056 - struct foo *bar[666], i.e. 666 pointers to separate blocks of struct foos | |
| 2367 | 1057 --> XD_BLOCK_ARRAY, argument 666, pointing to a description of |
| 1204 | 1058 a single pointer to struct foo; the description is a single |
| 2367 | 1059 XD_BLOCK_PTR, argument 1, which in turn points to a description |
| 1204 | 1060 of struct foo. |
| 1061 | |
| 2367 | 1062 NOTE also that an XD_BLOCK_PTR of 666 foos is equivalent to an |
| 1063 XD_BLOCK_PTR of 1 bar, where the description of `bar' is an | |
| 1064 XD_BLOCK_ARRAY of 666 foos. | |
| 1065 | |
| 428 | 1066 XD_OPAQUE_DATA_PTR |
| 1204 | 1067 |
| 428 | 1068 Pointer to dumpable opaque data. Parameter is the size of the data. |
| 1069 Pointed data must be relocatable without changes. | |
| 1070 | |
| 771 | 1071 XD_UNION |
| 1204 | 1072 |
| 1073 Union of two or more different types of data. Parameters are a constant | |
| 1074 which determines which type the data is (this is usually an XD_INDIRECT, | |
| 1075 referring to one of the fields in the structure), and a "sizing lobby" (a | |
| 1076 sized_memory_description, which points to a memory_description and | |
| 1077 indicates its size). The size field in the sizing lobby describes the | |
| 1078 size of the union field in the object, and the memory_description in it | |
| 1079 is referred to as a "union map" and has a special interpretation: The | |
| 1080 offset field is replaced by a constant, which is compared to the first | |
| 1081 parameter of the XD_UNION descriptor to determine if this description | |
| 1082 applies to the union data, and XD_INDIRECT references refer to the | |
| 1083 containing object and description. Note that the description applies | |
| 2367 | 1084 "inline" to the union data, like XD_BLOCK_ARRAY and not XD_BLOCK_PTR. |
| 1204 | 1085 If the union data is a pointer to different types of structures, each |
| 2367 | 1086 element in the memory_description should be an XD_BLOCK_PTR. See |
| 1204 | 1087 unicode.c, redisplay.c and objects.c for examples of XD_UNION. |
| 1088 | |
| 1089 XD_UNION_DYNAMIC_SIZE | |
| 1090 | |
| 1091 Same as XD_UNION except that this is used for objects where the size of | |
| 1092 the object containing the union varies depending on the particular value | |
| 1093 of the union constant. That is, an object with plain XD_UNION typically | |
| 1094 has the union declared as `union foo' or as `void *', where an object | |
| 1095 with XD_UNION_DYNAMIC_SIZE typically has the union as the last element, | |
| 2367 | 1096 and declared as something like Rawbyte foo[1]. With plain XD_UNION, the |
| 1204 | 1097 object is (usually) of fixed size and always contains enough space for |
| 1098 the data associated with all possible union constants, and thus the union | |
| 1099 constant can potentially change during the lifetime of the object. With | |
| 1100 XD_UNION_DYNAMIC_SIZE, however, the union constant is fixed at the time | |
| 1101 of creation of the object, and the size of the object is computed | |
| 1102 dynamically at creation time based on the size of the data associated | |
| 1103 with the union constant. Currently, the only difference between XD_UNION | |
| 1104 and XD_UNION_DYNAMIC_SIZE is how the size of the union data is | |
| 1105 calculated, when (a) the structure containing the union has no size | |
| 1106 given; (b) the union occurs as the last element in the structure; and (c) | |
| 1107 the union has no size given (in the first-level sized_memory_description | |
| 1108 pointed to). In this circumstance, the size of XD_UNION comes from the | |
| 1109 max size of the data associated with all possible union constants, | |
| 1110 whereas the size of XD_UNION_DYNAMIC_SIZE comes from the size of the data | |
| 1111 associated with the currently specified (and unchangeable) union | |
| 1112 constant. | |
| 771 | 1113 |
| 2367 | 1114 XD_ASCII_STRING |
| 1204 | 1115 |
| 2367 | 1116 Pointer to a C string, purely ASCII. |
| 428 | 1117 |
| 1118 XD_DOC_STRING | |
| 1204 | 1119 |
| 2367 | 1120 Pointer to a doc string (C string in pure ASCII if positive, |
| 1121 opaque value if negative) | |
| 428 | 1122 |
| 1123 XD_INT_RESET | |
| 1204 | 1124 |
| 428 | 1125 An integer which will be reset to a given value in the dump file. |
| 1126 | |
| 1204 | 1127 XD_ELEMCOUNT |
| 771 | 1128 |
| 665 | 1129 Elemcount value. Used for counts. |
| 647 | 1130 |
| 665 | 1131 XD_BYTECOUNT |
| 1204 | 1132 |
| 665 | 1133 Bytecount value. Used for counts. |
| 647 | 1134 |
| 665 | 1135 XD_HASHCODE |
| 1204 | 1136 |
| 665 | 1137 Hashcode value. Used for the results of hashing functions. |
| 428 | 1138 |
| 1139 XD_INT | |
| 1204 | 1140 |
| 428 | 1141 int value. Used for counts. |
| 1142 | |
| 1143 XD_LONG | |
| 1204 | 1144 |
| 428 | 1145 long value. Used for counts. |
| 1146 | |
| 771 | 1147 XD_BYTECOUNT |
| 1204 | 1148 |
| 771 | 1149 bytecount value. Used for counts. |
| 1150 | |
| 428 | 1151 XD_END |
| 1204 | 1152 |
| 428 | 1153 Special type indicating the end of the array. |
| 1154 | |
| 1155 | |
| 1156 Special macros: | |
| 1204 | 1157 |
| 1158 XD_INDIRECT (line, delta) | |
| 1159 Usable where a count, size, offset or union constant is requested. Gives | |
| 1160 the value of the element which is at line number 'line' in the | |
| 1161 description (count starts at zero) and adds delta to it, which must | |
| 1162 (currently) be positive. | |
| 428 | 1163 */ |
| 1164 | |
| 1204 | 1165 enum memory_description_type |
| 647 | 1166 { |
| 440 | 1167 XD_LISP_OBJECT_ARRAY, |
| 428 | 1168 XD_LISP_OBJECT, |
| 3092 | 1169 #ifdef NEW_GC |
|
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
Ben Wing <ben@xemacs.org>
parents:
5160
diff
changeset
|
1170 XD_INLINE_LISP_OBJECT_BLOCK_PTR, |
| 3092 | 1171 #endif /* NEW_GC */ |
| 428 | 1172 XD_LO_LINK, |
| 1173 XD_OPAQUE_PTR, | |
| 2551 | 1174 XD_OPAQUE_PTR_CONVERTIBLE, |
| 1175 XD_OPAQUE_DATA_CONVERTIBLE, | |
| 1176 XD_OPAQUE_DATA_PTR, | |
| 2367 | 1177 XD_BLOCK_PTR, |
| 1178 XD_BLOCK_ARRAY, | |
| 771 | 1179 XD_UNION, |
| 1204 | 1180 XD_UNION_DYNAMIC_SIZE, |
| 2367 | 1181 XD_ASCII_STRING, |
| 428 | 1182 XD_DOC_STRING, |
| 1183 XD_INT_RESET, | |
| 665 | 1184 XD_BYTECOUNT, |
| 1185 XD_ELEMCOUNT, | |
| 1186 XD_HASHCODE, | |
| 428 | 1187 XD_INT, |
| 1188 XD_LONG, | |
| 1204 | 1189 XD_END |
| 428 | 1190 }; |
| 1191 | |
| 1204 | 1192 enum data_description_entry_flags |
| 647 | 1193 { |
| 1204 | 1194 /* If set, KKCC does not process this entry. |
| 1195 | |
| 1196 (1) One obvious use is with things that pdump saves but which do not get | |
| 1197 marked normally -- for example the next and prev fields in a marker. The | |
| 1198 marker chain is weak, with its entries removed when they are finalized. | |
| 1199 | |
| 1200 (2) This can be set on structures not containing any Lisp objects, or (more | |
| 1201 usefully) on structures that contain Lisp objects but where the objects | |
| 1202 always occur in another structure as well. For example, the extent lists | |
| 1203 kept by a buffer keep the extents in two lists, one sorted by the start | |
| 1204 of the extent and the other by the end. There's no point in marking | |
| 1205 both, since each contains the same objects as the other; but when dumping | |
| 1206 (if we were to dump such a structure), when computing memory size, etc., | |
| 1207 it's crucial to tag both sides. | |
| 1208 */ | |
| 1209 XD_FLAG_NO_KKCC = 1, | |
| 1210 /* If set, pdump does not process this entry. */ | |
| 1211 XD_FLAG_NO_PDUMP = 2, | |
| 1212 /* Indicates that this is a "default" entry in a union map. */ | |
| 1213 XD_FLAG_UNION_DEFAULT_ENTRY = 4, | |
| 3263 | 1214 #ifndef NEW_GC |
| 1204 | 1215 /* Indicates that this is a free Lisp object we're marking. |
| 1216 Only relevant for ERROR_CHECK_GC. This occurs when we're marking | |
| 1217 lcrecord-lists, where the objects have had their type changed to | |
| 1218 lrecord_type_free and also have had their free bit set, but we mark | |
| 1219 them as normal. */ | |
|
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
Ben Wing <ben@xemacs.org>
parents:
5160
diff
changeset
|
1220 XD_FLAG_FREE_LISP_OBJECT = 8, |
| 3263 | 1221 #endif /* not NEW_GC */ |
| 1204 | 1222 #if 0 |
| 1223 /* Suggestions for other possible flags: */ | |
| 1224 | |
| 1225 /* Eliminate XD_UNION_DYNAMIC_SIZE and replace it with a flag, like this. */ | |
| 1226 XD_FLAG_UNION_DYNAMIC_SIZE = 16, | |
| 1227 /* Require that everyone who uses a description map has to flag it, so | |
| 1228 that it's easy to tell, when looking through the code, where the | |
| 1229 description maps are and who's using them. This might also become | |
| 1230 necessary if for some reason the format of the description map is | |
| 1231 expanded and we need to stick a pointer in the second slot (although | |
| 1232 we could still ensure that the second slot in the first entry was NULL | |
| 1233 or <0). */ | |
|
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
Ben Wing <ben@xemacs.org>
parents:
5160
diff
changeset
|
1234 XD_FLAG_DESCRIPTION_MAP = 32, |
| 1204 | 1235 #endif |
| 428 | 1236 }; |
| 1237 | |
| 2551 | 1238 union memory_contents_description |
| 1239 { | |
| 1240 /* The first element is used by static initializers only. We always read | |
| 1241 from one of the other two pointers. */ | |
| 1242 const void *write_only; | |
| 1243 const struct sized_memory_description *descr; | |
| 1244 const struct opaque_convert_functions *funcs; | |
| 1245 }; | |
| 1246 | |
| 1204 | 1247 struct memory_description |
| 1248 { | |
| 1249 enum memory_description_type type; | |
| 1250 Bytecount offset; | |
| 1251 EMACS_INT data1; | |
| 2551 | 1252 union memory_contents_description data2; |
| 1204 | 1253 /* Indicates which subsystems process this entry, plus (potentially) other |
| 1254 flags that apply to this entry. */ | |
| 1255 int flags; | |
| 1256 }; | |
| 428 | 1257 |
| 1204 | 1258 struct sized_memory_description |
| 1259 { | |
| 1260 Bytecount size; | |
| 1261 const struct memory_description *description; | |
| 1262 }; | |
| 1263 | |
| 2551 | 1264 |
| 1265 struct opaque_convert_functions | |
| 1266 { | |
| 1267 /* Used by XD_OPAQUE_PTR_CONVERTIBLE and | |
| 1268 XD_OPAQUE_DATA_CONVERTIBLE */ | |
| 1269 | |
| 1270 /* Converter to external representation, for those objects from | |
| 1271 external libraries that can't be directly dumped as opaque data | |
| 1272 because they contain pointers. This is called at dump time to | |
| 1273 convert to an opaque, pointer-less representation. | |
| 1274 | |
| 1275 This function must put a pointer to the opaque result in *data | |
| 1276 and its size in *size. */ | |
|
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
Ben Wing <ben@xemacs.org>
parents:
5160
diff
changeset
|
1277 void (*convert) (const void *object, void **data, Bytecount *size); |
| 2551 | 1278 |
| 1279 /* Post-conversion cleanup. Optional (null if not provided). | |
| 1280 | |
| 1281 When provided it will be called post-dumping to free any storage | |
| 1282 allocated for the conversion results. */ | |
|
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
Ben Wing <ben@xemacs.org>
parents:
5160
diff
changeset
|
1283 void (*convert_free) (const void *object, void *data, Bytecount size); |
| 2551 | 1284 |
| 1285 /* De-conversion. | |
| 1286 | |
| 1287 At reload time, rebuilds the object from the converted form. | |
| 1288 "object" is 0 for the PTR case, return is ignored in the DATA | |
| 1289 case. */ | |
|
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
Ben Wing <ben@xemacs.org>
parents:
5160
diff
changeset
|
1290 void *(*deconvert) (void *object, void *data, Bytecount size); |
| 2551 | 1291 |
| 1292 }; | |
| 1293 | |
| 1204 | 1294 extern const struct sized_memory_description lisp_object_description; |
| 1295 | |
| 1296 #define XD_INDIRECT(val, delta) (-1 - (Bytecount) ((val) | ((delta) << 8))) | |
| 428 | 1297 |
| 1204 | 1298 #define XD_IS_INDIRECT(code) ((code) < 0) |
| 1299 #define XD_INDIRECT_VAL(code) ((-1 - (code)) & 255) | |
| 1300 #define XD_INDIRECT_DELTA(code) ((-1 - (code)) >> 8) | |
| 1301 | |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
1302 /* DEFINE_*_LISP_OBJECT is for objects with constant size. (Either |
|
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
1303 DEFINE_DUMPABLE_LISP_OBJECT for objects that can be saved in a dumped |
|
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
1304 executable, or DEFINE_NODUMP_LISP_OBJECT for objects that cannot be |
|
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
1305 saved -- e.g. that contain pointers to non-persistent external objects |
|
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
1306 such as window-system windows.) |
|
5117
3742ea8250b5
Checking in final CVS version of workspace 'ben-lisp-object'
Ben Wing <ben@xemacs.org>
parents:
3063
diff
changeset
|
1307 |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
1308 DEFINE_*_SIZABLE_LISP_OBJECT is for objects whose size varies. |
|
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
1309 |
|
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
1310 DEFINE_*_FROB_BLOCK_LISP_OBJECT is for objects that are allocated in |
|
5117
3742ea8250b5
Checking in final CVS version of workspace 'ben-lisp-object'
Ben Wing <ben@xemacs.org>
parents:
3063
diff
changeset
|
1311 large blocks ("frob blocks"), which are parceled up individually. Such |
|
3742ea8250b5
Checking in final CVS version of workspace 'ben-lisp-object'
Ben Wing <ben@xemacs.org>
parents:
3063
diff
changeset
|
1312 objects need special handling in alloc.c. This does not apply to |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
1313 NEW_GC, because it does this automatically. |
|
5117
3742ea8250b5
Checking in final CVS version of workspace 'ben-lisp-object'
Ben Wing <ben@xemacs.org>
parents:
3063
diff
changeset
|
1314 |
|
5120
d1247f3cc363
latest work on lisp-object workspace;
Ben Wing <ben@xemacs.org>
parents:
5118
diff
changeset
|
1315 DEFINE_*_INTERNAL_LISP_OBJECT is for "internal" objects that should |
|
5124
623d57b7fbe8
separate regular and disksave finalization, print method fixes.
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
1316 never be visible on the Lisp level. This is a shorthand for the most |
|
623d57b7fbe8
separate regular and disksave finalization, print method fixes.
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
1317 common type of internal objects, which have no equal or hash method |
|
623d57b7fbe8
separate regular and disksave finalization, print method fixes.
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
1318 (since they generally won't appear in hash tables), no finalizer and |
|
623d57b7fbe8
separate regular and disksave finalization, print method fixes.
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
1319 internal_object_printer() as their print method (which prints that the |
|
623d57b7fbe8
separate regular and disksave finalization, print method fixes.
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
1320 object is internal and shouldn't be visible externally). For internal |
|
623d57b7fbe8
separate regular and disksave finalization, print method fixes.
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
1321 objects needing a finalizer, equal or hash method, or wanting to |
|
623d57b7fbe8
separate regular and disksave finalization, print method fixes.
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
1322 customize the print method, use the normal DEFINE_*_LISP_OBJECT |
|
623d57b7fbe8
separate regular and disksave finalization, print method fixes.
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
1323 mechanism for defining these objects. |
|
5120
d1247f3cc363
latest work on lisp-object workspace;
Ben Wing <ben@xemacs.org>
parents:
5118
diff
changeset
|
1324 |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
1325 DEFINE_MODULE_* is for objects defined in an external module. |
|
5117
3742ea8250b5
Checking in final CVS version of workspace 'ben-lisp-object'
Ben Wing <ben@xemacs.org>
parents:
3063
diff
changeset
|
1326 |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
1327 MAKE_LISP_OBJECT and MAKE_MODULE_LISP_OBJECT are what underlies all of |
|
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
1328 these; they define a structure containing pointers to object methods |
|
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
1329 and other info such as the size of the structure containing the object. |
| 428 | 1330 */ |
| 1331 | |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
1332 /* #### FIXME What's going on here? */ |
| 800 | 1333 #if defined (ERROR_CHECK_TYPES) |
| 1334 # define DECLARE_ERROR_CHECK_TYPES(c_name, structtype) | |
| 428 | 1335 #else |
| 800 | 1336 # define DECLARE_ERROR_CHECK_TYPES(c_name, structtype) |
| 428 | 1337 #endif |
| 1338 | |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
1339 /********* The dumpable versions *********** */ |
| 934 | 1340 |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
1341 #define DEFINE_DUMPABLE_LISP_OBJECT(name,c_name,marker,printer,nuker,equal,hash,desc,structtype) \ |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1342 MAKE_LISP_OBJECT(name,c_name,1 /*dumpable*/,marker,printer,nuker,equal,hash,desc,sizeof (structtype),0,0,structtype) |
| 934 | 1343 |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
1344 #define DEFINE_DUMPABLE_SIZABLE_LISP_OBJECT(name,c_name,marker,printer,nuker,equal,hash,desc,sizer,structtype) \ |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1345 MAKE_LISP_OBJECT(name,c_name,1 /*dumpable*/,marker,printer,nuker,equal,hash,desc,0,sizer,0,structtype) |
| 934 | 1346 |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
1347 #define DEFINE_DUMPABLE_FROB_BLOCK_LISP_OBJECT(name,c_name,marker,printer,nuker,equal,hash,desc,structtype) \ |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1348 MAKE_LISP_OBJECT(name,c_name,1 /*dumpable*/,marker,printer,nuker,equal,hash,desc,sizeof(structtype),0,1,structtype) |
| 934 | 1349 |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
1350 #define DEFINE_DUMPABLE_FROB_BLOCK_SIZABLE_LISP_OBJECT(name,c_name,marker,printer,nuker,equal,hash,desc,sizer,structtype) \ |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1351 MAKE_LISP_OBJECT(name,c_name,1 /*dumpable*/,marker,printer,nuker,equal,hash,desc,0,sizer,1,structtype) |
|
5117
3742ea8250b5
Checking in final CVS version of workspace 'ben-lisp-object'
Ben Wing <ben@xemacs.org>
parents:
3063
diff
changeset
|
1352 |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
1353 #define DEFINE_DUMPABLE_INTERNAL_LISP_OBJECT(name,c_name,marker,desc,structtype) \ |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1354 DEFINE_DUMPABLE_LISP_OBJECT(name,c_name,marker,internal_object_printer,0,0,0,desc,structtype) |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
1355 |
|
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
1356 #define DEFINE_DUMPABLE_SIZABLE_INTERNAL_LISP_OBJECT(name,c_name,marker,desc,sizer,structtype) \ |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1357 DEFINE_DUMPABLE_SIZABLE_LISP_OBJECT(name,c_name,marker,internal_object_printer,0,0,0,desc,sizer,structtype) |
| 934 | 1358 |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
1359 /********* The non-dumpable versions *********** */ |
| 934 | 1360 |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
1361 #define DEFINE_NODUMP_LISP_OBJECT(name,c_name,marker,printer,nuker,equal,hash,desc,structtype) \ |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1362 MAKE_LISP_OBJECT(name,c_name,0 /*non-dumpable*/,marker,printer,nuker,equal,hash,desc,sizeof (structtype),0,0,structtype) |
|
5117
3742ea8250b5
Checking in final CVS version of workspace 'ben-lisp-object'
Ben Wing <ben@xemacs.org>
parents:
3063
diff
changeset
|
1363 |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
1364 #define DEFINE_NODUMP_SIZABLE_LISP_OBJECT(name,c_name,marker,printer,nuker,equal,hash,desc,sizer,structtype) \ |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1365 MAKE_LISP_OBJECT(name,c_name,0 /*non-dumpable*/,marker,printer,nuker,equal,hash,desc,0,sizer,0,structtype) |
| 934 | 1366 |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
1367 #define DEFINE_NODUMP_FROB_BLOCK_LISP_OBJECT(name,c_name,marker,printer,nuker,equal,hash,desc,structtype) \ |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1368 MAKE_LISP_OBJECT(name,c_name,0 /*non-dumpable*/,marker,printer,nuker,equal,hash,desc,sizeof(structtype),0,1,structtype) |
| 934 | 1369 |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
1370 #define DEFINE_NODUMP_FROB_BLOCK_SIZABLE_LISP_OBJECT(name,c_name,marker,printer,nuker,equal,hash,desc,sizer,structtype) \ |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1371 MAKE_LISP_OBJECT(name,c_name,0 /*non-dumpable*/,marker,printer,nuker,equal,hash,desc,0,sizer,1,structtype) |
|
5117
3742ea8250b5
Checking in final CVS version of workspace 'ben-lisp-object'
Ben Wing <ben@xemacs.org>
parents:
3063
diff
changeset
|
1372 |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
1373 #define DEFINE_NODUMP_INTERNAL_LISP_OBJECT(name,c_name,marker,desc,structtype) \ |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1374 DEFINE_NODUMP_LISP_OBJECT(name,c_name,marker,internal_object_printer,0,0,0,desc,structtype) |
| 934 | 1375 |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
1376 #define DEFINE_NODUMP_SIZABLE_INTERNAL_LISP_OBJECT(name,c_name,marker,desc,sizer,structtype) \ |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1377 DEFINE_NODUMP_SIZABLE_LISP_OBJECT(name,c_name,marker,internal_object_printer,0,0,0,desc,sizer,structtype) |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
1378 |
|
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
1379 /********* MAKE_LISP_OBJECT, the underlying macro *********** */ |
| 934 | 1380 |
| 3263 | 1381 #ifdef NEW_GC |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1382 #define MAKE_LISP_OBJECT(name,c_name,dumpable,marker,printer,nuker, \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1383 equal,hash,desc,size,sizer,frob_block_p,structtype) \ |
| 2720 | 1384 DECLARE_ERROR_CHECK_TYPES(c_name, structtype) \ |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1385 struct lrecord_implementation lrecord_##c_name = \ |
| 2720 | 1386 { name, dumpable, marker, printer, nuker, equal, hash, desc, \ |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1387 size, sizer, lrecord_type_##c_name } |
| 3263 | 1388 #else /* not NEW_GC */ |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1389 #define MAKE_LISP_OBJECT(name,c_name,dumpable,marker,printer,nuker,equal,hash,desc,size,sizer,frob_block_p,structtype) \ |
| 1204 | 1390 DECLARE_ERROR_CHECK_TYPES(c_name, structtype) \ |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1391 struct lrecord_implementation lrecord_##c_name = \ |
| 934 | 1392 { name, dumpable, marker, printer, nuker, equal, hash, desc, \ |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1393 size, sizer, lrecord_type_##c_name, frob_block_p } |
| 3263 | 1394 #endif /* not NEW_GC */ |
| 934 | 1395 |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
1396 |
|
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
1397 /********* The module dumpable versions *********** */ |
|
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
1398 |
|
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
1399 #define DEFINE_DUMPABLE_MODULE_LISP_OBJECT(name,c_name,dumpable,marker,printer,nuker,equal,hash,desc,structtype) \ |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1400 MAKE_MODULE_LISP_OBJECT(name,c_name,1 /*dumpable*/,marker,printer,nuker,equal,hash,desc,sizeof (structtype),0,0,structtype) |
| 934 | 1401 |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
1402 #define DEFINE_DUMPABLE_MODULE_SIZABLE_LISP_OBJECT(name,c_name,dumpable,marker,printer,nuker,equal,hash,desc,sizer,structtype) \ |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1403 MAKE_MODULE_LISP_OBJECT(name,c_name,1 /*dumpable*/,marker,printer,nuker,equal,hash,desc,0,sizer,0,structtype) |
| 934 | 1404 |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
1405 /********* The module non-dumpable versions *********** */ |
|
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
1406 |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1407 #define DEFINE_NODUMP_MODULE_LISP_OBJECT(name,c_name,dumpable,marker, \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1408 printer,nuker,equal,hash,desc,structtype) \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1409 MAKE_MODULE_LISP_OBJECT(name,c_name,0 /*non-dumpable*/,marker,printer, \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1410 nuker,equal,hash,desc,sizeof (structtype),0,0,structtype) |
| 934 | 1411 |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1412 #define DEFINE_NODUMP_MODULE_SIZABLE_LISP_OBJECT(name,c_name,dumpable, \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1413 marker,printer,nuker,equal,hash,desc,sizer,structtype) \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1414 MAKE_MODULE_LISP_OBJECT(name,c_name,0 /*non-dumpable*/,marker,printer, \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1415 nuker,equal,hash,desc,0,sizer,0,structtype) |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
1416 |
|
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
1417 /********* MAKE_MODULE_LISP_OBJECT, the underlying macro *********** */ |
| 934 | 1418 |
| 3263 | 1419 #ifdef NEW_GC |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1420 #define MAKE_MODULE_LISP_OBJECT(name,c_name,dumpable,marker,printer, \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1421 nuker,equal,hash,desc,size,sizer,frob_block_p,structtype) \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1422 DECLARE_ERROR_CHECK_TYPES(c_name, structtype) \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1423 int lrecord_type_##c_name; \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1424 struct lrecord_implementation lrecord_##c_name = \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1425 { name, dumpable, marker, printer, nuker, equal, hash, desc, \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1426 size, sizer, lrecord_type_last_built_in_type } |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1427 #else /* not NEW_GC */ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1428 #define MAKE_MODULE_LISP_OBJECT(name,c_name,dumpable,marker,printer, \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1429 nuker,equal,hash,desc,size,sizer,frob_block_p,structtype) \ |
| 2720 | 1430 DECLARE_ERROR_CHECK_TYPES(c_name, structtype) \ |
| 1431 int lrecord_type_##c_name; \ | |
| 1432 struct lrecord_implementation lrecord_##c_name = \ | |
| 1433 { name, dumpable, marker, printer, nuker, equal, hash, desc, \ | |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1434 size, sizer, lrecord_type_last_built_in_type, frob_block_p } |
| 3263 | 1435 #endif /* not NEW_GC */ |
| 934 | 1436 |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1437 #ifdef MEMORY_USAGE_STATS |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1438 #define INIT_MEMORY_USAGE_STATS(type) \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1439 do \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1440 { \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1441 lrecord_implementations_table[lrecord_type_##type]-> \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1442 memusage_stats_list = Qnil; \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1443 lrecord_implementations_table[lrecord_type_##type]-> \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1444 num_extra_memusage_stats = -1; \ |
|
5158
9e0b43d3095c
more cleanups to object-memory-usage stuff
Ben Wing <ben@xemacs.org>
parents:
5157
diff
changeset
|
1445 lrecord_implementations_table[lrecord_type_##type]-> \ |
|
9e0b43d3095c
more cleanups to object-memory-usage stuff
Ben Wing <ben@xemacs.org>
parents:
5157
diff
changeset
|
1446 num_extra_nonlisp_memusage_stats = -1; \ |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1447 staticpro (&lrecord_implementations_table[lrecord_type_##type]-> \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1448 memusage_stats_list); \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1449 } while (0) |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1450 #else |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1451 #define INIT_MEMORY_USAGE_STATS(type) DO_NOTHING |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1452 #endif /* (not) MEMORY_USAGE_STATS */ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1453 |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1454 #define INIT_LISP_OBJECT_BEGINNING(type) \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1455 do \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1456 { \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1457 lrecord_implementations_table[lrecord_type_##type] = &lrecord_##type; \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1458 INIT_MEMORY_USAGE_STATS (type); \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1459 } while (0) |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1460 |
| 1676 | 1461 #ifdef USE_KKCC |
| 1462 extern MODULE_API const struct memory_description *lrecord_memory_descriptions[]; | |
| 1463 | |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1464 #define INIT_LISP_OBJECT(type) do { \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1465 INIT_LISP_OBJECT_BEGINNING (type); \ |
| 1676 | 1466 lrecord_memory_descriptions[lrecord_type_##type] = \ |
| 1467 lrecord_implementations_table[lrecord_type_##type]->description; \ | |
| 1468 } while (0) | |
| 1469 #else /* not USE_KKCC */ | |
| 1632 | 1470 extern MODULE_API Lisp_Object (*lrecord_markers[]) (Lisp_Object); |
| 442 | 1471 |
|
5117
3742ea8250b5
Checking in final CVS version of workspace 'ben-lisp-object'
Ben Wing <ben@xemacs.org>
parents:
3063
diff
changeset
|
1472 #define INIT_LISP_OBJECT(type) do { \ |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1473 INIT_LISP_OBJECT_BEGINNING (type); \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1474 lrecord_markers[lrecord_type_##type] = \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1475 lrecord_implementations_table[lrecord_type_##type]->marker; \ |
| 442 | 1476 } while (0) |
| 1676 | 1477 #endif /* not USE_KKCC */ |
| 428 | 1478 |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
1479 #define INIT_MODULE_LISP_OBJECT(type) do { \ |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1480 lrecord_type_##type = lrecord_type_count++; \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1481 lrecord_##type.lrecord_type_index = lrecord_type_##type; \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1482 INIT_LISP_OBJECT (type); \ |
| 444 | 1483 } while (0) |
| 1484 | |
| 996 | 1485 #ifdef HAVE_SHLIB |
| 1486 /* Allow undefining types in order to support module unloading. */ | |
| 1487 | |
| 1676 | 1488 #ifdef USE_KKCC |
|
5117
3742ea8250b5
Checking in final CVS version of workspace 'ben-lisp-object'
Ben Wing <ben@xemacs.org>
parents:
3063
diff
changeset
|
1489 #define UNDEF_LISP_OBJECT(type) do { \ |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1490 lrecord_implementations_table[lrecord_type_##type] = NULL; \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1491 lrecord_memory_descriptions[lrecord_type_##type] = NULL; \ |
| 1676 | 1492 } while (0) |
| 1493 #else /* not USE_KKCC */ | |
|
5117
3742ea8250b5
Checking in final CVS version of workspace 'ben-lisp-object'
Ben Wing <ben@xemacs.org>
parents:
3063
diff
changeset
|
1494 #define UNDEF_LISP_OBJECT(type) do { \ |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1495 lrecord_implementations_table[lrecord_type_##type] = NULL; \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1496 lrecord_markers[lrecord_type_##type] = NULL; \ |
| 996 | 1497 } while (0) |
| 1676 | 1498 #endif /* not USE_KKCC */ |
| 996 | 1499 |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1500 #define UNDEF_MODULE_LISP_OBJECT(type) do { \ |
| 996 | 1501 if (lrecord_##type.lrecord_type_index == lrecord_type_count - 1) { \ |
| 1502 /* This is the most recently defined type. Clean up nicely. */ \ | |
| 1503 lrecord_type_##type = lrecord_type_count--; \ | |
| 1504 } /* Else we can't help leaving a hole with this implementation. */ \ | |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1505 UNDEF_LISP_OBJECT(type); \ |
| 996 | 1506 } while (0) |
| 1507 | |
| 1508 #endif /* HAVE_SHLIB */ | |
| 1509 | |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1510 /*************** Macros for declaring that a Lisp object has a |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1511 particular method, or for calling such a method. ********/ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1512 |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1513 /* Declare that object-type TYPE has method M; used in |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1514 initialization routines */ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1515 #define OBJECT_HAS_METHOD(type, m) \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1516 (lrecord_##type.m = type##_##m) |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1517 /* Same but the method name come before the type */ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1518 #define OBJECT_HAS_PREMETHOD(type, m) \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1519 (lrecord_##type.m = m##_##type) |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1520 /* Same but the name of the method is explicitly given */ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1521 #define OBJECT_HAS_NAMED_METHOD(type, m, func) \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1522 (lrecord_##type.m = (func)) |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1523 /* Object type has a property with the given value. */ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1524 #define OBJECT_HAS_PROPERTY(type, prop, val) \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1525 (lrecord_##type.prop = (val)) |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1526 |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1527 /* Does the given object method exist? */ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1528 #define HAS_OBJECT_METH_P(obj, m) \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1529 (!!(XRECORD_LHEADER_IMPLEMENTATION (obj)->m)) |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1530 /* Call an object method. */ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1531 #define OBJECT_METH(obj, m, args) \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1532 ((XRECORD_LHEADER_IMPLEMENTATION (obj)->m) args) |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1533 |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1534 /* Call an object method, if it exists. */ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1535 #define MAYBE_OBJECT_METH(obj, m, args) \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1536 do \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1537 { \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1538 const struct lrecord_implementation *_mom_imp = \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1539 XRECORD_LHEADER_IMPLEMENTATION (obj); \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1540 if (_mom_imp->m) \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1541 ((_mom_imp->m) args); \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1542 } while (0) |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1543 |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1544 /* Call an object method, if it exists, or return GIVEN. NOTE: |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1545 Multiply-evaluates OBJ. */ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1546 #define OBJECT_METH_OR_GIVEN(obj, m, args, given) \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1547 (HAS_OBJECT_METH_P (obj, m) ? OBJECT_METH (obj, m, args) : (given)) |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1548 |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1549 #define OBJECT_PROPERTY(obj, prop) (XRECORD_LHEADER_IMPLEMENTATION (obj)->prop) |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1550 |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1551 /************** Other stuff **************/ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1552 |
| 428 | 1553 #define LRECORDP(a) (XTYPE (a) == Lisp_Type_Record) |
| 1554 #define XRECORD_LHEADER(a) ((struct lrecord_header *) XPNTR (a)) | |
| 1555 | |
| 1556 #define RECORD_TYPEP(x, ty) \ | |
| 647 | 1557 (LRECORDP (x) && (XRECORD_LHEADER (x)->type == (unsigned int) (ty))) |
| 442 | 1558 |
| 1559 /* Steps to create a new object: | |
| 1560 | |
| 1561 1. Declare the struct for your object in a header file somewhere. | |
| 1562 Remember that it must begin with | |
| 1563 | |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1564 NORMAL_LISP_OBJECT_HEADER header; |
| 442 | 1565 |
|
5120
d1247f3cc363
latest work on lisp-object workspace;
Ben Wing <ben@xemacs.org>
parents:
5118
diff
changeset
|
1566 2. Put the "standard junk" (DECLARE_LISP_OBJECT()/XFOO/etc.) below the |
| 617 | 1567 struct definition -- see below. |
| 442 | 1568 |
| 1569 3. Add this header file to inline.c. | |
| 1570 | |
| 1571 4. Create the methods for your object. Note that technically you don't | |
| 1572 need any, but you will almost always want at least a mark method. | |
| 1573 | |
| 1204 | 1574 4. Create the data layout description for your object. See |
| 1575 toolbar_button_description below; the comment above in `struct lrecord', | |
| 1576 describing the purpose of the descriptions; and comments elsewhere in | |
| 1577 this file describing the exact syntax of the description structures. | |
| 1578 | |
|
5120
d1247f3cc363
latest work on lisp-object workspace;
Ben Wing <ben@xemacs.org>
parents:
5118
diff
changeset
|
1579 6. Define your object with DEFINE_*_LISP_OBJECT() or some |
|
d1247f3cc363
latest work on lisp-object workspace;
Ben Wing <ben@xemacs.org>
parents:
5118
diff
changeset
|
1580 variant. At the minimum, you need to decide whether your object can |
|
d1247f3cc363
latest work on lisp-object workspace;
Ben Wing <ben@xemacs.org>
parents:
5118
diff
changeset
|
1581 be dumped. Objects that are created as part of the loadup process and |
|
d1247f3cc363
latest work on lisp-object workspace;
Ben Wing <ben@xemacs.org>
parents:
5118
diff
changeset
|
1582 need to be persistent across dumping should be created dumpable. |
|
d1247f3cc363
latest work on lisp-object workspace;
Ben Wing <ben@xemacs.org>
parents:
5118
diff
changeset
|
1583 Nondumpable objects are generally those associated with display, |
|
d1247f3cc363
latest work on lisp-object workspace;
Ben Wing <ben@xemacs.org>
parents:
5118
diff
changeset
|
1584 particularly those containing a pointer to an external library object |
|
d1247f3cc363
latest work on lisp-object workspace;
Ben Wing <ben@xemacs.org>
parents:
5118
diff
changeset
|
1585 (e.g. a window-system window). |
| 442 | 1586 |
| 1204 | 1587 7. Include the header file in the .c file where you defined the object. |
| 442 | 1588 |
|
5117
3742ea8250b5
Checking in final CVS version of workspace 'ben-lisp-object'
Ben Wing <ben@xemacs.org>
parents:
3063
diff
changeset
|
1589 8. Put a call to INIT_LISP_OBJECT() for the object in the |
| 442 | 1590 .c file's syms_of_foo() function. |
| 1591 | |
| 1204 | 1592 9. Add a type enum for the object to enum lrecord_type, earlier in this |
| 442 | 1593 file. |
| 1594 | |
| 1204 | 1595 --ben |
| 1596 | |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1597 An example: |
| 428 | 1598 |
| 442 | 1599 ------------------------------ in toolbar.h ----------------------------- |
| 1600 | |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1601 struct toolbar_button |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1602 { |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1603 NORMAL_LISP_OBJECT_HEADER header; |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1604 |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1605 Lisp_Object next; |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1606 Lisp_Object frame; |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1607 |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1608 Lisp_Object up_glyph; |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1609 Lisp_Object down_glyph; |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1610 Lisp_Object disabled_glyph; |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1611 |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1612 Lisp_Object cap_up_glyph; |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1613 Lisp_Object cap_down_glyph; |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1614 Lisp_Object cap_disabled_glyph; |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1615 |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1616 Lisp_Object callback; |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1617 Lisp_Object enabled_p; |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1618 Lisp_Object help_string; |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1619 |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1620 char enabled; |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1621 char down; |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1622 char pushright; |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1623 char blank; |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1624 |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1625 int x, y; |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1626 int width, height; |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1627 int dirty; |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1628 int vertical; |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1629 int border_width; |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1630 }; |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1631 |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1632 [[ the standard junk: ]] |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1633 |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1634 DECLARE_LISP_OBJECT (toolbar_button, struct toolbar_button); |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1635 #define XTOOLBAR_BUTTON(x) XRECORD (x, toolbar_button, struct toolbar_button) |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1636 #define wrap_toolbar_button(p) wrap_record (p, toolbar_button) |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1637 #define TOOLBAR_BUTTONP(x) RECORDP (x, toolbar_button) |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1638 #define CHECK_TOOLBAR_BUTTON(x) CHECK_RECORD (x, toolbar_button) |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1639 #define CONCHECK_TOOLBAR_BUTTON(x) CONCHECK_RECORD (x, toolbar_button) |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1640 |
| 442 | 1641 ------------------------------ in toolbar.c ----------------------------- |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1642 |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1643 #include "toolbar.h" |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1644 |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1645 ... |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1646 |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1647 static const struct memory_description toolbar_button_description [] = { |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1648 { XD_LISP_OBJECT, offsetof (struct toolbar_button, next) }, |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1649 { XD_LISP_OBJECT, offsetof (struct toolbar_button, frame) }, |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1650 { XD_LISP_OBJECT, offsetof (struct toolbar_button, up_glyph) }, |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1651 { XD_LISP_OBJECT, offsetof (struct toolbar_button, down_glyph) }, |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1652 { XD_LISP_OBJECT, offsetof (struct toolbar_button, disabled_glyph) }, |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1653 { XD_LISP_OBJECT, offsetof (struct toolbar_button, cap_up_glyph) }, |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1654 { XD_LISP_OBJECT, offsetof (struct toolbar_button, cap_down_glyph) }, |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1655 { XD_LISP_OBJECT, offsetof (struct toolbar_button, cap_disabled_glyph) }, |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1656 { XD_LISP_OBJECT, offsetof (struct toolbar_button, callback) }, |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1657 { XD_LISP_OBJECT, offsetof (struct toolbar_button, enabled_p) }, |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1658 { XD_LISP_OBJECT, offsetof (struct toolbar_button, help_string) }, |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1659 { XD_END } |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1660 }; |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1661 |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1662 static Lisp_Object |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1663 allocate_toolbar_button (struct frame *f, int pushright) |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1664 { |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1665 struct toolbar_button *tb; |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1666 |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1667 tb = XTOOLBAR_BUTTON (ALLOC_NORMAL_LISP_OBJECT (toolbar_button)); |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1668 tb->next = Qnil; |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1669 tb->frame = wrap_frame (f); |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1670 tb->up_glyph = Qnil; |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1671 tb->down_glyph = Qnil; |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1672 tb->disabled_glyph = Qnil; |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1673 tb->cap_up_glyph = Qnil; |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1674 tb->cap_down_glyph = Qnil; |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1675 tb->cap_disabled_glyph = Qnil; |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1676 tb->callback = Qnil; |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1677 tb->enabled_p = Qnil; |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1678 tb->help_string = Qnil; |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1679 |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1680 tb->pushright = pushright; |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1681 tb->x = tb->y = tb->width = tb->height = -1; |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1682 tb->dirty = 1; |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1683 |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1684 return wrap_toolbar_button (tb); |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1685 } |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1686 |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1687 static Lisp_Object |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1688 mark_toolbar_button (Lisp_Object obj) |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1689 { |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1690 struct toolbar_button *data = XTOOLBAR_BUTTON (obj); |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1691 mark_object (data->next); |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1692 mark_object (data->frame); |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1693 mark_object (data->up_glyph); |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1694 mark_object (data->down_glyph); |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1695 mark_object (data->disabled_glyph); |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1696 mark_object (data->cap_up_glyph); |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1697 mark_object (data->cap_down_glyph); |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1698 mark_object (data->cap_disabled_glyph); |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1699 mark_object (data->callback); |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1700 mark_object (data->enabled_p); |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1701 return data->help_string; |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1702 } |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1703 |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1704 DEFINE_NODUMP_LISP_OBJECT ("toolbar-button", toolbar_button, |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1705 mark_toolbar_button, |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1706 external_object_printer, 0, 0, 0, |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1707 toolbar_button_description, |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1708 struct toolbar_button); |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1709 |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1710 ... |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1711 |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1712 void |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1713 syms_of_toolbar (void) |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1714 { |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1715 INIT_LISP_OBJECT (toolbar_button); |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1716 |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1717 ...; |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1718 } |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1719 |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1720 ------------------------------ in inline.c ----------------------------- |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1721 |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1722 #ifdef HAVE_TOOLBARS |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1723 #include "toolbar.h" |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1724 #endif |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1725 |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1726 ------------------------------ in lrecord.h ----------------------------- |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1727 |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1728 enum lrecord_type |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1729 { |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1730 ... |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1731 lrecord_type_toolbar_button, |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1732 ... |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1733 }; |
| 442 | 1734 |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1735 ------------------------------ in .gdbinit.in.in ----------------------------- |
| 442 | 1736 |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1737 ... |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1738 else |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1739 if $lrecord_type == lrecord_type_toolbar_button |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1740 pstructtype toolbar_button |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1741 ... |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1742 ... |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1743 ... |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1744 end |
| 442 | 1745 |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1746 --ben |
| 1204 | 1747 |
| 442 | 1748 */ |
| 1749 | |
| 1750 /* | |
| 1751 | |
| 1752 Note: Object types defined in external dynamically-loaded modules (not | |
|
5120
d1247f3cc363
latest work on lisp-object workspace;
Ben Wing <ben@xemacs.org>
parents:
5118
diff
changeset
|
1753 part of the XEmacs main source code) should use DECLARE_*_MODULE_LISP_OBJECT |
|
d1247f3cc363
latest work on lisp-object workspace;
Ben Wing <ben@xemacs.org>
parents:
5118
diff
changeset
|
1754 and DEFINE_*_MODULE_LISP_OBJECT rather than DECLARE_*_LISP_OBJECT |
|
d1247f3cc363
latest work on lisp-object workspace;
Ben Wing <ben@xemacs.org>
parents:
5118
diff
changeset
|
1755 and DEFINE_*_LISP_OBJECT. The MODULE versions declare and |
| 3029 | 1756 allocate an enumerator for the type being defined. |
| 442 | 1757 |
| 1758 */ | |
| 1759 | |
| 428 | 1760 |
| 800 | 1761 #ifdef ERROR_CHECK_TYPES |
| 428 | 1762 |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1763 # define DECLARE_LISP_OBJECT(c_name, structtype) \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1764 extern struct lrecord_implementation lrecord_##c_name; \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1765 DECLARE_INLINE_HEADER ( \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1766 structtype * \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1767 error_check_##c_name (Lisp_Object obj, const Ascbyte *file, int line) \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1768 ) \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1769 { \ |
| 788 | 1770 assert_at_line (RECORD_TYPEP (obj, lrecord_type_##c_name), file, line); \ |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1771 return (structtype *) XPNTR (obj); \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1772 } \ |
| 428 | 1773 extern Lisp_Object Q##c_name##p |
| 1774 | |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1775 # define DECLARE_MODULE_API_LISP_OBJECT(c_name, structtype) \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1776 extern MODULE_API struct lrecord_implementation lrecord_##c_name; \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1777 DECLARE_INLINE_HEADER ( \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1778 structtype * \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1779 error_check_##c_name (Lisp_Object obj, const Ascbyte *file, int line) \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1780 ) \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1781 { \ |
| 1632 | 1782 assert_at_line (RECORD_TYPEP (obj, lrecord_type_##c_name), file, line); \ |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1783 return (structtype *) XPNTR (obj); \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1784 } \ |
| 1632 | 1785 extern MODULE_API Lisp_Object Q##c_name##p |
| 1786 | |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1787 # define DECLARE_MODULE_LISP_OBJECT(c_name, structtype) \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1788 extern int lrecord_type_##c_name; \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1789 extern struct lrecord_implementation lrecord_##c_name; \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1790 DECLARE_INLINE_HEADER ( \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1791 structtype * \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1792 error_check_##c_name (Lisp_Object obj, const Ascbyte *file, int line) \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1793 ) \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1794 { \ |
| 788 | 1795 assert_at_line (RECORD_TYPEP (obj, lrecord_type_##c_name), file, line); \ |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1796 return (structtype *) XPNTR (obj); \ |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1797 } \ |
| 444 | 1798 extern Lisp_Object Q##c_name##p |
| 442 | 1799 |
| 788 | 1800 # define XRECORD(x, c_name, structtype) \ |
| 1801 error_check_##c_name (x, __FILE__, __LINE__) | |
| 428 | 1802 |
| 826 | 1803 DECLARE_INLINE_HEADER ( |
| 1804 Lisp_Object | |
| 2367 | 1805 wrap_record_1 (const void *ptr, enum lrecord_type ty, const Ascbyte *file, |
| 800 | 1806 int line) |
| 826 | 1807 ) |
| 617 | 1808 { |
| 793 | 1809 Lisp_Object obj = wrap_pointer_1 (ptr); |
| 1810 | |
| 788 | 1811 assert_at_line (RECORD_TYPEP (obj, ty), file, line); |
| 617 | 1812 return obj; |
| 1813 } | |
| 1814 | |
| 788 | 1815 #define wrap_record(ptr, ty) \ |
| 1816 wrap_record_1 (ptr, lrecord_type_##ty, __FILE__, __LINE__) | |
| 617 | 1817 |
| 800 | 1818 #else /* not ERROR_CHECK_TYPES */ |
| 428 | 1819 |
|
5120
d1247f3cc363
latest work on lisp-object workspace;
Ben Wing <ben@xemacs.org>
parents:
5118
diff
changeset
|
1820 # define DECLARE_LISP_OBJECT(c_name, structtype) \ |
| 428 | 1821 extern Lisp_Object Q##c_name##p; \ |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1822 extern struct lrecord_implementation lrecord_##c_name |
|
5120
d1247f3cc363
latest work on lisp-object workspace;
Ben Wing <ben@xemacs.org>
parents:
5118
diff
changeset
|
1823 # define DECLARE_MODULE_API_LISP_OBJECT(c_name, structtype) \ |
|
d1247f3cc363
latest work on lisp-object workspace;
Ben Wing <ben@xemacs.org>
parents:
5118
diff
changeset
|
1824 extern MODULE_API Lisp_Object Q##c_name##p; \ |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1825 extern MODULE_API struct lrecord_implementation lrecord_##c_name |
|
5120
d1247f3cc363
latest work on lisp-object workspace;
Ben Wing <ben@xemacs.org>
parents:
5118
diff
changeset
|
1826 # define DECLARE_MODULE_LISP_OBJECT(c_name, structtype) \ |
| 442 | 1827 extern Lisp_Object Q##c_name##p; \ |
| 647 | 1828 extern int lrecord_type_##c_name; \ |
| 444 | 1829 extern struct lrecord_implementation lrecord_##c_name |
| 428 | 1830 # define XRECORD(x, c_name, structtype) ((structtype *) XPNTR (x)) |
| 617 | 1831 /* wrap_pointer_1 is so named as a suggestion not to use it unless you |
| 1832 know what you're doing. */ | |
| 1833 #define wrap_record(ptr, ty) wrap_pointer_1 (ptr) | |
| 428 | 1834 |
| 800 | 1835 #endif /* not ERROR_CHECK_TYPES */ |
| 428 | 1836 |
| 442 | 1837 #define RECORDP(x, c_name) RECORD_TYPEP (x, lrecord_type_##c_name) |
| 428 | 1838 |
| 1839 /* Note: we now have two different kinds of type-checking macros. | |
| 1840 The "old" kind has now been renamed CONCHECK_foo. The reason for | |
| 1841 this is that the CONCHECK_foo macros signal a continuable error, | |
| 1842 allowing the user (through debug-on-error) to substitute a different | |
| 1843 value and return from the signal, which causes the lvalue argument | |
| 1844 to get changed. Quite a lot of code would crash if that happened, | |
| 1845 because it did things like | |
| 1846 | |
| 1847 foo = XCAR (list); | |
| 1848 CHECK_STRING (foo); | |
| 1849 | |
| 1850 and later on did XSTRING (XCAR (list)), assuming that the type | |
| 1851 is correct (when it might be wrong, if the user substituted a | |
| 1852 correct value in the debugger). | |
| 1853 | |
| 1854 To get around this, I made all the CHECK_foo macros signal a | |
| 1855 non-continuable error. Places where a continuable error is OK | |
| 1856 (generally only when called directly on the argument of a Lisp | |
| 1857 primitive) should be changed to use CONCHECK(). | |
| 1858 | |
| 1859 FSF Emacs does not have this problem because RMS took the cheesy | |
| 1860 way out and disabled returning from a signal entirely. */ | |
| 1861 | |
| 1862 #define CONCHECK_RECORD(x, c_name) do { \ | |
| 442 | 1863 if (!RECORD_TYPEP (x, lrecord_type_##c_name)) \ |
| 428 | 1864 x = wrong_type_argument (Q##c_name##p, x); \ |
| 1865 } while (0) | |
| 1866 #define CONCHECK_NONRECORD(x, lisp_enum, predicate) do {\ | |
| 1867 if (XTYPE (x) != lisp_enum) \ | |
| 1868 x = wrong_type_argument (predicate, x); \ | |
| 1869 } while (0) | |
| 1870 #define CHECK_RECORD(x, c_name) do { \ | |
| 442 | 1871 if (!RECORD_TYPEP (x, lrecord_type_##c_name)) \ |
| 428 | 1872 dead_wrong_type_argument (Q##c_name##p, x); \ |
| 1873 } while (0) | |
| 1874 #define CHECK_NONRECORD(x, lisp_enum, predicate) do { \ | |
| 1875 if (XTYPE (x) != lisp_enum) \ | |
| 1876 dead_wrong_type_argument (predicate, x); \ | |
| 1877 } while (0) | |
| 1878 | |
| 3263 | 1879 #ifndef NEW_GC |
| 1204 | 1880 /*-------------------------- lcrecord-list -----------------------------*/ |
| 1881 | |
| 1882 struct lcrecord_list | |
| 1883 { | |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1884 NORMAL_LISP_OBJECT_HEADER header; |
| 1204 | 1885 Lisp_Object free; |
| 1886 Elemcount size; | |
| 1887 const struct lrecord_implementation *implementation; | |
| 1888 }; | |
| 1889 | |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
1890 DECLARE_LISP_OBJECT (lcrecord_list, struct lcrecord_list); |
| 1204 | 1891 #define XLCRECORD_LIST(x) XRECORD (x, lcrecord_list, struct lcrecord_list) |
| 1892 #define wrap_lcrecord_list(p) wrap_record (p, lcrecord_list) | |
| 1893 #define LCRECORD_LISTP(x) RECORDP (x, lcrecord_list) | |
| 1894 /* #define CHECK_LCRECORD_LIST(x) CHECK_RECORD (x, lcrecord_list) | |
| 1895 Lcrecord lists should never escape to the Lisp level, so | |
| 1896 functions should not be doing this. */ | |
| 1897 | |
| 826 | 1898 /* Various ways of allocating lcrecords. All bytes (except lcrecord |
| 1204 | 1899 header) are zeroed in returned structure. |
| 1900 | |
| 1901 See above for a discussion of the difference between plain lrecords and | |
| 1902 lrecords. lcrecords themselves are divided into three types: (1) | |
| 1903 auto-managed, (2) hand-managed, and (3) unmanaged. "Managed" refers to | |
| 1904 using a special object called an lcrecord-list to keep track of freed | |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1905 lcrecords, which can freed with free_normal_lisp_object() or the like |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1906 and later be recycled when a new lcrecord is required, rather than |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1907 requiring new malloc(). Thus, allocation of lcrecords can be very |
| 1204 | 1908 cheap. (Technically, the lcrecord-list manager could divide up large |
| 1909 chunks of memory and allocate out of that, mimicking what happens with | |
| 1910 lrecords. At that point, however, we'd want to rethink the whole | |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1911 division between lrecords and lcrecords.) |
| 1204 | 1912 |
| 1913 NOTE: There is a fundamental limitation of lcrecord-lists, which is that | |
| 1914 they only handle blocks of a particular, fixed size. Thus, objects that | |
| 1915 can be of varying sizes need to do various tricks. These considerations | |
| 1916 in particular dictate the various types of management: | |
| 1917 | |
| 1918 -- "Auto-managed" means that you just go ahead and allocate the lcrecord | |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1919 whenever you want, using ALLOC_NORMAL_LISP_OBJECT(), and the appropriate |
| 1204 | 1920 lcrecord-list manager is automatically created. To free, you just call |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
1921 "free_normal_lisp_object()" and the appropriate lcrecord-list manager is |
| 1204 | 1922 automatically located and called. The limitation here of course is that |
| 1923 all your objects are of the same size. (#### Eventually we should have a | |
| 1924 more sophisticated system that tracks the sizes seen and creates one | |
| 1925 lcrecord list per size, indexed in a hash table. Usually there are only | |
| 1926 a limited number of sizes, so this works well.) | |
| 826 | 1927 |
| 1204 | 1928 -- "Hand-managed" exists because we haven't yet written the more |
| 1929 sophisticated scheme for auto-handling different-sized lcrecords, as | |
| 1930 described in the end of the last paragraph. In this model, you go ahead | |
| 1931 and create the lcrecord-list objects yourself for the sizes you will | |
| 1932 need, using make_lcrecord_list(). Then, create lcrecords using | |
| 1933 alloc_managed_lcrecord(), passing in the lcrecord-list you created, and | |
| 1934 free them with free_managed_lcrecord(). | |
| 1935 | |
| 1936 -- "Unmanaged" means you simply allocate lcrecords, period. No | |
| 1937 lcrecord-lists, no way to free them. This may be suitable when the | |
| 1938 lcrecords are variable-sized and (a) you're too lazy to write the code | |
| 1939 to hand-manage them, or (b) the objects you create are always or almost | |
| 1940 always Lisp-visible, and thus there's no point in freeing them (and it | |
| 1941 wouldn't be safe to do so). You just create them with | |
|
5117
3742ea8250b5
Checking in final CVS version of workspace 'ben-lisp-object'
Ben Wing <ben@xemacs.org>
parents:
3063
diff
changeset
|
1942 ALLOC_SIZED_LISP_OBJECT(), and that's it. |
| 1204 | 1943 |
| 1944 --ben | |
| 1945 | |
| 1946 Here is an in-depth look at the steps required to create a allocate an | |
| 1947 lcrecord using the hand-managed style. Since this is the most | |
| 1948 complicated, you will learn a lot about the other styles as well. In | |
| 1949 addition, there is useful general information about what freeing an | |
| 1950 lcrecord really entails, and what are the precautions: | |
| 1951 | |
| 1952 1) Create an lcrecord-list object using make_lcrecord_list(). This is | |
| 1953 often done at initialization. Remember to staticpro_nodump() this | |
| 1954 object! The arguments to make_lcrecord_list() are the same as would be | |
|
5117
3742ea8250b5
Checking in final CVS version of workspace 'ben-lisp-object'
Ben Wing <ben@xemacs.org>
parents:
3063
diff
changeset
|
1955 passed to ALLOC_SIZED_LISP_OBJECT(). |
| 428 | 1956 |
|
5117
3742ea8250b5
Checking in final CVS version of workspace 'ben-lisp-object'
Ben Wing <ben@xemacs.org>
parents:
3063
diff
changeset
|
1957 2) Instead of calling ALLOC_SIZED_LISP_OBJECT(), call |
|
3742ea8250b5
Checking in final CVS version of workspace 'ben-lisp-object'
Ben Wing <ben@xemacs.org>
parents:
3063
diff
changeset
|
1958 alloc_managed_lcrecord() and pass the lcrecord-list earlier created. |
| 1204 | 1959 |
| 1960 3) When done with the lcrecord, call free_managed_lcrecord(). The | |
| 1961 standard freeing caveats apply: ** make sure there are no pointers to | |
| 1962 the object anywhere! ** | |
| 1963 | |
| 1964 4) Calling free_managed_lcrecord() is just like kissing the | |
| 1965 lcrecord goodbye as if it were garbage-collected. This means: | |
| 1966 -- the contents of the freed lcrecord are undefined, and the | |
| 1967 contents of something produced by alloc_managed_lcrecord() | |
|
5117
3742ea8250b5
Checking in final CVS version of workspace 'ben-lisp-object'
Ben Wing <ben@xemacs.org>
parents:
3063
diff
changeset
|
1968 are undefined, just like for ALLOC_SIZED_LISP_OBJECT(). |
| 1204 | 1969 -- the mark method for the lcrecord's type will *NEVER* be called |
| 1970 on freed lcrecords. | |
| 1971 -- the finalize method for the lcrecord's type will be called | |
| 1972 at the time that free_managed_lcrecord() is called. | |
| 1973 */ | |
| 1974 | |
| 1975 /* UNMANAGED MODEL: */ | |
|
5117
3742ea8250b5
Checking in final CVS version of workspace 'ben-lisp-object'
Ben Wing <ben@xemacs.org>
parents:
3063
diff
changeset
|
1976 Lisp_Object old_alloc_lcrecord (const struct lrecord_implementation *); |
|
3742ea8250b5
Checking in final CVS version of workspace 'ben-lisp-object'
Ben Wing <ben@xemacs.org>
parents:
3063
diff
changeset
|
1977 Lisp_Object old_alloc_sized_lcrecord (Bytecount size, |
|
3742ea8250b5
Checking in final CVS version of workspace 'ben-lisp-object'
Ben Wing <ben@xemacs.org>
parents:
3063
diff
changeset
|
1978 const struct lrecord_implementation *); |
| 1204 | 1979 |
| 1980 /* HAND-MANAGED MODEL: */ | |
| 1981 Lisp_Object make_lcrecord_list (Elemcount size, | |
| 1982 const struct lrecord_implementation | |
| 1983 *implementation); | |
| 1984 Lisp_Object alloc_managed_lcrecord (Lisp_Object lcrecord_list); | |
| 1985 void free_managed_lcrecord (Lisp_Object lcrecord_list, Lisp_Object lcrecord); | |
| 1986 | |
| 1987 /* AUTO-MANAGED MODEL: */ | |
|
5117
3742ea8250b5
Checking in final CVS version of workspace 'ben-lisp-object'
Ben Wing <ben@xemacs.org>
parents:
3063
diff
changeset
|
1988 MODULE_API Lisp_Object |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
1989 alloc_automanaged_sized_lcrecord (Bytecount size, |
|
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
1990 const struct lrecord_implementation *imp); |
|
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
1991 MODULE_API Lisp_Object |
|
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
1992 alloc_automanaged_lcrecord (const struct lrecord_implementation *imp); |
| 3017 | 1993 |
|
5117
3742ea8250b5
Checking in final CVS version of workspace 'ben-lisp-object'
Ben Wing <ben@xemacs.org>
parents:
3063
diff
changeset
|
1994 #define old_alloc_lcrecord_type(type, imp) \ |
|
3742ea8250b5
Checking in final CVS version of workspace 'ben-lisp-object'
Ben Wing <ben@xemacs.org>
parents:
3063
diff
changeset
|
1995 ((type *) XPNTR (alloc_automanaged_lcrecord (sizeof (type), imp))) |
| 2720 | 1996 |
| 3024 | 1997 void old_free_lcrecord (Lisp_Object rec); |
| 771 | 1998 |
| 3263 | 1999 #else /* NEW_GC */ |
| 2720 | 2000 |
|
5120
d1247f3cc363
latest work on lisp-object workspace;
Ben Wing <ben@xemacs.org>
parents:
5118
diff
changeset
|
2001 MODULE_API Lisp_Object alloc_sized_lrecord (Bytecount size, |
|
d1247f3cc363
latest work on lisp-object workspace;
Ben Wing <ben@xemacs.org>
parents:
5118
diff
changeset
|
2002 const struct lrecord_implementation *imp); |
|
5117
3742ea8250b5
Checking in final CVS version of workspace 'ben-lisp-object'
Ben Wing <ben@xemacs.org>
parents:
3063
diff
changeset
|
2003 Lisp_Object noseeum_alloc_sized_lrecord (Bytecount size, |
|
5120
d1247f3cc363
latest work on lisp-object workspace;
Ben Wing <ben@xemacs.org>
parents:
5118
diff
changeset
|
2004 const struct lrecord_implementation *imp); |
|
d1247f3cc363
latest work on lisp-object workspace;
Ben Wing <ben@xemacs.org>
parents:
5118
diff
changeset
|
2005 MODULE_API Lisp_Object alloc_lrecord (const struct lrecord_implementation *imp); |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
2006 Lisp_Object noseeum_alloc_lrecord (const struct lrecord_implementation *imp); |
| 3092 | 2007 |
|
5120
d1247f3cc363
latest work on lisp-object workspace;
Ben Wing <ben@xemacs.org>
parents:
5118
diff
changeset
|
2008 MODULE_API Lisp_Object alloc_lrecord_array (int elemcount, |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
2009 const struct lrecord_implementation *imp); |
|
5120
d1247f3cc363
latest work on lisp-object workspace;
Ben Wing <ben@xemacs.org>
parents:
5118
diff
changeset
|
2010 MODULE_API Lisp_Object alloc_sized_lrecord_array (Bytecount size, |
|
d1247f3cc363
latest work on lisp-object workspace;
Ben Wing <ben@xemacs.org>
parents:
5118
diff
changeset
|
2011 int elemcount, |
|
d1247f3cc363
latest work on lisp-object workspace;
Ben Wing <ben@xemacs.org>
parents:
5118
diff
changeset
|
2012 const struct lrecord_implementation *imp); |
| 2720 | 2013 |
| 3263 | 2014 #endif /* NEW_GC */ |
| 3017 | 2015 |
| 1204 | 2016 DECLARE_INLINE_HEADER ( |
| 2017 Bytecount | |
| 2018 detagged_lisp_object_size (const struct lrecord_header *h) | |
| 2019 ) | |
| 2020 { | |
| 2021 const struct lrecord_implementation *imp = LHEADER_IMPLEMENTATION (h); | |
| 2022 | |
| 2023 return (imp->size_in_bytes_method ? | |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
2024 imp->size_in_bytes_method (wrap_pointer_1 (h)) : |
| 1204 | 2025 imp->static_size); |
| 2026 } | |
| 2027 | |
| 2028 DECLARE_INLINE_HEADER ( | |
| 2029 Bytecount | |
| 2030 lisp_object_size (Lisp_Object o) | |
| 2031 ) | |
| 2032 { | |
| 2033 return detagged_lisp_object_size (XRECORD_LHEADER (o)); | |
| 2034 } | |
| 2035 | |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
2036 struct usage_stats; |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
2037 |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
2038 MODULE_API void copy_lisp_object (Lisp_Object dst, Lisp_Object src); |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
2039 MODULE_API void zero_sized_lisp_object (Lisp_Object obj, Bytecount size); |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
2040 MODULE_API void zero_nonsized_lisp_object (Lisp_Object obj); |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
2041 Bytecount lisp_object_storage_size (Lisp_Object obj, |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
2042 struct usage_stats *ustats); |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
2043 void free_normal_lisp_object (Lisp_Object obj); |
|
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
2044 |
| 1204 | 2045 |
| 2046 /************************************************************************/ | |
| 2047 /* Dumping */ | |
| 2048 /************************************************************************/ | |
| 2049 | |
| 2367 | 2050 /* dump_add_root_block_ptr (&var, &desc) dumps the structure pointed to by |
| 1204 | 2051 `var'. This is for a single relocatable pointer located in the data |
| 2367 | 2052 segment (i.e. the block pointed to is in the heap). |
| 2053 | |
| 2054 If the structure pointed to is not a `struct' but an array, you should | |
| 2055 set the size field of the sized_memory_description to 0, and use | |
| 2056 XD_BLOCK_ARRAY in the inner memory_description. | |
| 2057 | |
| 2058 NOTE that a "root struct pointer" could also be described using | |
| 2059 dump_add_root_block(), with SIZE == sizeof (void *), and a description | |
| 2060 containing a single XD_BLOCK_PTR entry, offset 0, size 1, with a | |
| 2061 structure description the same as the value passed to | |
| 2062 dump_add_root_block_ptr(). That would require an extra level of | |
| 2063 description, though, as compared to using dump_add_root_block_ptr(), | |
| 2064 and thus this function is generally more convenient. | |
| 2065 */ | |
| 1204 | 2066 #ifdef PDUMP |
| 2367 | 2067 void dump_add_root_block_ptr (void *, const struct sized_memory_description *); |
| 1204 | 2068 #else |
| 2367 | 2069 #define dump_add_root_block_ptr(varaddr, descaddr) DO_NOTHING |
| 1204 | 2070 #endif |
| 2071 | |
| 2072 /* dump_add_opaque (&var, size) dumps the opaque static structure `var'. | |
| 2073 This is for a static block of memory (in the data segment, not the | |
| 2074 heap), with no relocatable pointers in it. */ | |
| 2075 #ifdef PDUMP | |
| 2076 #define dump_add_opaque(varaddr,size) dump_add_root_block (varaddr, size, NULL) | |
| 2077 #else | |
| 2078 #define dump_add_opaque(varaddr,size) DO_NOTHING | |
| 2079 #endif | |
| 2080 | |
| 2081 /* dump_add_root_block (ptr, size, desc) dumps the static structure | |
| 2082 located at `var' of size SIZE and described by DESC. This is for a | |
| 2083 static block of memory (in the data segment, not the heap), with | |
| 2084 relocatable pointers in it. */ | |
| 2085 #ifdef PDUMP | |
| 2086 void dump_add_root_block (const void *ptraddress, Bytecount size, | |
| 2087 const struct memory_description *desc); | |
| 2088 #else | |
| 2367 | 2089 #define dump_add_root_block(ptraddress, size, desc) DO_NOTHING |
| 1204 | 2090 #endif |
| 2091 | |
| 2092 /* Call dump_add_opaque_int (&int_var) to dump `int_var', of type `int'. */ | |
| 2093 #ifdef PDUMP | |
| 2094 #define dump_add_opaque_int(int_varaddr) do { \ | |
| 2095 int *dao_ = (int_varaddr); /* type check */ \ | |
| 2096 dump_add_opaque (dao_, sizeof (*dao_)); \ | |
| 2097 } while (0) | |
| 2098 #else | |
| 2099 #define dump_add_opaque_int(int_varaddr) DO_NOTHING | |
| 2100 #endif | |
| 2101 | |
| 2102 /* Call dump_add_opaque_fixnum (&fixnum_var) to dump `fixnum_var', of type | |
| 2103 `Fixnum'. */ | |
| 2104 #ifdef PDUMP | |
| 2105 #define dump_add_opaque_fixnum(fixnum_varaddr) do { \ | |
| 2106 Fixnum *dao_ = (fixnum_varaddr); /* type check */ \ | |
| 2107 dump_add_opaque (dao_, sizeof (*dao_)); \ | |
| 2108 } while (0) | |
| 2109 #else | |
| 2110 #define dump_add_opaque_fixnum(fixnum_varaddr) DO_NOTHING | |
| 2111 #endif | |
| 2112 | |
| 2113 /* Call dump_add_root_lisp_object (&var) to ensure that var is properly | |
| 2114 updated after pdump. */ | |
| 2115 #ifdef PDUMP | |
| 2116 void dump_add_root_lisp_object (Lisp_Object *); | |
| 2117 #else | |
| 2118 #define dump_add_root_lisp_object(varaddr) DO_NOTHING | |
| 2119 #endif | |
| 2120 | |
| 2121 /* Call dump_add_weak_lisp_object (&var) to ensure that var is properly | |
| 2122 updated after pdump. var must point to a linked list of objects out of | |
| 2123 which some may not be dumped */ | |
| 2124 #ifdef PDUMP | |
| 2125 void dump_add_weak_object_chain (Lisp_Object *); | |
| 2126 #else | |
| 2127 #define dump_add_weak_object_chain(varaddr) DO_NOTHING | |
| 2128 #endif | |
| 2129 | |
| 2130 /* Nonzero means Emacs has already been initialized. | |
| 2131 Used during startup to detect startup of dumped Emacs. */ | |
| 1632 | 2132 extern MODULE_API int initialized; |
| 1204 | 2133 |
| 2134 #ifdef PDUMP | |
| 1688 | 2135 #include "dumper.h" |
| 3263 | 2136 #ifdef NEW_GC |
| 2720 | 2137 #define DUMPEDP(adr) 0 |
| 3263 | 2138 #else /* not NEW_GC */ |
| 2367 | 2139 #define DUMPEDP(adr) ((((Rawbyte *) (adr)) < pdump_end) && \ |
| 2140 (((Rawbyte *) (adr)) >= pdump_start)) | |
| 3263 | 2141 #endif /* not NEW_GC */ |
| 1204 | 2142 #else |
| 2143 #define DUMPEDP(adr) 0 | |
| 2144 #endif | |
| 2145 | |
| 1330 | 2146 #define OBJECT_DUMPED_P(obj) DUMPEDP (XPNTR (obj)) |
| 2147 | |
| 1204 | 2148 /***********************************************************************/ |
| 2149 /* data descriptions */ | |
| 2150 /***********************************************************************/ | |
| 2151 | |
| 2152 | |
| 2153 #if defined (USE_KKCC) || defined (PDUMP) | |
| 2154 | |
| 2155 extern int in_pdump; | |
| 2156 | |
| 2157 EMACS_INT lispdesc_indirect_count_1 (EMACS_INT code, | |
| 2158 const struct memory_description *idesc, | |
| 2159 const void *idata); | |
| 2160 const struct sized_memory_description *lispdesc_indirect_description_1 | |
| 2161 (const void *obj, const struct sized_memory_description *sdesc); | |
| 2367 | 2162 Bytecount lispdesc_block_size_1 (const void *obj, Bytecount size, |
| 2163 const struct memory_description *desc); | |
| 2164 | |
| 2165 DECLARE_INLINE_HEADER ( | |
| 2166 Bytecount lispdesc_block_size (const void *obj, | |
| 2167 const struct sized_memory_description *sdesc)) | |
| 2168 { | |
| 2169 return lispdesc_block_size_1 (obj, sdesc->size, sdesc->description); | |
| 2170 } | |
| 1204 | 2171 |
| 2172 DECLARE_INLINE_HEADER ( | |
| 2173 EMACS_INT | |
| 2174 lispdesc_indirect_count (EMACS_INT code, | |
| 2175 const struct memory_description *idesc, | |
| 2176 const void *idata) | |
| 2177 ) | |
| 2178 { | |
| 2179 if (XD_IS_INDIRECT (code)) | |
| 2180 code = lispdesc_indirect_count_1 (code, idesc, idata); | |
| 2181 return code; | |
| 2182 } | |
| 2183 | |
| 2184 DECLARE_INLINE_HEADER ( | |
| 2185 const struct sized_memory_description * | |
| 2186 lispdesc_indirect_description (const void *obj, | |
| 2187 const struct sized_memory_description *sdesc) | |
| 2188 ) | |
| 2189 { | |
| 2190 if (sdesc->description) | |
| 2191 return sdesc; | |
| 2192 else | |
| 2193 return lispdesc_indirect_description_1 (obj, sdesc); | |
| 2194 } | |
| 2195 | |
| 2196 | |
| 2197 /* Do standard XD_UNION processing. DESC1 is an entry in DESC, which | |
| 2198 describes the entire data structure. Returns NULL (do nothing, nothing | |
| 2199 matched), or a new value for DESC1. In the latter case, assign to DESC1 | |
| 2200 in your function and goto union_switcheroo. */ | |
| 2201 | |
| 2202 DECLARE_INLINE_HEADER ( | |
| 2203 const struct memory_description * | |
| 2204 lispdesc_process_xd_union (const struct memory_description *desc1, | |
| 2205 const struct memory_description *desc, | |
| 2206 const void *data) | |
| 2207 ) | |
| 2208 { | |
| 2209 int count = 0; | |
| 2210 EMACS_INT variant = lispdesc_indirect_count (desc1->data1, desc, | |
| 2211 data); | |
| 2212 desc1 = | |
| 2551 | 2213 lispdesc_indirect_description (data, desc1->data2.descr)->description; |
| 1204 | 2214 |
| 2215 for (count = 0; desc1[count].type != XD_END; count++) | |
| 2216 { | |
| 2217 if ((desc1[count].flags & XD_FLAG_UNION_DEFAULT_ENTRY) || | |
| 2218 desc1[count].offset == variant) | |
| 2219 { | |
| 2220 return &desc1[count]; | |
| 2221 } | |
| 2222 } | |
| 2223 | |
| 2224 return NULL; | |
| 2225 } | |
| 2226 | |
| 2227 #endif /* defined (USE_KKCC) || defined (PDUMP) */ | |
| 428 | 2228 |
| 1743 | 2229 END_C_DECLS |
| 1650 | 2230 |
| 440 | 2231 #endif /* INCLUDED_lrecord_h_ */ |