src/vtables.c

   1 /*
   2 Copyright (C) 2001-2009, Parrot Foundation.
   3 $Id$
   4
   5 =head1 NAME
   6
   7 src/vtables.c - Functions to build and manipulate vtables
   8
   9 =head1 DESCRIPTION
  10
  11 =head2 Functions
  12
  13 =over 4
  14
  15 =cut
  16
  17 */
  18
  19 #include "parrot/parrot.h"
  20 #include "parrot/vtables.h"
  21
  22 /* This function is defined in the auto-generated file core_pmcs.c */
  23 /* XXX Get it into some public place */
  24 extern void Parrot_initialize_core_pmcs(PARROT_INTERP, int pass);
  25
  26 /* HEADERIZER HFILE: include/parrot/vtables.h */
  27
  28 /*
  29
  30 =item C<VTABLE * Parrot_new_vtable(PARROT_INTERP)>
  31
  32 Creates and returns a pointer to the new C<VTABLE>.
  33
  34 =cut
  35
  36 */
  37
  38 PARROT_EXPORT
  39 PARROT_MALLOC
  40 PARROT_CANNOT_RETURN_NULL
  41 VTABLE *
  42 Parrot_new_vtable(SHIM_INTERP)
  43 {
  44     ASSERT_ARGS(Parrot_new_vtable)
  45     return mem_allocate_zeroed_typed(VTABLE);
  46 }
  47
  48 /*
  49
  50 =item C<VTABLE * Parrot_clone_vtable(PARROT_INTERP, const VTABLE *base_vtable)>
  51
  52 Clones C<*base_vtable> and returns a pointer to the new C<VTABLE>.
  53
  54 =cut
  55
  56 */
  57
  58 PARROT_EXPORT
  59 PARROT_MALLOC
  60 PARROT_CANNOT_RETURN_NULL
  61 VTABLE *
  62 Parrot_clone_vtable(PARROT_INTERP, ARGIN(const VTABLE *base_vtable))
  63 {
  64     ASSERT_ARGS(Parrot_clone_vtable)
  65     VTABLE * const new_vtable = mem_allocate_typed(VTABLE);
  66
  67     STRUCT_COPY(new_vtable, base_vtable);
  68
  69     /* when called from global PMC initialization, not all vtables have isa_hash
  70      * when called at runtime, they do */
  71     if (base_vtable->isa_hash) {
  72         new_vtable->isa_hash = parrot_new_hash(interp);
  73         parrot_hash_clone(interp, base_vtable->isa_hash, new_vtable->isa_hash);
  74     }
  75
  76
  77     return new_vtable;
  78 }
  79
  80
  81 /*
  82
  83 =item C<void Parrot_destroy_vtable(PARROT_INTERP, VTABLE *vtable)>
  84
  85 Destroys C<*vtable>.
  86
  87 =cut
  88
  89 */
  90
  91 PARROT_EXPORT
  92 void
  93 Parrot_destroy_vtable(PARROT_INTERP, ARGMOD(VTABLE *vtable))
  94 {
  95     ASSERT_ARGS(Parrot_destroy_vtable)
  96     /* We sometimes get a type number allocated without any corresponding
  97      * vtable. E.g. if you load perl_group, perlscalar is this way.  */
  98
  99     if (vtable->ro_variant_vtable) {
 100         VTABLE *ro_vtable = vtable->ro_variant_vtable;
 101
 102         if (ro_vtable->isa_hash) {
 103             parrot_hash_destroy(interp, ro_vtable->isa_hash);
 104             if (ro_vtable->isa_hash == vtable->isa_hash)
 105                 vtable->isa_hash = NULL;
 106
 107             ro_vtable->isa_hash = NULL;
 108         }
 109
 110         mem_sys_free(ro_vtable);
 111         vtable->ro_variant_vtable = NULL;
 112     }
 113
 114     if (vtable->isa_hash) {
 115         parrot_hash_destroy(interp, vtable->isa_hash);
 116         vtable->isa_hash = NULL;
 117     }
 118
 119     mem_sys_free(vtable);
 120 }
 121
 122 /*
 123
 124 =item C<void parrot_alloc_vtables(PARROT_INTERP)>
 125
 126 Allocate memory for the vtables for all known classes (PMC types).
 127
 128 =cut
 129
 130 */
 131
 132 void
 133 parrot_alloc_vtables(PARROT_INTERP)
 134 {
 135     ASSERT_ARGS(parrot_alloc_vtables)
 136     interp->vtables          = mem_allocate_n_zeroed_typed(PARROT_MAX_CLASSES, VTABLE *);
 137     interp->n_vtable_max     = enum_class_core_max;
 138     interp->n_vtable_alloced = PARROT_MAX_CLASSES - 1;
 139 }
 140
 141 /*
 142
 143 =item C<void parrot_realloc_vtables(PARROT_INTERP)>
 144
 145 Reallocate memory for vtables, increasing the number of vtables by 16.
 146
 147 =cut
 148
 149 */
 150
 151 void
 152 parrot_realloc_vtables(PARROT_INTERP)
 153 {
 154     ASSERT_ARGS(parrot_realloc_vtables)
 155     /* 16 bigger seems reasonable, though it's only a pointer
 156        table and we could get bigger without blowing much memory
 157        */
 158     const INTVAL new_max     = interp->n_vtable_alloced + 16;
 159     const INTVAL new_size    = new_max              * sizeof (VTABLE *);
 160     const INTVAL old_size    = interp->n_vtable_max * sizeof (VTABLE *);
 161
 162     /* arrays start at zero, but we compare type numbers starting at 1 */
 163     interp->n_vtable_alloced = new_max - 1;
 164     interp->vtables          = (VTABLE **)mem_sys_realloc_zeroed(
 165         interp->vtables, new_size, old_size);
 166 }
 167
 168 /*
 169
 170 =item C<void parrot_free_vtables(PARROT_INTERP)>
 171
 172 Free memory allocated for the vtables. Each vtable is destroyed
 173 through its destructor Parrot_destroy_vtable, after which the list
 174 of pointers to these vtables is freed.
 175
 176 =cut
 177
 178 */
 179
 180 void
 181 parrot_free_vtables(PARROT_INTERP)
 182 {
 183     ASSERT_ARGS(parrot_free_vtables)
 184     int i;
 185
 186     for (i = 0; i < interp->n_vtable_max; i++)
 187         Parrot_destroy_vtable(interp, interp->vtables[i]);
 188
 189     mem_sys_free(interp->vtables);
 190 }
 191
 192 /*
 193
 194 =item C<void mark_vtables(PARROT_INTERP)>
 195
 196 Mark all vtables as being alive for the garbage collector.
 197
 198 =cut
 199
 200 */
 201
 202 void
 203 mark_vtables(PARROT_INTERP)
 204 {
 205     ASSERT_ARGS(mark_vtables)
 206     INTVAL i;
 207
 208     for (i = 1; i < interp->n_vtable_max; i++) {
 209         const VTABLE * const vtable = interp->vtables[i];
 210
 211         /* XXX dynpmc groups have empty slots for abstract objects */
 212         if (!vtable)
 213             continue;
 214
 215         Parrot_gc_mark_PMC_alive(interp, vtable->mro);
 216         Parrot_gc_mark_PMC_alive(interp, vtable->_namespace);
 217         Parrot_gc_mark_STRING_alive(interp, vtable->whoami);
 218         Parrot_gc_mark_STRING_alive(interp, vtable->provides_str);
 219         Parrot_gc_mark_PMC_alive(interp, vtable->pmc_class);
 220     }
 221 }
 222
 223 /*
 224
 225 =item C<void Parrot_initialize_core_vtables(PARROT_INTERP)>
 226
 227 Initialize vtables for the core PMCs.
 228
 229 =cut
 230
 231 */
 232
 233 PARROT_EXPORT
 234 void
 235 Parrot_initialize_core_vtables(PARROT_INTERP)
 236 {
 237     ASSERT_ARGS(Parrot_initialize_core_vtables)
 238
 239     if (! interp->vtables) {
 240         parrot_alloc_vtables(interp);
 241         Parrot_initialize_core_pmcs(interp, 0);
 242     }
 243 }
 244
 245 /*
 246  * Local variables:
 247  *   c-file-style: "parrot"
 248  * End:
 249  * vim: expandtab shiftwidth=4:
 250  */