Mercurial > repos > rhope

comparison worker.c @ 0:76568becd6d6

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Rhope Alpha 2a source import
author Mike Pavone <pavone@retrodev.com>
date Tue, 28 Apr 2009 23:06:07 +0000
parents
children 914ad38f9b59
comparison
equal deleted inserted replaced
-1:000000000000 0:76568becd6d6
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)
110 return returnval;
111 if(work->def->program != worker_entry->instance->def->program) {
112 prep_program(work->def->program );
113 }
114 returnval = execute_def(work->def, *worker_entry, inputlist, pack_list_sub_callback);
115 if(returnval == 0)
116 {
117 inputlist[0] = array_to_list(inputlist, work->def->num_outputs, worker_entry->instance->def->program);
118 /*vis_list_new(params, NULL);
119 DEBUGPRINTF("params[0] after vis_list_new: %X\n", params[0]);
120 for(i = 0; i < work->def->num_outputs; ++i)
121 {
122 params[1] = inputlist[i];
123 vis_list_append(params, NULL);
124 DEBUGPRINTF("params[0] after vis_list_append: %X\n", params[0]);
125 }
126 inputlist[0] = params[0];*/
127 }
128 release_ref(inputWorker);
129 return returnval;
130 }
131
132 int vis_worker_setinput(datum ** inputlist, queue_entry * worker_entry)
133 {
134 worker_datum * work;
135 inputlist[0] = copy_datum(inputlist[0], 0);
136 work = inputlist[0]->c.generic.data;
137 if(inputlist[1]->c.integers.num_a < 32)
138 work->params[inputlist[1]->c.integers.num_a] = inputlist[2];
139 else
140 {
141 puts("Error: Visuality currently only supports 32 inputs\n");
142 execute_active = FALSE;
143 return -1;
144 }
145 release_ref(inputlist[1]);
146 inputlist[1] = inputlist[2] = NULL;
147 return 0;
148 }
149
150 int vis_worker_add_worker_call(datum ** inputlist, queue_entry * worker_entry)
151 {
152 worker_datum * add_work;
153 worker_datum * work = inputlist[0]->c.generic.data;
154 int index;
155 add_work = inputlist[1]->c.generic.data;
156 /*index = add_work->def - work->def->program->deflist;
157 DEBUGPRINTF("work->def: %X, deflist: %X\n", work->def, worker_entry->instance->def->program->deflist);
158 DEBUGPRINTF("work->def->name: %X\n", work->def->name);*/
159 index = add_worker_to_def(work->def, add_work->def, 1.0, 1.0);
160 release_ref(inputlist[1]);
161 inputlist[1] = new_datum(BUILTIN_TYPE_WHOLE, 2, 0, worker_entry->instance->def->program);
162 inputlist[1]->c.integers.num_a = index;
163 return 0;
164 }
165
166 int vis_worker_add_wire(datum ** inputlist, queue_entry * worker_entry)
167 {
168 worker_datum * work = inputlist[0]->c.generic.data;
169 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);
170 release_ref(inputlist[1]);
171 release_ref(inputlist[2]);
172 release_ref(inputlist[3]);
173 release_ref(inputlist[4]);
174 return 0;
175 }
176
177 void list_change_program(list_data * list, program * new_prog)
178 {
179 int i;
180 for(i = 0; i < list->num_entries; ++i)
181 {
182 if(list->entries[i] && list->entries[i]->company->type_id < USER_DEFINED_TYPES)
183 {
184 list->entries[i] = copy_datum(list->entries[i], 0);
185 list->entries[i]->company = new_prog->companylist + list->entries[i]->company->type_id;
186 if(list->entries[i]->company->type_id == BUILTIN_TYPE_LIST)
187 list_change_program(list->entries[i]->c.generic.data, new_prog);
188 }
189 }
190 }
191
192 int vis_worker_add_constant(datum ** inputlist, queue_entry * worker_entry)
193 {
194 datum * constant = inputlist[1];
195 worker_datum * work = inputlist[0]->c.generic.data;
196 int index = add_constant(work->def, "code generated", 1.0, 1.0);
197 if(worker_entry->instance->def->program != work->def->program && constant->company->type_id < USER_DEFINED_TYPES)
198 {
199 constant = copy_datum(constant, 0);
200 constant->company = work->def->program->companylist + constant->company->type_id;
201 if(constant->company->type_id == BUILTIN_TYPE_LIST)
202 {
203 list_change_program(constant->c.generic.data, work->def->program);
204 }
205 }
206 work->def->implement_func->workerlist[index].value_index = constant;
207 inputlist[1] = new_datum(BUILTIN_TYPE_WHOLE, 2, 0, worker_entry->instance->def->program);
208 inputlist[1]->c.integers.num_a = index;
209 return 0;
210 }
211
212 int vis_worker_add_input(datum ** inputlist, queue_entry * worker_entry)
213 {
214 worker_datum * work = inputlist[0]->c.generic.data;
215 int index = add_input_num(work->def, inputlist[1]->c.generic.data, inputlist[2]->c.integers.num_a, 1.0, 1.0);
216 release_ref(inputlist[1]);
217 release_ref(inputlist[2]);
218 inputlist[1] = new_datum(BUILTIN_TYPE_WHOLE, 2, 0, worker_entry->instance->def->program);
219 inputlist[1]->c.integers.num_a = index;
220 return 0;
221 }
222
223 int vis_worker_add_output(datum ** inputlist, queue_entry * worker_entry)
224 {
225 worker_datum * work = inputlist[0]->c.generic.data;
226 int index = add_output_num(work->def, inputlist[1]->c.generic.data, inputlist[2]->c.integers.num_a, 1.0, 1.0);
227 release_ref(inputlist[1]);
228 release_ref(inputlist[2]);
229 inputlist[1] = new_datum(BUILTIN_TYPE_WHOLE, 2, 0, worker_entry->instance->def->program);
230 inputlist[1]->c.integers.num_a = index;
231 return 0;
232 }
233
234 int vis_worker_add_objectget(datum ** inputlist, queue_entry * worker_entry)
235 {
236 worker_datum * work = inputlist[0]->c.generic.data;
237 int index = add_get_comp_room(work->def, inputlist[1]->c.generic.data, 1.0,1.0);
238 release_ref(inputlist[1]);
239 inputlist[1] = new_datum(BUILTIN_TYPE_WHOLE, 2, 0, worker_entry->instance->def->program);
240 inputlist[1]->c.integers.num_a = index;
241 return 0;
242 }
243
244 int vis_worker_add_objectset(datum ** inputlist, queue_entry * worker_entry)
245 {
246 worker_datum * work = inputlist[0]->c.generic.data;
247 int index = add_set_comp_room(work->def, inputlist[1]->c.generic.data, 1.0,1.0);
248 release_ref(inputlist[1]);
249 inputlist[1] = new_datum(BUILTIN_TYPE_WHOLE, 2, 0, worker_entry->instance->def->program);
250 inputlist[1]->c.integers.num_a = index;
251 return 0;
252 }
253
254 int vis_worker_add_globalget(datum ** inputlist, queue_entry * worker_entry)
255 {
256 worker_datum * work = inputlist[0]->c.generic.data;
257 int index;
258 char * name = malloc(inputlist[1]->c.generic.len + inputlist[2]->c.generic.len + 1);
259 memcpy(name, inputlist[1]->c.generic.data, inputlist[1]->c.generic.len);
260 release_ref(inputlist[1]);
261 strcat(name, "::");
262 strcat(name, inputlist[2]->c.generic.data);
263 release_ref(inputlist[2]);
264 index = add_global_get(work->def, name, 1.0,1.0);
265 free(name);
266 inputlist[1] = new_datum(BUILTIN_TYPE_WHOLE, 2, 0, worker_entry->instance->def->program);
267 inputlist[1]->c.integers.num_a = index;
268 return 0;
269 }
270
271 int vis_worker_add_globalset(datum ** inputlist, queue_entry * worker_entry)
272 {
273 worker_datum * work = inputlist[0]->c.generic.data;
274 int index;
275 char * name = malloc(inputlist[1]->c.generic.len + inputlist[2]->c.generic.len + 1);
276 memcpy(name, inputlist[1]->c.generic.data, inputlist[1]->c.generic.len);
277 release_ref(inputlist[1]);
278 strcat(name, "::");
279 strcat(name, inputlist[2]->c.generic.data);
280 release_ref(inputlist[2]);
281 index = add_global_set(work->def, name, 1.0,1.0);
282 free(name);
283 inputlist[1] = new_datum(BUILTIN_TYPE_WHOLE, 2, 0, worker_entry->instance->def->program);
284 inputlist[1]->c.integers.num_a = index;
285 return 0;
286 }
287
288 int vis_worker_new(datum ** inputlist, queue_entry * worker_entry)
289 {
290 int i;
291 datum * output = new_datum(BUILTIN_TYPE_WORKER, 1, sizeof(worker_datum), worker_entry->instance->def->program);
292 worker_datum * work = output->c.generic.data;
293 work->def = create_worker(worker_entry->instance->def->program, inputlist[0]->c.generic.data, 0, 0, USER_FLAG | WORKER_TYPE);
294 add_program_ref(work->def->program);
295 for(i = 0; i < 32; ++i)
296 work->params[i] = NULL;
297 release_ref(inputlist[0]);
298 inputlist[0] = output;
299 return 0;
300 }
301
302 int vis_worker_clear(datum ** inputlist, queue_entry * worker_entry)
303 {
304 int i;
305 worker_datum * work = inputlist[0]->c.generic.data;
306 VIS_EnterCriticalSection(work->def->implement_func->lock);
307 for(i = 0; i < work->def->implement_func->num_workers; ++i) {
308 if(work->def->implement_func->workerlist[i].type == CONSTANT) {
309 release_ref(work->def->implement_func->workerlist[i].value_index);
310 }
311 }
312 work->def->num_inputs = 0;
313 work->def->num_outputs = 0;
314 work->def->implement_func->num_workers = 0;
315 work->def->implement_func->num_wires = 0;
316 work->def->implement_func->dirty = TRUE;
317 VIS_LeaveCriticalSection(work->def->implement_func->lock);
318 return 0;
319 }
320
321 int vis_worker_uses(datum ** inputlist, queue_entry * worker_entry)
322 {
323 int i;
324 worker_datum * work = inputlist[0]->c.generic.data;
325 list_data * list = inputlist[1]->c.generic.data;
326 char ** new_uses;
327 if(list->num_entries)
328 {
329 new_uses = malloc(sizeof(char *) * list->num_entries);
330 for(i = 0; i < list->num_entries; ++i) {
331 if(list->entries[i]->company->type_id != BUILTIN_TYPE_STRING) {
332 ERRORPUTS("List passed to Uses@Worker contains non-string value(s)\n");
333 execute_active = FALSE;
334 return -1;
335 }
336 new_uses[i] = malloc(sizeof(char) * list->entries[i]->c.generic.len);
337 memcpy(new_uses[i], list->entries[i]->c.generic.data, list->entries[i]->c.generic.len);
338 }
339 } else
340 new_uses = NULL;
341 if(work->def->uses_stores)
342 free(work->def->uses_stores);
343 work->def->uses_stores = new_uses;
344 work->def->num_stores = list->num_entries;
345 release_ref(inputlist[1]);
346 return 0;
347 }
348
349 int vis_worker_setio_counts(datum ** inputlist, queue_entry * worker_entry)
350 {
351 int i;
352 int new_inputs = inputlist[1]->c.integers.num_a;
353 worker_datum * work = inputlist[0]->c.generic.data;
354 release_ref(inputlist[1]);
355 if(work->def->num_inputs < new_inputs)
356 {
357 work->def->input_types = realloc(work->def->input_types, sizeof(short)*new_inputs);
358 for(i = work->def->num_inputs; i < new_inputs; ++i)
359 work->def->input_types[i] = ANY_TYPE;
360 }
361 work->def->num_inputs = new_inputs;
362 work->def->num_outputs = inputlist[2]->c.integers.num_a;
363 release_ref(inputlist[2]);
364 return 0;
365 }
366
367 int vis_program_new(datum ** inputlist, queue_entry * worker_entry)
368 {
369 program * prog = new_program(START_DEF_STORAGE, START_COMP_STORAGE);
370 inputlist[0] = new_datum(BUILTIN_TYPE_PROGRAM, 2, 0, worker_entry->instance->def->program);
371 inputlist[0]->c.generic.data = prog;
372 inputlist[0]->c.generic.len = sizeof(program);
373 //inputlist[0]->union_type = 1;
374 return 0;
375 }
376
377 int vis_program_new_worker(datum ** inputlist, queue_entry * worker_entry)
378 {
379 int i;
380 datum * output = new_datum(BUILTIN_TYPE_WORKER, 1, sizeof(worker_datum), worker_entry->instance->def->program);
381 worker_datum * work = output->c.generic.data;
382 add_program_ref(inputlist[0]->c.generic.data);
383 work->def = create_worker(inputlist[0]->c.generic.data, inputlist[1]->c.generic.data, 0, 0, USER_FLAG | WORKER_TYPE);
384 for(i = 0; i < 32; ++i)
385 work->params[i] = NULL;
386 release_ref(inputlist[1]);
387 inputlist[1] = output;
388 return 0;
389 }
390
391 int vis_program_add_worker(datum ** inputlist, queue_entry * worker_entry)
392 {
393 int i;
394 worker_datum * work = inputlist[1]->c.generic.data;
395 program * prog = inputlist[0]->c.generic.data;
396 datum * output = new_datum(BUILTIN_TYPE_WORKER, 1, sizeof(worker_datum), worker_entry->instance->def->program);
397 worker_datum * out_work = output->c.generic.data;
398 add_program_ref(inputlist[0]->c.generic.data);
399 out_work->def = create_worker(prog, work->def->name, work->def->num_inputs, work->def->num_outputs, WORKER_TYPE);
400 out_work->def->implement_func = work->def->implement_func;
401 out_work->def->type = work->def->type;
402 if(work->def->type & USER_FLAG)
403 out_work->def->program = work->def->program;
404 for(i = 0; i < work->def->num_inputs; ++i)
405 out_work->def->input_types[i] = out_work->def->input_types[i];
406 release_ref(inputlist[1]);
407 inputlist[1] = output;
408 return 0;
409 }
410
411 int vis_program_add_builtins(datum ** inputlist, queue_entry * worker_entry)
412 {
413 initpredefworkers((program *)inputlist[0]->c.generic.data);
414 return 0;
415 }
416
417 int vis_program_run(datum ** inputlist, queue_entry * worker_entry)
418 {
419 datum * params[32];
420 defchunk * current;
421 int i;
422 program * prog = inputlist[0]->c.generic.data;
423 params[0] = inputlist[1];
424 VIS_EnterCriticalSection(program_count_lock);
425 ++program_count;
426 VIS_LeaveCriticalSection(program_count_lock);
427 prep_program(prog);
428 add_program_ref(prog);
429 init_custom_worker(-1, NULL, prog->defs->deflist, main_callback, add_ref(inputlist[0]), params);
430 return 0;
431 }
432
433 int vis_program_find_worker(datum ** inputlist, queue_entry * worker_entry)
434 {
435 int i,returnval;
436 worker_datum * work;
437 worker_def * def;
438 program * prog = inputlist[0]->c.generic.data;
439 returnval = find_worker(inputlist[1]->c.generic.data, NULL, NULL, prog, &def);
440 release_ref(inputlist[0]);
441 if(returnval >= 0)
442 {
443 add_program_ref(prog);
444 release_ref(inputlist[1]);
445 inputlist[0] = new_datum(BUILTIN_TYPE_WORKER, 1, sizeof(worker_datum), worker_entry->instance->def->program);
446 inputlist[1] = NULL;
447 work = inputlist[0]->c.generic.data;
448 work->def = def;
449 for(i = 0; i < 32; ++i)
450 work->params[i] = NULL;
451 } else {
452 inputlist[0] = NULL;
453 }
454 return 0;
455 }
456
457 void free_worker(worker_def * def)
458 {
459 int i;
460 if(def->type & USER_FLAG && (def->type & TYPE_MASK) == WORKER_TYPE)
461 {
462 for(i = 0; i < def->implement_func->num_workers; ++i)
463 if(def->implement_func->workerlist[i].type == CONSTANT)
464 release_ref(def->implement_func->workerlist[i].value_index);
465 free(def->implement_func->workerlist);
466 free(def->implement_func->wirelist);
467 free(def->implement_func->workers_to_wires_up);
468 free(def->implement_func->workers_to_wires_down);
469 free(def->implement_func);
470 }
471 free(def->name);
472 free(def->input_types);
473 free(def->output_types);
474 }
475
476 void free_company(company * comp)
477 {
478 free(comp->methodlist);
479 free(comp->room_list);
480 }
481
482 void add_program_ref(program * prog)
483 {
484 VIS_EnterCriticalSection(prog->lock);
485 ++prog->refcount;
486 VIS_LeaveCriticalSection(prog->lock);
487 }
488
489 void release_program_ref(program * prog)
490 {
491 int i;
492 defchunk * current, *temp;
493 VIS_EnterCriticalSection(prog->lock);
494 --prog->refcount;
495 if(!prog->refcount) {
496 VIS_LeaveCriticalSection(prog->lock);
497 VIS_DeleteCriticalSection(prog->lock);
498 current = prog->defs;
499 while(current)
500 {
501 for(i = 0; i < current->num_defs; ++i)
502 {
503 free_worker(current->deflist + i);
504 }
505 current = current->next;
506 }
507 current = prog->defs;
508 while(current)
509 {
510 temp = current;
511 current = current->next;
512 free(temp);
513 }
514 //FIXME: We can't currently free the object definitions because of issues related to global stores
515 //for(i = 0; i < prog->num_companies; ++i)
516 // free_company(prog->companylist + i);
517 //free(prog->companylist);
518 free(prog);
519 } else {
520 VIS_LeaveCriticalSection(prog->lock);
521 }
522 }
523
524 /*
525 int vis_worker_begin_transaction(datum ** inputlist, queue_entry * worker_entry)
526 {
527 worker_def * def;
528 int returnval;
529 datum * params[2];
530 int i;
531 global_store * store;
532 list_data * list = inputist[0]->c.generic.data;
533 transaction * trans = malloc(sizeof(transaction) + list->num_entries - 1);
534 trans->num_stores = list->num_entries;
535 VIS_EnterCriticalSection(global_store_lock);
536 for(i = 0; i < list->num_entries; ++i)
537 {
538 params[0] = global_store_dict;
539 params[1] = add_ref(list->entries[i]);
540 vis_dict_index(params, NULL);
541 store = params[0]->c.generic.data;
542 while(store->inuse)
543 {
544 VIS_LeaveCriticalSection(global_store_lock);
545 #ifdef WIN32
546 Sleep(0);
547 #else
548 sleep(0);
549 #endif
550 VIS_EnterCriticalSection(global_store_lock);
551 }
552 store->inuse;
553 trans->stores[i] = params[0];
554 }
555 VIS_LeaveCriticalSection(global_store_lock;
556 release_ref(inputlist[0]);
557 def = deflist+inputlist[1]->c.integers.num_a;
558 release_ref(inputlist[1]);
559 list_to_array(inputlist[2], inputlist, def->num_inputs);
560 returnval = execute_def_data(def, *worker_entry, inputlist, trasnaction_sub_callback, transaction);
561 if(returnval == 0)
562 inputlist[0] = array_to_list(inputlist, def->num_outputs);
563 return returnval;
564 }
565
566 */
567