Mercurial > repos > rhope
annotate worker.c @ 75:0083b2f7b3c7
Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
| author | Mike Pavone <pavone@retrodev.com> |
|---|---|
| date | Tue, 06 Jul 2010 07:52:59 -0400 |
| parents | 914ad38f9b59 |
| 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 |