Mercurial > repos > rhope
annotate worker.c @ 30:914ad38f9b59
Compiler now works for some simple programs
| author | Mike Pavone <pavone@retrodev.com> |
|---|---|
| date | Mon, 28 Sep 2009 19:42:33 -0400 |
| parents | 76568becd6d6 |
| children |
| rev | line source |
|---|---|
| 0 | 1 #include "structs.h" |
| 2 #include "interp.h" | |
| 3 #include "datum.h" | |
| 4 #include "parser.h" | |
| 5 #include "saveload.h" | |
| 6 #include <stdlib.h> | |
| 7 #include <string.h> | |
| 8 | |
| 9 int vis_worker_from_string(datum ** inputlist, queue_entry * worker_entry) | |
| 10 { | |
| 11 int i; | |
| 12 worker_datum * work; | |
| 13 datum * output = new_datum(BUILTIN_TYPE_WORKER, 1, sizeof(worker_datum), worker_entry->instance->def->program); | |
| 14 work = output->c.generic.data; | |
| 15 find_worker(inputlist[0]->c.generic.data, NULL, NULL, worker_entry->instance->def->program, &work->def); | |
| 16 if(work->def) | |
| 17 add_program_ref(work->def->program); | |
| 18 for(i = 0; i < 32; ++i) | |
| 19 work->params[i] = NULL; | |
| 20 release_ref(inputlist[0]); | |
| 21 inputlist[0] = output; | |
| 22 return 0; | |
| 23 } | |
| 24 | |
| 25 BOOL list_to_array(datum * list_dat, datum ** out_params, int num) | |
| 26 { | |
| 27 int i; | |
| 28 datum * params[2]; | |
| 29 list_data * list = list_dat->c.generic.data; | |
| 30 if(num > list->num_entries) { | |
| 31 return FALSE; | |
| 32 } | |
| 33 for(i = 0; i < num; ++i) | |
| 34 out_params[i] = add_ref(list->entries[i]); | |
| 35 release_ref(list_dat); | |
| 36 return TRUE; | |
| 37 } | |
| 38 | |
| 39 datum * array_to_list(datum ** in_params, int num, program * prog) | |
| 40 { | |
| 41 int i; | |
| 42 datum * params[2]; | |
| 43 params[0] = create_list(prog); | |
| 44 for(i = 0; i < num; ++i) | |
| 45 { | |
| 46 params[1] = in_params[i]; | |
| 47 vis_list_append(params, NULL); | |
| 48 } | |
| 49 return params[0]; | |
| 50 } | |
| 51 | |
| 52 int worker_populate_inputs(datum * inputWorker, datum * ioList, datum ** inputlist) | |
| 53 { | |
| 54 int i,j=0; | |
| 55 worker_datum * work = inputWorker->c.generic.data; | |
| 56 list_data * list = ioList->c.generic.data; | |
| 57 for(i = 0; i < work->def->num_inputs; ++i) | |
| 58 if(work->params[i]) | |
| 59 { | |
| 60 DEBUGPRINTF("Setting input %d to %X from worker object\n", i, work->params[i]); | |
| 61 inputlist[i] = add_ref(work->params[i]); | |
| 62 } | |
| 63 else | |
| 64 { | |
| 65 if(j < list->num_entries) | |
| 66 { | |
| 67 DEBUGPRINTF("Setting input %d to %X from input %d\n", i, list->entries[j], j); | |
| 68 inputlist[i] = add_ref(list->entries[j]); | |
| 69 ++j; | |
| 70 } | |
| 71 else | |
| 72 { | |
| 73 ERRORPRINTF("Error: List passed to Do@Worker doesn't have enough entries for worker %s\n", work->def->name); | |
| 74 return -1; | |
| 75 } | |
| 76 } | |
| 77 return 0; | |
| 78 } | |
| 79 | |
| 80 int vis_worker_do(datum ** inputlist, queue_entry * worker_entry) | |
| 81 { | |
| 82 //int i,j; | |
| 83 worker_datum * work; | |
| 84 //worker_def * def; | |
| 85 //list_data * list; | |
| 86 datum * inputWorker = inputlist[0]; | |
| 87 datum * ioList = inputlist[1]; | |
| 88 int returnval; | |
| 89 //release_ref(inputlist[0]); | |
| 90 work = inputlist[0]->c.generic.data; | |
| 91 //list_to_array(inputlist[1], inputlist, work->def->num_inputs); | |
| 92 /*list = inputlist[1]->c.generic.data; | |
| 93 j = 0; | |
| 94 DEBUGPRINTF("vis_worker_do: def_name: %s, num_inputs = %d, list length = %d\n", work->def->name, work->def->num_inputs, list->num_entries); | |
| 95 for(i = 0; i < work->def->num_inputs; ++i) | |
| 96 if(work->params[i]) | |
| 97 { | |
| 98 DEBUGPRINTF("Setting input %d to %X from worker object\n", i, work->params[i]); | |
| 99 inputlist[i] = add_ref(work->params[i]); | |
| 100 } | |
| 101 else | |
| 102 { | |
| 103 DEBUGPRINTF("Setting input %d to %X from input %d, company name: %s\n", i, list->entries[j], j, list->entries[j]->company->name); | |
| 104 inputlist[i] = add_ref(list->entries[j]); | |
| 105 ++j; | |
| 106 }*/ | |
| 107 returnval = worker_populate_inputs(inputWorker, ioList, inputlist); | |
| 108 release_ref(ioList); | |
| 109 if(returnval) | |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
0
diff
changeset
|
110 { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
0
diff
changeset
|
111 print_stack_trace(worker_entry->instance); |
| 0 | 112 return returnval; |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
0
diff
changeset
|
113 } |
| 0 | 114 if(work->def->program != worker_entry->instance->def->program) { |
| 115 prep_program(work->def->program ); | |
| 116 } | |
| 117 returnval = execute_def(work->def, *worker_entry, inputlist, pack_list_sub_callback); | |
| 118 if(returnval == 0) | |
| 119 { | |
| 120 inputlist[0] = array_to_list(inputlist, work->def->num_outputs, worker_entry->instance->def->program); | |
| 121 /*vis_list_new(params, NULL); | |
| 122 DEBUGPRINTF("params[0] after vis_list_new: %X\n", params[0]); | |
| 123 for(i = 0; i < work->def->num_outputs; ++i) | |
| 124 { | |
| 125 params[1] = inputlist[i]; | |
| 126 vis_list_append(params, NULL); | |
| 127 DEBUGPRINTF("params[0] after vis_list_append: %X\n", params[0]); | |
| 128 } | |
| 129 inputlist[0] = params[0];*/ | |
| 130 } | |
| 131 release_ref(inputWorker); | |
| 132 return returnval; | |
| 133 } | |
| 134 | |
| 135 int vis_worker_setinput(datum ** inputlist, queue_entry * worker_entry) | |
| 136 { | |
| 137 worker_datum * work; | |
| 138 inputlist[0] = copy_datum(inputlist[0], 0); | |
| 139 work = inputlist[0]->c.generic.data; | |
| 140 if(inputlist[1]->c.integers.num_a < 32) | |
| 141 work->params[inputlist[1]->c.integers.num_a] = inputlist[2]; | |
| 142 else | |
| 143 { | |
| 144 puts("Error: Visuality currently only supports 32 inputs\n"); | |
| 145 execute_active = FALSE; | |
| 146 return -1; | |
| 147 } | |
| 148 release_ref(inputlist[1]); | |
| 149 inputlist[1] = inputlist[2] = NULL; | |
| 150 return 0; | |
| 151 } | |
| 152 | |
| 153 int vis_worker_add_worker_call(datum ** inputlist, queue_entry * worker_entry) | |
| 154 { | |
| 155 worker_datum * add_work; | |
| 156 worker_datum * work = inputlist[0]->c.generic.data; | |
| 157 int index; | |
| 158 add_work = inputlist[1]->c.generic.data; | |
| 159 /*index = add_work->def - work->def->program->deflist; | |
| 160 DEBUGPRINTF("work->def: %X, deflist: %X\n", work->def, worker_entry->instance->def->program->deflist); | |
| 161 DEBUGPRINTF("work->def->name: %X\n", work->def->name);*/ | |
| 162 index = add_worker_to_def(work->def, add_work->def, 1.0, 1.0); | |
| 163 release_ref(inputlist[1]); | |
| 164 inputlist[1] = new_datum(BUILTIN_TYPE_WHOLE, 2, 0, worker_entry->instance->def->program); | |
| 165 inputlist[1]->c.integers.num_a = index; | |
| 166 return 0; | |
| 167 } | |
| 168 | |
| 169 int vis_worker_add_wire(datum ** inputlist, queue_entry * worker_entry) | |
| 170 { | |
| 171 worker_datum * work = inputlist[0]->c.generic.data; | |
| 172 add_wire(work->def, inputlist[1]->c.integers.num_a, inputlist[2]->c.integers.num_a, inputlist[3]->c.integers.num_a, inputlist[4]->c.integers.num_a); | |
| 173 release_ref(inputlist[1]); | |
| 174 release_ref(inputlist[2]); | |
| 175 release_ref(inputlist[3]); | |
| 176 release_ref(inputlist[4]); | |
| 177 return 0; | |
| 178 } | |
| 179 | |
| 180 void list_change_program(list_data * list, program * new_prog) | |
| 181 { | |
| 182 int i; | |
| 183 for(i = 0; i < list->num_entries; ++i) | |
| 184 { | |
| 185 if(list->entries[i] && list->entries[i]->company->type_id < USER_DEFINED_TYPES) | |
| 186 { | |
| 187 list->entries[i] = copy_datum(list->entries[i], 0); | |
| 188 list->entries[i]->company = new_prog->companylist + list->entries[i]->company->type_id; | |
| 189 if(list->entries[i]->company->type_id == BUILTIN_TYPE_LIST) | |
| 190 list_change_program(list->entries[i]->c.generic.data, new_prog); | |
| 191 } | |
| 192 } | |
| 193 } | |
| 194 | |
| 195 int vis_worker_add_constant(datum ** inputlist, queue_entry * worker_entry) | |
| 196 { | |
| 197 datum * constant = inputlist[1]; | |
| 198 worker_datum * work = inputlist[0]->c.generic.data; | |
| 199 int index = add_constant(work->def, "code generated", 1.0, 1.0); | |
| 200 if(worker_entry->instance->def->program != work->def->program && constant->company->type_id < USER_DEFINED_TYPES) | |
| 201 { | |
| 202 constant = copy_datum(constant, 0); | |
| 203 constant->company = work->def->program->companylist + constant->company->type_id; | |
| 204 if(constant->company->type_id == BUILTIN_TYPE_LIST) | |
| 205 { | |
| 206 list_change_program(constant->c.generic.data, work->def->program); | |
| 207 } | |
| 208 } | |
| 209 work->def->implement_func->workerlist[index].value_index = constant; | |
| 210 inputlist[1] = new_datum(BUILTIN_TYPE_WHOLE, 2, 0, worker_entry->instance->def->program); | |
| 211 inputlist[1]->c.integers.num_a = index; | |
| 212 return 0; | |
| 213 } | |
| 214 | |
| 215 int vis_worker_add_input(datum ** inputlist, queue_entry * worker_entry) | |
| 216 { | |
| 217 worker_datum * work = inputlist[0]->c.generic.data; | |
| 218 int index = add_input_num(work->def, inputlist[1]->c.generic.data, inputlist[2]->c.integers.num_a, 1.0, 1.0); | |
| 219 release_ref(inputlist[1]); | |
| 220 release_ref(inputlist[2]); | |
| 221 inputlist[1] = new_datum(BUILTIN_TYPE_WHOLE, 2, 0, worker_entry->instance->def->program); | |
| 222 inputlist[1]->c.integers.num_a = index; | |
| 223 return 0; | |
| 224 } | |
| 225 | |
| 226 int vis_worker_add_output(datum ** inputlist, queue_entry * worker_entry) | |
| 227 { | |
| 228 worker_datum * work = inputlist[0]->c.generic.data; | |
| 229 int index = add_output_num(work->def, inputlist[1]->c.generic.data, inputlist[2]->c.integers.num_a, 1.0, 1.0); | |
| 230 release_ref(inputlist[1]); | |
| 231 release_ref(inputlist[2]); | |
| 232 inputlist[1] = new_datum(BUILTIN_TYPE_WHOLE, 2, 0, worker_entry->instance->def->program); | |
| 233 inputlist[1]->c.integers.num_a = index; | |
| 234 return 0; | |
| 235 } | |
| 236 | |
| 237 int vis_worker_add_objectget(datum ** inputlist, queue_entry * worker_entry) | |
| 238 { | |
| 239 worker_datum * work = inputlist[0]->c.generic.data; | |
| 240 int index = add_get_comp_room(work->def, inputlist[1]->c.generic.data, 1.0,1.0); | |
| 241 release_ref(inputlist[1]); | |
| 242 inputlist[1] = new_datum(BUILTIN_TYPE_WHOLE, 2, 0, worker_entry->instance->def->program); | |
| 243 inputlist[1]->c.integers.num_a = index; | |
| 244 return 0; | |
| 245 } | |
| 246 | |
| 247 int vis_worker_add_objectset(datum ** inputlist, queue_entry * worker_entry) | |
| 248 { | |
| 249 worker_datum * work = inputlist[0]->c.generic.data; | |
| 250 int index = add_set_comp_room(work->def, inputlist[1]->c.generic.data, 1.0,1.0); | |
| 251 release_ref(inputlist[1]); | |
| 252 inputlist[1] = new_datum(BUILTIN_TYPE_WHOLE, 2, 0, worker_entry->instance->def->program); | |
| 253 inputlist[1]->c.integers.num_a = index; | |
| 254 return 0; | |
| 255 } | |
| 256 | |
| 257 int vis_worker_add_globalget(datum ** inputlist, queue_entry * worker_entry) | |
| 258 { | |
| 259 worker_datum * work = inputlist[0]->c.generic.data; | |
| 260 int index; | |
| 261 char * name = malloc(inputlist[1]->c.generic.len + inputlist[2]->c.generic.len + 1); | |
| 262 memcpy(name, inputlist[1]->c.generic.data, inputlist[1]->c.generic.len); | |
| 263 release_ref(inputlist[1]); | |
| 264 strcat(name, "::"); | |
| 265 strcat(name, inputlist[2]->c.generic.data); | |
| 266 release_ref(inputlist[2]); | |
| 267 index = add_global_get(work->def, name, 1.0,1.0); | |
| 268 free(name); | |
| 269 inputlist[1] = new_datum(BUILTIN_TYPE_WHOLE, 2, 0, worker_entry->instance->def->program); | |
| 270 inputlist[1]->c.integers.num_a = index; | |
| 271 return 0; | |
| 272 } | |
| 273 | |
| 274 int vis_worker_add_globalset(datum ** inputlist, queue_entry * worker_entry) | |
| 275 { | |
| 276 worker_datum * work = inputlist[0]->c.generic.data; | |
| 277 int index; | |
| 278 char * name = malloc(inputlist[1]->c.generic.len + inputlist[2]->c.generic.len + 1); | |
| 279 memcpy(name, inputlist[1]->c.generic.data, inputlist[1]->c.generic.len); | |
| 280 release_ref(inputlist[1]); | |
| 281 strcat(name, "::"); | |
| 282 strcat(name, inputlist[2]->c.generic.data); | |
| 283 release_ref(inputlist[2]); | |
| 284 index = add_global_set(work->def, name, 1.0,1.0); | |
| 285 free(name); | |
| 286 inputlist[1] = new_datum(BUILTIN_TYPE_WHOLE, 2, 0, worker_entry->instance->def->program); | |
| 287 inputlist[1]->c.integers.num_a = index; | |
| 288 return 0; | |
| 289 } | |
| 290 | |
| 291 int vis_worker_new(datum ** inputlist, queue_entry * worker_entry) | |
| 292 { | |
| 293 int i; | |
| 294 datum * output = new_datum(BUILTIN_TYPE_WORKER, 1, sizeof(worker_datum), worker_entry->instance->def->program); | |
| 295 worker_datum * work = output->c.generic.data; | |
| 296 work->def = create_worker(worker_entry->instance->def->program, inputlist[0]->c.generic.data, 0, 0, USER_FLAG | WORKER_TYPE); | |
| 297 add_program_ref(work->def->program); | |
| 298 for(i = 0; i < 32; ++i) | |
| 299 work->params[i] = NULL; | |
| 300 release_ref(inputlist[0]); | |
| 301 inputlist[0] = output; | |
| 302 return 0; | |
| 303 } | |
| 304 | |
| 305 int vis_worker_clear(datum ** inputlist, queue_entry * worker_entry) | |
| 306 { | |
| 307 int i; | |
| 308 worker_datum * work = inputlist[0]->c.generic.data; | |
| 309 VIS_EnterCriticalSection(work->def->implement_func->lock); | |
| 310 for(i = 0; i < work->def->implement_func->num_workers; ++i) { | |
| 311 if(work->def->implement_func->workerlist[i].type == CONSTANT) { | |
| 312 release_ref(work->def->implement_func->workerlist[i].value_index); | |
| 313 } | |
| 314 } | |
| 315 work->def->num_inputs = 0; | |
| 316 work->def->num_outputs = 0; | |
| 317 work->def->implement_func->num_workers = 0; | |
| 318 work->def->implement_func->num_wires = 0; | |
| 319 work->def->implement_func->dirty = TRUE; | |
| 320 VIS_LeaveCriticalSection(work->def->implement_func->lock); | |
| 321 return 0; | |
| 322 } | |
| 323 | |
| 324 int vis_worker_uses(datum ** inputlist, queue_entry * worker_entry) | |
| 325 { | |
| 326 int i; | |
| 327 worker_datum * work = inputlist[0]->c.generic.data; | |
| 328 list_data * list = inputlist[1]->c.generic.data; | |
| 329 char ** new_uses; | |
| 330 if(list->num_entries) | |
| 331 { | |
| 332 new_uses = malloc(sizeof(char *) * list->num_entries); | |
| 333 for(i = 0; i < list->num_entries; ++i) { | |
| 334 if(list->entries[i]->company->type_id != BUILTIN_TYPE_STRING) { | |
| 335 ERRORPUTS("List passed to Uses@Worker contains non-string value(s)\n"); | |
| 336 execute_active = FALSE; | |
| 337 return -1; | |
| 338 } | |
| 339 new_uses[i] = malloc(sizeof(char) * list->entries[i]->c.generic.len); | |
| 340 memcpy(new_uses[i], list->entries[i]->c.generic.data, list->entries[i]->c.generic.len); | |
| 341 } | |
| 342 } else | |
| 343 new_uses = NULL; | |
| 344 if(work->def->uses_stores) | |
| 345 free(work->def->uses_stores); | |
| 346 work->def->uses_stores = new_uses; | |
| 347 work->def->num_stores = list->num_entries; | |
| 348 release_ref(inputlist[1]); | |
| 349 return 0; | |
| 350 } | |
| 351 | |
| 352 int vis_worker_setio_counts(datum ** inputlist, queue_entry * worker_entry) | |
| 353 { | |
| 354 int i; | |
| 355 int new_inputs = inputlist[1]->c.integers.num_a; | |
| 356 worker_datum * work = inputlist[0]->c.generic.data; | |
| 357 release_ref(inputlist[1]); | |
| 358 if(work->def->num_inputs < new_inputs) | |
| 359 { | |
| 360 work->def->input_types = realloc(work->def->input_types, sizeof(short)*new_inputs); | |
| 361 for(i = work->def->num_inputs; i < new_inputs; ++i) | |
| 362 work->def->input_types[i] = ANY_TYPE; | |
| 363 } | |
| 364 work->def->num_inputs = new_inputs; | |
| 365 work->def->num_outputs = inputlist[2]->c.integers.num_a; | |
| 366 release_ref(inputlist[2]); | |
| 367 return 0; | |
| 368 } | |
| 369 | |
| 370 int vis_program_new(datum ** inputlist, queue_entry * worker_entry) | |
| 371 { | |
| 372 program * prog = new_program(START_DEF_STORAGE, START_COMP_STORAGE); | |
| 373 inputlist[0] = new_datum(BUILTIN_TYPE_PROGRAM, 2, 0, worker_entry->instance->def->program); | |
| 374 inputlist[0]->c.generic.data = prog; | |
| 375 inputlist[0]->c.generic.len = sizeof(program); | |
| 376 //inputlist[0]->union_type = 1; | |
| 377 return 0; | |
| 378 } | |
| 379 | |
| 380 int vis_program_new_worker(datum ** inputlist, queue_entry * worker_entry) | |
| 381 { | |
| 382 int i; | |
| 383 datum * output = new_datum(BUILTIN_TYPE_WORKER, 1, sizeof(worker_datum), worker_entry->instance->def->program); | |
| 384 worker_datum * work = output->c.generic.data; | |
| 385 add_program_ref(inputlist[0]->c.generic.data); | |
| 386 work->def = create_worker(inputlist[0]->c.generic.data, inputlist[1]->c.generic.data, 0, 0, USER_FLAG | WORKER_TYPE); | |
| 387 for(i = 0; i < 32; ++i) | |
| 388 work->params[i] = NULL; | |
| 389 release_ref(inputlist[1]); | |
| 390 inputlist[1] = output; | |
| 391 return 0; | |
| 392 } | |
| 393 | |
| 394 int vis_program_add_worker(datum ** inputlist, queue_entry * worker_entry) | |
| 395 { | |
| 396 int i; | |
| 397 worker_datum * work = inputlist[1]->c.generic.data; | |
| 398 program * prog = inputlist[0]->c.generic.data; | |
| 399 datum * output = new_datum(BUILTIN_TYPE_WORKER, 1, sizeof(worker_datum), worker_entry->instance->def->program); | |
| 400 worker_datum * out_work = output->c.generic.data; | |
| 401 add_program_ref(inputlist[0]->c.generic.data); | |
| 402 out_work->def = create_worker(prog, work->def->name, work->def->num_inputs, work->def->num_outputs, WORKER_TYPE); | |
| 403 out_work->def->implement_func = work->def->implement_func; | |
| 404 out_work->def->type = work->def->type; | |
| 405 if(work->def->type & USER_FLAG) | |
| 406 out_work->def->program = work->def->program; | |
| 407 for(i = 0; i < work->def->num_inputs; ++i) | |
| 408 out_work->def->input_types[i] = out_work->def->input_types[i]; | |
| 409 release_ref(inputlist[1]); | |
| 410 inputlist[1] = output; | |
| 411 return 0; | |
| 412 } | |
| 413 | |
| 414 int vis_program_add_builtins(datum ** inputlist, queue_entry * worker_entry) | |
| 415 { | |
| 416 initpredefworkers((program *)inputlist[0]->c.generic.data); | |
| 417 return 0; | |
| 418 } | |
| 419 | |
| 420 int vis_program_run(datum ** inputlist, queue_entry * worker_entry) | |
| 421 { | |
| 422 datum * params[32]; | |
| 423 defchunk * current; | |
| 424 int i; | |
| 425 program * prog = inputlist[0]->c.generic.data; | |
| 426 params[0] = inputlist[1]; | |
| 427 VIS_EnterCriticalSection(program_count_lock); | |
| 428 ++program_count; | |
| 429 VIS_LeaveCriticalSection(program_count_lock); | |
| 430 prep_program(prog); | |
| 431 add_program_ref(prog); | |
| 432 init_custom_worker(-1, NULL, prog->defs->deflist, main_callback, add_ref(inputlist[0]), params); | |
| 433 return 0; | |
| 434 } | |
| 435 | |
| 436 int vis_program_find_worker(datum ** inputlist, queue_entry * worker_entry) | |
| 437 { | |
| 438 int i,returnval; | |
| 439 worker_datum * work; | |
| 440 worker_def * def; | |
| 441 program * prog = inputlist[0]->c.generic.data; | |
| 442 returnval = find_worker(inputlist[1]->c.generic.data, NULL, NULL, prog, &def); | |
| 443 release_ref(inputlist[0]); | |
| 444 if(returnval >= 0) | |
| 445 { | |
| 446 add_program_ref(prog); | |
| 447 release_ref(inputlist[1]); | |
| 448 inputlist[0] = new_datum(BUILTIN_TYPE_WORKER, 1, sizeof(worker_datum), worker_entry->instance->def->program); | |
| 449 inputlist[1] = NULL; | |
| 450 work = inputlist[0]->c.generic.data; | |
| 451 work->def = def; | |
| 452 for(i = 0; i < 32; ++i) | |
| 453 work->params[i] = NULL; | |
| 454 } else { | |
| 455 inputlist[0] = NULL; | |
| 456 } | |
| 457 return 0; | |
| 458 } | |
| 459 | |
| 460 void free_worker(worker_def * def) | |
| 461 { | |
| 462 int i; | |
| 463 if(def->type & USER_FLAG && (def->type & TYPE_MASK) == WORKER_TYPE) | |
| 464 { | |
| 465 for(i = 0; i < def->implement_func->num_workers; ++i) | |
| 466 if(def->implement_func->workerlist[i].type == CONSTANT) | |
| 467 release_ref(def->implement_func->workerlist[i].value_index); | |
| 468 free(def->implement_func->workerlist); | |
| 469 free(def->implement_func->wirelist); | |
| 470 free(def->implement_func->workers_to_wires_up); | |
| 471 free(def->implement_func->workers_to_wires_down); | |
| 472 free(def->implement_func); | |
| 473 } | |
| 474 free(def->name); | |
| 475 free(def->input_types); | |
| 476 free(def->output_types); | |
| 477 } | |
| 478 | |
| 479 void free_company(company * comp) | |
| 480 { | |
| 481 free(comp->methodlist); | |
| 482 free(comp->room_list); | |
| 483 } | |
| 484 | |
| 485 void add_program_ref(program * prog) | |
| 486 { | |
| 487 VIS_EnterCriticalSection(prog->lock); | |
| 488 ++prog->refcount; | |
| 489 VIS_LeaveCriticalSection(prog->lock); | |
| 490 } | |
| 491 | |
| 492 void release_program_ref(program * prog) | |
| 493 { | |
| 494 int i; | |
| 495 defchunk * current, *temp; | |
| 496 VIS_EnterCriticalSection(prog->lock); | |
| 497 --prog->refcount; | |
| 498 if(!prog->refcount) { | |
| 499 VIS_LeaveCriticalSection(prog->lock); | |
| 500 VIS_DeleteCriticalSection(prog->lock); | |
| 501 current = prog->defs; | |
| 502 while(current) | |
| 503 { | |
| 504 for(i = 0; i < current->num_defs; ++i) | |
| 505 { | |
| 506 free_worker(current->deflist + i); | |
| 507 } | |
| 508 current = current->next; | |
| 509 } | |
| 510 current = prog->defs; | |
| 511 while(current) | |
| 512 { | |
| 513 temp = current; | |
| 514 current = current->next; | |
| 515 free(temp); | |
| 516 } | |
| 517 //FIXME: We can't currently free the object definitions because of issues related to global stores | |
| 518 //for(i = 0; i < prog->num_companies; ++i) | |
| 519 // free_company(prog->companylist + i); | |
| 520 //free(prog->companylist); | |
| 521 free(prog); | |
| 522 } else { | |
| 523 VIS_LeaveCriticalSection(prog->lock); | |
| 524 } | |
| 525 } | |
| 526 | |
| 527 /* | |
| 528 int vis_worker_begin_transaction(datum ** inputlist, queue_entry * worker_entry) | |
| 529 { | |
| 530 worker_def * def; | |
| 531 int returnval; | |
| 532 datum * params[2]; | |
| 533 int i; | |
| 534 global_store * store; | |
| 535 list_data * list = inputist[0]->c.generic.data; | |
| 536 transaction * trans = malloc(sizeof(transaction) + list->num_entries - 1); | |
| 537 trans->num_stores = list->num_entries; | |
| 538 VIS_EnterCriticalSection(global_store_lock); | |
| 539 for(i = 0; i < list->num_entries; ++i) | |
| 540 { | |
| 541 params[0] = global_store_dict; | |
| 542 params[1] = add_ref(list->entries[i]); | |
| 543 vis_dict_index(params, NULL); | |
| 544 store = params[0]->c.generic.data; | |
| 545 while(store->inuse) | |
| 546 { | |
| 547 VIS_LeaveCriticalSection(global_store_lock); | |
| 548 #ifdef WIN32 | |
| 549 Sleep(0); | |
| 550 #else | |
| 551 sleep(0); | |
| 552 #endif | |
| 553 VIS_EnterCriticalSection(global_store_lock); | |
| 554 } | |
| 555 store->inuse; | |
| 556 trans->stores[i] = params[0]; | |
| 557 } | |
| 558 VIS_LeaveCriticalSection(global_store_lock; | |
| 559 release_ref(inputlist[0]); | |
| 560 def = deflist+inputlist[1]->c.integers.num_a; | |
| 561 release_ref(inputlist[1]); | |
| 562 list_to_array(inputlist[2], inputlist, def->num_inputs); | |
| 563 returnval = execute_def_data(def, *worker_entry, inputlist, trasnaction_sub_callback, transaction); | |
| 564 if(returnval == 0) | |
| 565 inputlist[0] = array_to_list(inputlist, def->num_outputs); | |
| 566 return returnval; | |
| 567 } | |
| 568 | |
| 569 */ | |
| 570 |