object.h

   1 #ifndef _object__h__included__
   2 #define _object__h__included__
   3
   4 #include "class.h"
   5
   6 struct context;
   7 struct message;
   8
   9 /* Object marked for garbage collection. */
  10 #define OF_MARKED_FOR_GC 1
  11 /* Already execuing message handler. */
  12 #define OF_EXECUTING 2
  13
  14 /* Object. */
  15 struct object;
  16
  17 /* Object list. */
  18 struct objectlist;
  19
  20 /******************************************************************************
  21  *
  22  * DESCRIPTION:
  23  *      Read object field.
  24  *
  25  * PARAMETERS:
  26  *      object                  The object to read.
  27  *      slot                    Field slot number.
  28  *
  29  * RETURN VALUE:
  30  *      Read value, or NULL if slot is invalid.
  31  *
  32  *****************************************************************************/
  33 struct object* object_read_field(struct object* object, size_t slot);
  34
  35 /******************************************************************************
  36  *
  37  * DESCRIPTION:
  38  *      Write object field. Writes to nonexistent slots are discarded.
  39  *
  40  * PARAMETERS:
  41  *      object                  The object to write.
  42  *      slot                    Field slot number.
  43  *      towrite                 Refrence to write.
  44  *
  45  *****************************************************************************/
  46 void object_write_field(struct object* object, size_t slot,
  47         struct object* towrite);
  48
  49 /******************************************************************************
  50  *
  51  * DESCRIPTION:
  52  *      Get class of object.
  53  *
  54  * PARAMETERS:
  55  *      object                  The object to interrogate.
  56  *
  57  * RETURN VALUE:
  58  *      Class of object.
  59  *
  60  *****************************************************************************/
  61 struct class* object_class(struct object* object);
  62
  63 /******************************************************************************
  64  *
  65  * DESCRIPTION:
  66  *      Check object EXECUTING flag.
  67  *
  68  * PARAMETERS:
  69  *      object                  The object to interrogate.
  70  *
  71  * RETURN VALUE:
  72  *      1 if object is executing, 0 otherwise.
  73  *
  74  *****************************************************************************/
  75 unsigned object_is_executing(struct object* object);
  76
  77 /******************************************************************************
  78  *
  79  * DESCRIPTION:
  80  *      Set object EXECUTING flag.
  81  *
  82  * PARAMETERS:
  83  *      object                  The object to manipulate.
  84  *
  85  *****************************************************************************/
  86 void object_set_executing(struct object* object);
  87
  88 /******************************************************************************
  89  *
  90  * DESCRIPTION:
  91  *      Clear object EXECUTING flag.
  92  *
  93  * PARAMETERS:
  94  *      object                  The object to manipulate.
  95  *
  96  *****************************************************************************/
  97 void object_clear_executing(struct object* object);
  98
  99
 100 /******************************************************************************
 101  *
 102  * DESCRIPTION:
 103  *      Check object MARKED_FOR_GC flag.
 104  *
 105  * PARAMETERS:
 106  *      object                  The object to interrogate.
 107  *
 108  * RETURN VALUE:
 109  *      1 if object is marked for GC, 0 otherwise.
 110  *
 111  *****************************************************************************/
 112 unsigned object_is_gcmark(struct object* object);
 113
 114 /******************************************************************************
 115  *
 116  * DESCRIPTION:
 117  *      Set object MARKED_FOR_GC flag.
 118  *
 119  * PARAMETERS:
 120  *      object                  The object to manipulate.
 121  *
 122  *****************************************************************************/
 123 void object_set_gcmark(struct object* object);
 124
 125 /******************************************************************************
 126  *
 127  * DESCRIPTION:
 128  *      Clear object MARKED_FOR_GC flag.
 129  *
 130  * PARAMETERS:
 131  *      object                  The object to manipulate.
 132  *
 133  *****************************************************************************/
 134 void object_clear_gcmark(struct object* object);
 135
 136 /******************************************************************************
 137  *
 138  * DESCRIPTION:
 139  *      Create object of specified class.
 140  *
 141  * PARAMETERS:
 142  *      class                   The class of new object.
 143  *
 144  * RETURN VALUE:
 145  *      The newly created object.
 146  *
 147  *****************************************************************************/
 148 struct object* object_create_ordinary(struct class* class);
 149
 150 /******************************************************************************
 151  *
 152  * DESCRIPTION:
 153  *      Create special object.
 154  *
 155  * PARAMETERS:
 156  *      handler                 Handler object.
 157  *      fields                  Fields for local object. Note that if this
 158  *                              is nonzero, new class is created and
 159  *                              registered.
 160  *
 161  * RETURN VALUE:
 162  *      The newly created object.
 163  *
 164  *****************************************************************************/
 165 struct object* object_create_special(void (*handler)(struct context* ctx,
 166         struct message* msg), size_t fields);
 167
 168 /******************************************************************************
 169  *
 170  * DESCRIPTION:
 171  *      Create object list.
 172  *
 173  * RETURN VALUE:
 174  *      The newly created object list.
 175  *
 176  *****************************************************************************/
 177 struct objectlist* objectlist_create();
 178
 179 /******************************************************************************
 180  *
 181  * DESCRIPTION:
 182  *      Destroy object list and all objects in it.
 183  *
 184  * PARAMETERS:
 185  *      objectlist              Object list to destroy.
 186  *
 187  *****************************************************************************/
 188 void objectlist_destroy(struct objectlist* objectlist);
 189
 190 /******************************************************************************
 191  *
 192  * DESCRIPTION:
 193  *      Add object to object list.
 194  *
 195  * PARAMETERS:
 196  *      objectlist              Object list to add object to.
 197  *      object                  Object to add.
 198  *
 199  *****************************************************************************/
 200 void objectlist_add(struct objectlist* objectlist, struct object* object);
 201
 202 /******************************************************************************
 203  *
 204  * DESCRIPTION:
 205  *      Kill all marked objects from list.
 206  *
 207  * PARAMETERS:
 208  *      objectlist              Object list to manipulate.
 209  *
 210  * RETURN VALUE:
 211  *      1 if more remain, 0 if all are gone.
 212  *
 213  *****************************************************************************/
 214 unsigned objectlist_kill_marked(struct objectlist* objectlist);
 215
 216 /******************************************************************************
 217  *
 218  * DESCRIPTION:
 219  *      Set object MARKED_FOR_GC flag for all objects in list.
 220  *
 221  * PARAMETERS:
 222  *      objectlist              The object list to manipulate.
 223  *
 224  *****************************************************************************/
 225 void objectlist_set_gcmark_all(struct objectlist* objectlist);
 226
 227 /******************************************************************************
 228  *
 229  * DESCRIPTION:
 230  *      Execute special action, if any.
 231  *
 232  * PARAMETERS:
 233  *      object                  The object.
 234  *      ctx                     Context to pass in.
 235  *      msg                     Message to pass in.
 236  *
 237  * RETURN VALUE:
 238  *      1 if special action was executed, 0 if there is none.
 239  *
 240  *****************************************************************************/
 241 unsigned object_exec_special(struct object* object, struct context* ctx,
 242         struct message* msg);
 243
 244
 245 #endif