Mercurial > repos > rhope
annotate worker.c @ 140:c14698c512f1
Untested addition of Pause/Resume
author | Mike Pavone <pavone@retrodev.com> |
---|---|
date | Sat, 20 Nov 2010 20:03:25 +0000 |
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 |