3 * Sensible Object Design header file
5 * (c) 2009 Straylight/Edgeware
8 /*----- Licensing notice --------------------------------------------------*
10 * This file is part of the Sensble Object Design, an object system for C.
12 * The SOD Runtime Library is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU Library General Public License as
14 * published by the Free Software Foundation; either version 2 of the
15 * License, or (at your option) any later version.
17 * The SOD Runtime is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU Library General Public License for more details.
22 * You should have received a copy of the GNU Library General Public
23 * License along with SOD; if not, write to the Free
24 * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
35 /*----- Header files ------------------------------------------------------*/
42 /*----- Data structures ---------------------------------------------------*/
44 /* A skeletal vtable structure. At the beginning of every ichain is a
45 * pointer to one of these.
48 const SodClass *_class; /* Pointer to class object */
49 size_t _base; /* Offset to instance base */
52 /* A skeletal instance structure. Every instance pointer points to one of
56 struct sod_vtable *_vt; /* Pointer to (chain's) vtable */
59 /* Information about a particular chain of superclasses. In each class,
60 * there's a pointer to an array of these. If you search hard enough, you'll
61 * be able to find out a fair amount of information about an instance and its
65 size_t n_classes; /* Number of classes in chain */
66 const SodClass *const *classes; /* Vector of classes, head first */
67 size_t off_ichain; /* Offset of ichain from base */
68 const struct sod_vtable *vt; /* Chain's vtable pointer */
69 size_t ichainsz; /* Size of the ichain structure */
72 /*----- Infrastructure macros ---------------------------------------------*/
74 /* --- @SOD_XCHAIN@ --- *
76 * Arguments: @chead@ = nickname of target chain's head
77 * @obj@ = pointer to an instance chain
79 * Returns: Pointer to target chain, as a @char *@.
81 * Use: Utility for implementing cross-chain upcasts. It's probably
82 * not that clever to use this macro directly; it's used to make
83 * the automatically-generated upcast macros more palatable.
86 #define SOD_XCHAIN(chead, obj) ((char *)(obj) + (obj)->_vt->_off_##chead)
88 /* --- @SOD_OFFSETDIFF@ --- *
90 * Arguments: @type@ = a simple (i.e., declaratorless) type name
91 * @mema, memb@ = members of @type@
93 * Returns: The relative offset from @mema@ to @memb@, as a @ptrdiff_t@.
95 * Use: Computes a signed offset between structure members.
98 #define SOD_OFFSETDIFF(type, mema, memb) \
99 ((ptrdiff_t)offsetof(type, memb) - (ptrdiff_t)offsetof(type, mema))
101 /* --- @SOD_ILAYOUT@ --- *
103 * Arguments: @cls@ = name of a class
104 * @chead@ = nickname of chain head of @cls@
105 * @obj@ = pointer to the @chead@ ichain of an (exact) instance
108 * Returns: A pointer to the instance's base, cast as a pointer to the
111 * Use: Finds an instance's base address given a pointer to one of
112 * its ichains, if you know precisely the instance's class and
113 * which chain you're pointing to. If you don't, then (a) you
114 * want @SOD_INSTBASE@ below, and (b) you'll have the wrong
117 * This macro is not intended to be used directly outside of
118 * automatically generated effective method and trampoline
119 * functions, which have the kinds of specific knowledge
120 * necessary to use it safely.
123 #define SOD_ILAYOUT(cls, chead, obj) \
124 ((struct cls##__ilayout *) \
125 ((char *)(obj) - offsetof(struct cls##__ilayout, chead)))
127 /*----- Utility macros ----------------------------------------------------*/
129 /* --- @SOD_CLASSOF@ --- *
131 * Arguments: @p@ = pointer to an instance chain
133 * Returns: A pointer to the instance's class, as a const SodClass.
136 #define SOD_CLASSOF(obj) ((const SodClass *)(obj)->_vt->_class)
138 /* --- @SOD_INSTBASE@ --- *
140 * Arguments: @obj@ = pointer to an instance (i.e., the address of one of
141 * its instance chains)
143 * Returns: The base address of @obj@'s instance layout, as a @void *@.
145 * Use: Finds the base address of an instance. If you know the
146 * dynamic class of the object then @SOD_ILAYOUT@ is faster. If
147 * you don't, this is the right macro, but your options for
148 * doing something sensible with the result are limited, mostly
149 * to simple memory management operations such as freeing or
150 * zeroizing the instance structure.
153 #define SOD_INSTBASE(obj) ((void *)((char *)(obj) - (obj)->_vt->_base))
155 /* --- @SOD_CONVERT@ --- *
157 * Arguments: @cls@ = a class type name
158 * @const void *obj@ = a pointer to an instance
160 * Returns: Pointer to appropriate instance ichain, or null if the
161 * instance isn't of the specified class.
163 * Use: This is a simple wrapper around the @sod_convert@, which
164 * you should see for full details. It accepts a class type
165 * name rather than a pointer to a class object, and arranges to
166 * return a pointer of the correct type.
169 #define SOD_CONVERT(cls, obj) ((cls *)sod_convert(cls##__class, (obj)))
171 /*----- Functions provided ------------------------------------------------*/
173 /* --- @sod_subclassp@ --- *
175 * Arguments: @const SodClass *sub, *super@ = pointers to two classes
177 * Returns: Nonzero if @c@ is a subclass of @d@.
180 extern int sod_subclassp(const SodClass */*sub*/, const SodClass */*super*/);
182 /* --- @sod_convert@ --- *
184 * Arguments: @const SodClass *cls@ = desired class object
185 * @const void *obj@ = pointer to instance
187 * Returns: Pointer to appropriate ichain of object, or null if the
188 * instance isn't of the specified class.
190 * Use: General down/cross-casting function.
192 * Upcasts can be performed efficiently using the automatically
193 * generated macros. In particular, upcasts within a chain are
194 * trivial; cross-chain upcasts require information from vtables
195 * but are fairly fast. This function is rather slower, but is
198 * Suppose we have an instance of a class C, referred to by a
199 * pointer to an instance of one of C's superclasses S. If T
200 * is some other superclass of C then this function will return
201 * a pointer to C suitable for use as an instance of T. If T
202 * is not a superclass of C, then the function returns null.
203 * (If the pointer doesn't point to an instance of some class
204 * then the behaviour is undefined.) Note that you don't need
205 * to know what either C or S actually are.
208 extern void *sod_convert(const SodClass */*cls*/, const void */*obj*/);
210 /*----- That's all, folks -------------------------------------------------*/