src/pmc/packfiledirectory.pmc

   1 /*
   2 Copyright (C) 2001-2010, Parrot Foundation.
   3 $Id$
   4
   5 =head1 NAME
   6
   7 src/pmc/packfiledirectory.pmc - PackfileDirectory PMC
   8
   9 =head1 DESCRIPTION
  10
  11 This class implements a PackfileDirectory object, a segment of the .pbc data
  12 file used for listing the rest of the file's contents.  Essentially this
  13 segment is a container for all other segments within a Packfile.
  14
  15 See packfile.pmc for the toplevel Packfile interface, see packfilesegment.pmc
  16 for the list of common methods every packfile segment pmc must implement; see
  17 PDD13 for the design spec.
  18
  19
  20 =head2 Methods
  21
  22 =over 4
  23
  24 =cut
  25
  26 */
  27
  28 /* HEADERIZER HFILE: none */
  29 /* HEADERIZER BEGIN: static */
  30 /* HEADERIZER END: static */
  31
  32 pmclass PackfileDirectory auto_attrs extends PackfileSegment {
  33     /* Directory is a hash of Segments */
  34     ATTR PMC *hash;
  35
  36 /*
  37
  38 =item C<void init()>
  39
  40 Initialize PackfileDirectory.
  41
  42 =cut
  43
  44 */
  45     VTABLE void init() {
  46         Parrot_PackfileDirectory_attributes * const attrs =
  47                 PMC_data_typed(SELF, Parrot_PackfileDirectory_attributes*);
  48
  49         attrs->hash = Parrot_pmc_new(INTERP, enum_class_Hash);
  50
  51         PObj_custom_mark_SET(SELF);
  52     }
  53
  54 /*
  55
  56 =item C<void mark()>
  57
  58 Marks the object as live.
  59
  60 =cut
  61
  62 */
  63
  64     VTABLE void mark() {
  65         Parrot_PackfileDirectory_attributes * const attrs =
  66                 PARROT_PACKFILEDIRECTORY(SELF);
  67
  68         Parrot_gc_mark_PMC_alive(INTERP, attrs->hash);
  69
  70         SUPER();
  71     }
  72
  73 /*
  74
  75 =item C<void set_pointer(void *ptr)>
  76
  77 Initialize PackfileDirectory from PackFile_Directory.
  78
  79 =cut
  80
  81 */
  82
  83     VTABLE void set_pointer(void *ptr) {
  84         const PackFile_Directory * const pfd = (const PackFile_Directory *)ptr;
  85         size_t i;
  86
  87         SUPER(ptr);
  88
  89         /* Iterate over elements and create corresponded PMCs */
  90         for (i=0; i < pfd->num_segments; ++i) {
  91             PackFile_Segment * const pfseg = pfd->segments[i];
  92             int     pmc_type;
  93             PMC     *segment;
  94             STRING  *name;
  95
  96             switch (pfseg->type) {
  97               case PF_DIR_SEG:
  98                 pmc_type = enum_class_PackfileDirectory;
  99                 break;
 100               case PF_FIXUP_SEG:
 101                 pmc_type = enum_class_PackfileFixupTable;
 102                 break;
 103               case PF_CONST_SEG:
 104                 pmc_type = enum_class_PackfileConstantTable;
 105                 break;
 106               case PF_ANNOTATIONS_SEG:
 107                 pmc_type = enum_class_PackfileAnnotations;
 108                 break;
 109               case PF_DEBUG_SEG:
 110                 pmc_type = enum_class_PackfileDebug;
 111                 break;
 112               case PF_BYTEC_SEG:
 113               case PF_UNKNOWN_SEG:
 114               default:
 115                 pmc_type = enum_class_PackfileRawSegment;
 116                 break;
 117             }
 118
 119             segment = Parrot_pmc_new(INTERP, pmc_type);
 120             name    = pfseg->name;
 121             VTABLE_set_pmc_keyed_str(INTERP, SELF, name, segment);
 122
 123             /* Initialize internal PMC structure */
 124             VTABLE_set_pointer(INTERP, segment, pfseg);
 125
 126         }
 127     }
 128
 129 /*
 130
 131 =item C<void *get_pointer()>
 132
 133 Creates PackFile for given directory.
 134
 135 =cut
 136
 137 */
 138
 139     VTABLE void *get_pointer() {
 140         Parrot_PackfileDirectory_attributes * attrs =
 141                 PARROT_PACKFILEDIRECTORY(SELF);
 142         PackFile           * const pf    = PackFile_new(INTERP, 0); /* dummy PackFile... */
 143         PackFile_Directory * const pfdir = &pf->directory;
 144         PMC                * const iter  = VTABLE_get_iter(INTERP, attrs->hash);
 145
 146         /* Create Segments. Add to Directory with transfering ownership */
 147         while (VTABLE_get_bool(INTERP, iter)) {
 148             STRING           * const name  = VTABLE_shift_string(INTERP, iter);
 149             PMC              * const seg   = VTABLE_get_pmc_keyed_str(INTERP, attrs->hash, name);
 150             PackFile_Segment * const pfseg = (PackFile_Segment *)VTABLE_get_pointer(INTERP, seg);
 151
 152             pfseg->pf   = pf;
 153             pfseg->name = name;
 154             PackFile_add_segment(INTERP, pfdir, pfseg);
 155         }
 156
 157         return pf;
 158     }
 159
 160 /*
 161
 162 =item C<INTVAL elements()>
 163
 164 Get the number of elements in the array.
 165
 166 =cut
 167
 168 */
 169     VTABLE INTVAL elements() {
 170         return VTABLE_elements(INTERP, PARROT_PACKFILEDIRECTORY(SELF)->hash);
 171     }
 172
 173
 174 /*
 175
 176 =item C<PMC *get_iter()>
 177
 178 Return a new iterator for the directory.
 179
 180 =cut
 181
 182 */
 183
 184     VTABLE PMC *get_iter() {
 185         return VTABLE_get_iter(INTERP, PARROT_PACKFILEDIRECTORY(SELF)->hash);
 186     }
 187
 188 /*
 189
 190 =item C<PMC *get_pmc_keyed_str(STRING *name)>
 191
 192 Search the array for a segment with the given name, and return it if it exists.
 193
 194 =cut
 195
 196 */
 197     VTABLE PMC *get_pmc_keyed_str(STRING *name)  {
 198         return VTABLE_get_pmc_keyed_str(INTERP,
 199                 PARROT_PACKFILEDIRECTORY(SELF)->hash, name);
 200     }
 201
 202
 203 /*
 204
 205 =item C<PMC *get_pmc_keyed(PMC *key)>
 206
 207 Fetch a keyed string value from the packfiledirectory object.
 208
 209 =cut
 210
 211 */
 212     VTABLE PMC *get_pmc_keyed(PMC *key) {
 213         STRING * const s_key = VTABLE_get_string(INTERP, key);
 214         return VTABLE_get_pmc_keyed_str(INTERP,
 215                 PARROT_PACKFILEDIRECTORY(SELF)->hash, s_key);
 216     }
 217
 218
 219 /*
 220
 221 =item C<void set_pmc_keyed_str(STRING *name, PMC *segment)>
 222
 223 Add a segment with the given name to the directory.  If a segment with this
 224 name already existed, it will be replaced with the new segment.
 225
 226 =cut
 227
 228 TODO: check type
 229
 230 */
 231     VTABLE void set_pmc_keyed_str(STRING *name, PMC *segment)  {
 232         Parrot_pcc_invoke_method_from_c_args(INTERP, segment,
 233             Parrot_str_new_constant(INTERP, "set_directory"),
 234             "P->", SELF);
 235         VTABLE_set_pmc_keyed_str(INTERP,
 236             PARROT_PACKFILEDIRECTORY(SELF)->hash, name, segment);
 237     }
 238
 239 /*
 240
 241 =item C<PMC *set_pmc_keyed(PMC *key, PMC *segment)>
 242
 243 Add a segment with the given name to the directory.  Dispatches to
 244 set_pmc_keyed_str.
 245
 246 =cut
 247
 248 */
 249
 250     VTABLE void set_pmc_keyed(PMC *key, PMC *segment)  {
 251         STRING * const s_key = VTABLE_get_string(INTERP, key);
 252         VTABLE_set_pmc_keyed_str(INTERP, SELF, s_key, segment);
 253     }
 254
 255 /*
 256
 257 =item C<PMC *delete_keyed(PMC *key)>
 258
 259 Delete the specified segment from the directory.
 260
 261 =cut
 262
 263 */
 264
 265     VTABLE void delete_keyed(PMC *key) {
 266         VTABLE_delete_keyed(INTERP,
 267             PARROT_PACKFILEDIRECTORY(SELF)->hash, key);
 268     }
 269
 270
 271 }
 272
 273 /*
 274
 275 =back
 276
 277 =cut
 278
 279 */
 280
 281 /*
 282  * Local variables:
 283  *   c-file-style: "parrot"
 284  * End:
 285  * vim: expandtab shiftwidth=4:
 286  */