Mercurial > repos > rhope

comparison runtime/object.c @ 62:b218af069da7

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
merge
author Mike Pavone <pavone@retrodev.com>
date Sat, 10 Oct 2009 16:43:37 -0400
parents d2f9b0a9403d 1b86a1ee500a
children 04baa003de5a
comparison
equal deleted inserted replaced
61:fa24ef3b026f 62:b218af069da7
1 #include "object.h" 1 #include "object.h"
2 #include "builtin.h" 2 #include "builtin.h"
3 #include <stdlib.h> 3 #include <stdlib.h>
4 #include <string.h> 4 #include <string.h>
5 #include <stdio.h> 5 #include <stdio.h>
6 #include "fixed_alloc.h"
6 7
7 blueprint ** registered_types = NULL; 8 blueprint ** registered_types = NULL;
8 uint32_t max_registered_type = 0; 9 uint32_t max_registered_type = 0;
9 uint32_t type_storage = 0; 10 uint32_t type_storage = 0;
10 11
12 mem_manager * manager = NULL;
11 /* 13 /*
14
12 returntype call_method(uint32_t methodid, calldata * params) 15 returntype call_method(uint32_t methodid, calldata * params)
13 { 16 {
14 int i; 17 int i;
15 blueprint * bp = get_blueprint(params->params[0]); 18 blueprint * bp = get_blueprint(params->params[0]);
16 if(methodid >= bp->first_methodid && methodid < bp->last_methodid && bp->method_lookup[methodid - bp->first_methodid]) 19 if(methodid >= bp->first_methodid && methodid < bp->last_methodid && bp->method_lookup[methodid - bp->first_methodid])
124 return EXCEPTION_RETURN; 127 return EXCEPTION_RETURN;
125 }*/ 128 }*/
126 129
127 object * alloc_object(blueprint * bp) 130 object * alloc_object(blueprint * bp)
128 { 131 {
129 //TODO: Replace with something more performant 132 return falloc(bp->boxed_size, manager);
130 return malloc(bp->boxed_size); 133 //return malloc(bp->boxed_size);
131 }
132
133 void * alloc_variable(uint32_t size)
134 {
135 return malloc(size);
136 } 134 }
137 135
138 void dealloc_object(blueprint * bp, object * obj) 136 void dealloc_object(blueprint * bp, object * obj)
139 { 137 {
140 //TODO: Replace with something more performant 138 ffree(obj, bp->boxed_size, manager);
141 free(obj);
142 } 139 }
143 140
144 object * new_object(uint32_t type) 141 object * new_object(uint32_t type)
145 { 142 {
146 blueprint * bp; 143 blueprint * bp;
171 { 168 {
172 blueprint *bp; 169 blueprint *bp;
173 multisize * ret; 170 multisize * ret;
174 if(type >= max_registered_type || !registered_types[type]) 171 if(type >= max_registered_type || !registered_types[type])
175 return NULL; 172 return NULL;
176 ret = alloc_variable(sizeof(multisize) + type); 173 ret = falloc(sizeof(multisize) + size, manager);
177 if(ret) 174 if(ret)
178 { 175 {
179 bp = registered_types[type]; 176 bp = registered_types[type];
180 ret->base.bprint = bp; 177 ret->base.bprint = bp;
181 ret->size = size; 178 ret->size = size;
194 if(rh_atomic_get(tocopy, refcount) == 1) 191 if(rh_atomic_get(tocopy, refcount) == 1)
195 return tocopy; 192 return tocopy;
196 bp = get_blueprint(tocopy); 193 bp = get_blueprint(tocopy);
197 if(bp->size < 0) { 194 if(bp->size < 0) {
198 mtocopy = (multisize *)tocopy; 195 mtocopy = (multisize *)tocopy;
199 mcopy = alloc_variable(sizeof(multisize) + mtocopy->size); 196 mcopy = falloc(sizeof(multisize) + mtocopy->size, manager);
200 mcopy->size = mtocopy->size; 197 mcopy->size = mtocopy->size;
201 memcpy(((char *)mcopy)+sizeof(multisize), ((char *)mtocopy)+sizeof(multisize), mtocopy->size); 198 memcpy(((char *)mcopy)+sizeof(multisize), ((char *)mtocopy)+sizeof(multisize), mtocopy->size);
202 copy = (object *)mcopy; 199 copy = (object *)mcopy;
203 } else { 200 } else {
204 copy = alloc_object(bp); 201 copy = alloc_object(bp);
209 bp->copy(copy); 206 bp->copy(copy);
210 release_ref(tocopy); 207 release_ref(tocopy);
211 return copy; 208 return copy;
212 } 209 }
213 210
214 void free_object(object * obj) 211 object * naked_to_boxed(uint32_t type, void * rawdata)
215 { 212 {
216 blueprint * bp = get_blueprint(obj); 213 object * dest;
217 if(bp->cleanup) 214 blueprint * bp = get_blueprint_byid(type);
218 bp->cleanup(obj); 215 if(!bp->boxed_size)
219 dealloc_object(bp, obj); 216 return NULL; //We don't know how big a naked multi-size object is so we can't do anything with it
217 dest = alloc_object(bp);
218 memcpy(((char *)dest) + sizeof(object), rawdata, bp->size);
219 dest->bprint = bp;
220 rh_atomic_set(dest, refcount, 1);
221 bp->copy(dest);
222 return dest;
223 }
224
225 void boxed_to_naked(object * src, void * dest)
226 {
227 blueprint * bp = get_blueprint(src);
228 if(!bp->boxed_size)
229 return; //We don't know how big a naked multi-size object is so we can't do anything with it
230 memcpy(dest, ((char *)src) + sizeof(object), bp->size);
231 bp->copy(src);
220 } 232 }
221 233
222 void release_ref(object * obj) 234 void release_ref(object * obj)
223 { 235 {
224 if(rh_atomic_sub_testzero(obj, refcount, 1)) 236 if(rh_atomic_sub_testzero(obj, refcount, 1))
225 free_object(obj); 237 get_blueprint(obj)->free(obj);
226 } 238 }
227 239
228 void check_type_storage(type) 240 void check_type_storage(type)
229 { 241 {
230 uint32_t type_storage_temp; 242 uint32_t type_storage_temp;
266 278
267 void default_action(object * obj) 279 void default_action(object * obj)
268 { 280 {
269 } 281 }
270 282
283 void normal_free(object * obj)
284 {
285 blueprint * bp = get_blueprint(obj);
286 if(bp->cleanup)
287 bp->cleanup(obj);
288 ffree(obj, bp->boxed_size, manager);
289 }
290
291 void multi_free(object * obj)
292 {
293 multisize * multi = (multisize *)obj;
294 blueprint * bp = get_blueprint(obj);
295 if(bp->cleanup)
296 bp->cleanup(obj);
297 ffree(multi, sizeof(multi) + multi->size, manager);
298 }
299
271 blueprint * new_blueprint(uint32_t type, uint32_t size, special_func init, special_func copy, special_func cleanup) 300 blueprint * new_blueprint(uint32_t type, uint32_t size, special_func init, special_func copy, special_func cleanup)
272 { 301 {
273 blueprint * bp = malloc(sizeof(blueprint)); 302 blueprint * bp = malloc(sizeof(blueprint));
303 //dirty hack!, move elsewhere
304 if (!manager) {
305 fixed_alloc_init();
306 manager = new_mem_manager();
307 }
274 if(bp) 308 if(bp)
275 { 309 {
276 bp->size = size; 310 bp->size = size;
277 bp->boxed_size = size >= 0 ? size + sizeof(object) : size; 311 bp->boxed_size = size >= 0 ? size + sizeof(object) : 0;
278 bp->method_lookup = bp->getter_lookup = bp->setter_lookup = bp->convert_to = bp->convert_from = NULL; 312 bp->method_lookup = bp->getter_lookup = bp->setter_lookup = bp->convert_to = bp->convert_from = NULL;
279 bp->type_id = type; 313 bp->type_id = type;
280 bp->init = init ? init : default_action; 314 bp->init = init ? init : default_action;
281 bp->copy = copy ? copy : default_action; 315 bp->copy = copy ? copy : default_action;
282 bp->cleanup = cleanup ? cleanup : default_action; 316 bp->cleanup = cleanup ? cleanup : default_action;
317 bp->free = size >= 0 ? normal_free : multi_free;
283 bp->first_methodid = bp->last_methodid = bp->first_getfieldid = bp->last_getfieldid = bp->first_setfieldid = bp->last_setfieldid = bp->first_convertto = bp->last_convertto = bp->first_convertfrom = bp->last_convertfrom = 0; 318 bp->first_methodid = bp->last_methodid = bp->first_getfieldid = bp->last_getfieldid = bp->first_setfieldid = bp->last_setfieldid = bp->first_convertto = bp->last_convertto = bp->first_convertfrom = bp->last_convertfrom = 0;
284 //TODO: Handle names 319 //TODO: Handle names
285 bp->name = NULL; 320 bp->name = NULL;
286 } 321 }
287 return bp; 322 return bp;