Mercurial > repos > rhope
annotate interp.c @ 28:d8b4d38fceb6
Merged in the worker registration code for the math functions added for ICFP 08
| author | Mike Pavone <pavone@retrodev.com> |
|---|---|
| date | Fri, 26 Jun 2009 19:57:46 -0400 |
| parents | 20d40cb8abf3 |
| children | 3cc5e4a42344 |
| rev | line source |
|---|---|
| 0 | 1 #ifdef WIN32 |
| 2 #include <windows.h> | |
| 3 #include <winsock.h> | |
| 4 #include <crtdbg.h> | |
| 5 #else | |
| 6 #ifdef SYLLABLE | |
| 7 #include <unistd.h> | |
| 8 #include <atheos/threads.h> | |
| 9 #else | |
| 10 #ifdef NINTENDO_DS | |
| 11 #include <nds.h> | |
| 12 #else | |
| 13 #include <unistd.h> | |
| 14 #include <pthread.h> | |
| 15 #endif | |
| 16 #endif | |
| 17 #endif | |
| 18 #include <stdio.h> | |
| 19 #include <stdlib.h> | |
| 20 #include <string.h> | |
| 21 #include <time.h> | |
| 22 #include "mt19937ar.h" | |
| 23 #include "interp.h" | |
| 24 #include "vis_threading.h" | |
| 25 #include "datum.h" | |
| 26 #include "parser.h" | |
| 27 #include "saveload.h" | |
| 28 | |
| 29 #ifdef TEXT_FILE_DEBUG | |
| 30 FILE * debugfile; | |
| 31 #endif | |
| 32 char debugbuffer[1024]; | |
| 33 | |
| 34 //extern HWND hWnd; | |
| 35 extern char new_name_buf[256]; | |
| 36 extern int buf_size; | |
| 37 | |
| 38 int lock_fail_counter; | |
| 39 int lock_counter; | |
| 40 | |
| 41 VIS_CRITICAL_SECTION(data_lock) | |
| 42 VIS_CRITICAL_SECTION(worker_queue_lock) | |
| 43 VIS_CRITICAL_SECTION(randlock) | |
| 44 VIS_Event(queue_add_event) | |
| 45 | |
| 46 int program_count=1; | |
| 47 VIS_CRITICAL_SECTION(program_count_lock) | |
| 48 | |
| 49 //#define ENABLE_PROFILING 1 | |
| 50 | |
| 51 #ifdef ENABLE_PROFILING | |
| 52 | |
| 53 __int64 vis_profile_start_times[NUM_PROFS]; | |
| 54 __int64 vis_profile_running_total[NUM_PROFS]; | |
| 55 int vis_profile_counts[NUM_PROFS]; | |
| 56 | |
| 57 __declspec(naked) | |
| 58 unsigned __int64 __cdecl rdtsc(void) | |
| 59 { | |
| 60 __asm | |
| 61 { | |
| 62 rdtsc | |
| 63 ret ; return value at EDX:EAX | |
| 64 } | |
| 65 } | |
| 66 | |
| 67 | |
| 68 #define PROF_INIT_CUSTOM 0 | |
| 69 #define PROF_WORKER_THREAD 1 | |
| 70 #define PROF_PROCESS_WORKER 2 | |
| 71 #define PROF_CLEANUP_CUSTOM 3 | |
| 72 #define PROF_SUB_CALLBACK 4 | |
| 73 #define PROF_CLEANUP_RELEASE_REFS 5 | |
| 74 #define PROF_CLEANUP_CHECK 6 | |
| 75 #define PROF_CLEANUP_FREELISTS 7 | |
| 76 #define PROF_PROCESS_OUTPUTS 8 | |
| 77 #define PROF_OPT_PREP_INPUT 9 | |
| 78 #define PROF_RUN_OPT 10 | |
| 79 #define PROF_ADDQUEUE 11 | |
| 80 #define PROF_ADDQUEUE_MALLOC 12 | |
| 81 #define PROF_OPT_LOOP 13 | |
| 82 #define PROF_EXECUTE_WORKER 14 | |
| 83 #define PROF_EXECUTE_OTHER 15 | |
| 84 #define PROF_PREP_MAGIC 16 | |
| 85 #define PROF_CONVERT_INPUTS 17 | |
| 86 #define PROF_EXECUTE_CUSTOM 18 | |
| 87 #define PROF_EXECUTE_BUILTIN 19 | |
| 88 #define PROF_EMPTYFUNC 20 | |
| 89 #define PROF_NOCODE 21 | |
| 90 #define PROF_LESSERWHOLE 22 | |
| 91 #define PROF_EQUALWHOLE 23 | |
| 92 #define PROF_PARTIAL_EXEC 24 | |
| 93 #define PROF_ADDWHOLE 25 | |
| 94 #define PROF_FULL_EXEC 26 | |
| 95 #define PROF_OPT_EXEC_USER 27 | |
| 96 #define PROF_OPT_EXEC_BUILT 28 | |
| 97 #define PROF_VIRTUAL_DECODE 27 | |
| 98 #define PROF_VIRTUAL_EXECUTE 28 | |
| 99 | |
| 100 | |
| 101 /*#define VIS_PROFILE_START(index) vis_profile_start_times[index] = rdtsc() | |
| 102 #define VIS_PROFILE_END(index) vis_profile_running_total[index] += (rdtsc()-vis_profile_start_times[index]); ++vis_profile_counts[index] | |
| 103 | |
| 104 #else | |
| 105 | |
| 106 #define VIS_PROFILE_START(index) | |
| 107 #define VIS_PROFILE_END(index)*/ | |
| 108 | |
| 109 #endif | |
| 110 | |
| 111 queue_entry * worker_queue; | |
| 112 queue_section first_section; | |
| 113 queue_section * current_section; | |
| 114 int queue_start; | |
| 115 int queue_len; | |
| 116 | |
| 117 BOOL execute_active=FALSE; | |
| 118 | |
| 119 char text_buf[256]; | |
| 120 int text_buf_size; | |
| 121 VIS_CRITICAL_SECTION(text_buf_lock) | |
| 122 | |
| 123 #ifdef WIN32 | |
| 124 WSADATA wsa_data; | |
| 125 #ifdef GUI_LIB | |
| 126 char errorbuffer[1024]; | |
| 127 #endif | |
| 128 #endif | |
| 129 | |
| 130 | |
| 131 worker_instance * main_instance; | |
| 132 | |
| 133 //company companylist[40]; | |
| 134 //int num_companies=0; | |
| 135 | |
| 136 datum * global_store_dict; | |
| 137 VIS_CRITICAL_SECTION(global_store_lock); | |
| 138 | |
| 139 | |
| 140 int empty_func(datum ** a, queue_entry * worker_entry) | |
| 141 { | |
| 142 return 0; | |
| 143 } | |
| 144 | |
| 145 worker_impl empty_test = empty_func; | |
| 146 /* | |
| 147 void set_in_child(worker_def * parent, int worker_num, BOOL * in_child, BOOL value, int exclude_worker) | |
| 148 { | |
| 149 int j,i = parent->workerlist[worker_num].wire_down_lookup; | |
| 150 if(exclude_worker >= 0 && exclude_worker == worker_num) | |
| 151 return; | |
| 152 in_child[worker_num] = value; | |
| 153 while(parent->wirelist[j=parent->workers_to_wires_down[i]].start_worker == worker_num && j >= 0) | |
| 154 set_in_child(parent, parent->wirelist[j].end_worker, in_child, value); | |
| 155 } | |
| 156 | |
| 157 void build_child_worker(worker_def * parent, int worker_num, int output_num) | |
| 158 { | |
| 159 int i,j, num_child_workers, num_child_wires, child_def; | |
| 160 BOOL * in_child = malloc(sizeof(BOOL)* parent->num_workers); | |
| 161 int * child_offsets = malloc(sizeof(int) * parent->num_workers); | |
| 162 for(i = 0; i < parent->num_workers; ++i) | |
| 163 { | |
| 164 in_child[i] = FALSE; | |
| 165 child_offsets[i] = -1; | |
| 166 } | |
| 167 i = parent->workerlist[worker_num].wire_down_lookup; | |
| 168 while(parent->wirelist[j=parent->workers_to_wires_down[i]].start_worker == worker_num && j >= 0) | |
| 169 { | |
| 170 if(parent->wirelist[j].output_num == output_num) | |
| 171 set_in_child(parent, parent->wirelist[j].end_worker, in_child, TRUE,-1); | |
| 172 } | |
| 173 i = parent->workerlist[worker_num].wire_down_lookup; | |
| 174 while(parent->wirelist[j=parent->workers_to_wires_down[i]].start_worker == worker_num && j >= 0) | |
| 175 { | |
| 176 if(parent->wirelist[j].output_num != output_num) | |
| 177 set_in_child(parent, parent->wirelist[j].end_worker, in_child, FALSE,-1); | |
| 178 } | |
| 179 for(i = 0; i < parent->num_workers; ++i) | |
| 180 { | |
| 181 if(i != worker_num && (parent->workerlist[i].type == 4 || (parent->workerlist[i].type == 2 && !in_child[i]))) | |
| 182 set_in_child(parent, i, in_child, FALSE); | |
| 183 } | |
| 184 for(i = 0; i < parent->num_workers; ++i) | |
| 185 { | |
| 186 if(in_child[i]) | |
| 187 child_offests[i] = num_child_workers++; | |
| 188 } | |
| 189 for(i = 0; i < parent->num_wires; ++i) | |
| 190 { | |
| 191 if(in_child[parent->wirelist[i].start_worker] || in_child[parent->wirelist[i].end_worker]) | |
| 192 ++num_child_wires; | |
| 193 } | |
| 194 child_def = num_defs++;//needs lock or atomic incrememnt | |
| 195 deflist[child_def].workerlist = malloc(sizeof(worker)*num_child_workers); | |
| 196 deflist[child_def].wirelist = malloc(sizeof(wire)*num_child_wires); | |
| 197 for(i = 0; i < parent->num_workers; ++i) | |
| 198 { | |
| 199 if(in_child[i]) | |
| 200 deflist[child_def].workerlist[child_offests[i]] = parent->workerlist[i]; | |
| 201 } | |
| 202 } */ | |
| 203 | |
| 204 #define MAX_TRACE_DEPTH 40 | |
| 205 | |
| 206 void print_stack_trace(worker_instance * stack_instance) | |
| 207 { | |
| 208 int i = 0; | |
| 209 ERRORPUTS("Stack trace:\n"); | |
| 210 while(stack_instance && i < MAX_TRACE_DEPTH) | |
| 211 { | |
| 212 ERRORPRINTF("%s\n", stack_instance->def->name); | |
| 213 stack_instance = stack_instance->caller_instance; | |
| 214 ++i; | |
| 215 } | |
| 216 if(stack_instance) | |
| 217 { | |
| 218 ERRORPUTS("Stack trace aborted after 40 entries\n"); | |
| 219 } | |
| 220 } | |
| 221 | |
| 222 void check_tail(worker_def * def) | |
| 223 { | |
| 224 custom_worker * worker = def->implement_func; | |
| 225 int i,j,k,endworker; | |
| 226 BOOL can_tail, outputs_handled[32]; | |
| 227 for(i = 0; i < worker->num_workers; ++i) | |
| 228 { | |
| 229 if(worker->workerlist[i].type == WORKER) | |
| 230 { | |
| 231 can_tail = TRUE; | |
| 232 for(j = 0; j < def->num_outputs; ++j) | |
| 233 outputs_handled[j] = FALSE; | |
| 234 j = worker->workerlist[i].wire_down_lookup; | |
| 235 while((k=worker->workers_to_wires_down[j]) >= 0 && worker->wirelist[k].start_worker == i) | |
| 236 { | |
| 237 endworker = worker->wirelist[k].end_worker; | |
| 238 if(worker->workerlist[endworker].type != OUTPUT || worker->workerlist[endworker].io_num != worker->wirelist[k].output_num) | |
| 239 { | |
| 240 can_tail = FALSE; | |
| 241 break; | |
| 242 } | |
| 243 else | |
| 244 outputs_handled[worker->wirelist[k].output_num] = TRUE; | |
| 245 ++j; | |
| 246 } | |
| 247 if(can_tail) | |
| 248 { | |
| 249 for(j = 0; j < def->num_outputs; ++j) | |
| 250 if(!outputs_handled[j]) | |
| 251 { | |
| 252 can_tail = FALSE; | |
| 253 break; | |
| 254 } | |
| 255 if(can_tail) | |
| 256 if(worker->workerlist[i].value_index == def) | |
| 257 worker->workerlist[i].type = TAIL_RECURSE; | |
| 258 else if(!def->num_stores) | |
| 259 worker->workerlist[i].type = TAIL_CALL; | |
| 260 } | |
| 261 } | |
| 262 } | |
| 263 } | |
| 264 | |
| 265 BOOL method_match(char * name, char * method_name) | |
| 266 { | |
| 267 int i = 0; | |
| 268 while(name[i] != '\0' && method_name[i] != '@' && method_name[i] != '\0') | |
| 269 { | |
| 270 if(name[i] != method_name[i]) | |
| 271 return FALSE; | |
| 272 ++i; | |
| 273 } | |
| 274 if(name[i] != '\0' || method_name[i] != '@') | |
| 275 return FALSE; | |
| 276 return TRUE; | |
| 277 } | |
| 278 | |
| 279 worker_def * find_method(int type, char * name, int num_inputs, program * prog) | |
| 280 { | |
| 281 int i; | |
| 282 worker_def * output = NULL; | |
| 283 company * companylist = prog->companylist; | |
| 284 VIS_EnterCriticalSection(companylist[type].lock); | |
| 285 for(i = 0; i < companylist[type].num_methods; ++i) | |
| 286 { | |
| 287 //DEBUGPRINTF( "Checking method %s(%d,%d)\n", companylist[type].methodlist[i]->name, companylist[type].methodlist[i]->num_inputs, companylist[type].methodlist[i]->num_outputs); | |
| 288 if(companylist[type].methodlist[i]->num_inputs == num_inputs && method_match(name, companylist[type].methodlist[i]->name)) | |
| 289 { | |
| 290 DEBUGPRINTF( "Found method: %s\n", companylist[type].methodlist[i]->name); | |
| 291 output = companylist[type].methodlist[i]; | |
| 292 break; | |
| 293 } | |
| 294 } | |
| 295 VIS_LeaveCriticalSection(companylist[type].lock); | |
| 296 return output; | |
| 297 } | |
| 298 | |
| 299 worker_def * find_method_noinputcheck(int type, char * name, program * prog) | |
| 300 { | |
| 301 int i; | |
| 302 worker_def * output = NULL; | |
| 303 company * companylist = prog->companylist; | |
| 304 VIS_EnterCriticalSection(companylist[type].lock); | |
| 305 for(i = 0; i < companylist[type].num_methods; ++i) | |
| 306 { | |
| 307 //DEBUGPRINTF( "Checking method %s(%d,%d)\n", companylist[type].methodlist[i]->name, companylist[type].methodlist[i]->num_inputs, companylist[type].methodlist[i]->num_outputs); | |
| 308 if(method_match(name, companylist[type].methodlist[i]->name)) | |
| 309 { | |
| 310 DEBUGPRINTF( "Found method: %s\n", companylist[type].methodlist[i]->name); | |
| 311 output = companylist[type].methodlist[i]; | |
| 312 break; | |
| 313 } | |
| 314 } | |
| 315 VIS_LeaveCriticalSection(companylist[type].lock); | |
| 316 return output; | |
| 317 } | |
| 318 | |
| 319 worker_def * find_converter_method(int totype, int fromtype, program * prog) | |
| 320 { | |
| 321 int i; | |
| 322 company * companylist = prog->companylist; | |
| 323 DEBUGPRINTF( "Finding converter from %s to %s\n", companylist[fromtype].name, companylist[totype].name); | |
| 324 //DEBUGPRINTF( "Num methods %d\n", companylist[totype].num_methods); | |
| 325 for(i = 0; i < companylist[totype].num_methods; ++i) | |
| 326 { | |
| 327 //DEBUGPRINTF("methodlist[i]: %X\n", companylist[totype].methodlist[i]); | |
| 328 DEBUGPRINTF( "Checking method %s\n", companylist[totype].methodlist[i]->name); | |
| 329 | |
| 330 if(companylist[totype].methodlist[i]->name[0] == '<' && method_match(companylist[fromtype].name, companylist[totype].methodlist[i]->name+1)) | |
| 331 { | |
| 332 DEBUGPRINTF( "Found Method %s\n", companylist[totype].methodlist[i]->name); | |
| 333 | |
| 334 return companylist[totype].methodlist[i]; | |
| 335 } | |
| 336 } | |
| 337 return NULL; | |
| 338 } | |
| 339 | |
| 340 worker_instance * init_custom_worker_type(int aworker, worker_instance * caller, worker_def * def, instance_callback callback, void * callback_data, datum ** params, int type) | |
| 341 { | |
| 342 int i, workerlist_size, j, add_index_count=0; | |
| 343 int add_index[32]; | |
| 344 datum * work_params[32]; | |
| 345 datum * temp_params[3]; | |
| 346 global_store * store; | |
| 347 worker_instance * instance; | |
| 348 BOOL release_params = TRUE; | |
| 349 def_make_lookup(def); | |
| 350 workerlist_size = sizeof(worker_instance_data)*(def->implement_func->num_workers); | |
| 351 //DEBUGPRINTF("workerlist_size: %d * %d = %d, wirelist_size: %d * %d = %d.\n", sizeof(worker_instance_data), def->implement_func->num_workers, workerlist_size, sizeof(wire_instance_data), def->implement_func->num_wires, sizeof(wire_instance_data)*(def->implement_func->num_wires)); | |
| 352 //DEBUGPRINTF("Before malloc(%d)\n",sizeof(worker_instance) + workerlist_size + sizeof(wire_instance_data)*(def->implement_func->num_wires)); | |
| 353 if(type == TAIL_RECURSE || type == TAIL_CALL) | |
| 354 { | |
| 355 VIS_EnterCriticalSection(caller->counter_lock); | |
| 356 if(caller->in_progress_count <= 1 && !caller->in_queue_count) | |
| 357 { | |
| 358 VIS_LeaveCriticalSection(caller->counter_lock); | |
| 359 instance = caller; | |
| 360 for(i = 0; i < instance->num_workers; ++i) | |
| 361 { | |
| 362 if(instance->def->implement_func->workerlist[i].type != WORKER && instance->def->implement_func->workerlist[i].type != TAIL_RECURSE && instance->def->implement_func->workerlist[i].type != TAIL_CALL && instance->workerlist[i].value) | |
| 363 release_ref(instance->workerlist[i].value); | |
| 364 if(instance->workerlist[i].ready_count && instance->workerlist[i].ready_count < (instance->def->implement_func->workerlist[i].num_inputs + (instance->def->implement_func->workerlist[i].null_input ? 1 : 0))) | |
| 365 { | |
| 366 DEBUGPRINTF("Freeing params for worker number %d, ready_count: %d, num_inputs: %d, null_input: %d, instance: %X\n", i, instance->workerlist[i].ready_count,instance->def->implement_func->workerlist[i].num_inputs, instance->def->implement_func->workerlist[i].null_input, instance); | |
| 367 for(j = 0; j <= instance->def->implement_func->workerlist[i].num_inputs; ++j) | |
| 368 { | |
| 369 DEBUGPRINTF("Releasing param %d of worker %d\n", j, i); | |
| 370 release_ref(instance->workerlist[i].params[j]); | |
| 371 } | |
| 372 } | |
| 373 } | |
| 374 for(i = 0; i < def->num_inputs; ++i) | |
| 375 work_params[i] = params[i]; | |
| 376 params = work_params; | |
| 377 if(type == TAIL_RECURSE) | |
| 378 { | |
| 379 instance->in_progress_count = 0; | |
| 380 //TODO: adjust profile counter? | |
| 381 goto init_workerlist; | |
| 382 } | |
| 383 else | |
| 384 { | |
| 385 aworker = instance->worker_in_caller; | |
| 386 callback = instance->callback; | |
| 387 callback_data = instance->callback_data; | |
| 388 caller = instance->caller_instance; | |
| 389 VIS_DeleteCriticalSection(instance->counter_lock); | |
| 390 free(instance); | |
| 391 } | |
| 392 } | |
| 393 else | |
| 394 { | |
| 395 VIS_LeaveCriticalSection(caller->counter_lock); | |
| 396 } | |
| 397 } | |
| 398 | |
| 399 | |
| 400 instance = MALLOC(sizeof(worker_instance) + workerlist_size/* + sizeof(wire_instance_data)*(def->implement_func->num_wires) */,"instance"); | |
| 401 | |
| 402 //DEBUGPRINTF("malloc returned %X.\n", instance); | |
| 403 VIS_PROFILE_START(PROF_INIT_CUSTOM); | |
| 404 //DEBUGPRINTF("init_custom_worker, instance: %X\n", instance); | |
| 405 #ifdef USER_PROFILE | |
| 406 QueryPerformanceCounter(&(instance->start)); | |
| 407 #endif | |
| 408 instance->def = def; | |
| 409 instance->num_workers = def->implement_func->num_workers; | |
| 410 instance->workerlist = (worker_instance_data *)(((char *)instance) + sizeof(worker_instance));//malloc(sizeof(worker_instance_data)*(def->implement_func->num_workers)); | |
| 411 //DEBUGPRINTF("workerlist at %X\n", instance->workerlist); | |
| 412 | |
| 413 /*instance->num_wires = def->implement_func->num_wires; | |
| 414 instance->wirelist = (wire_instance_data *)(((char *)(instance->workerlist)) + workerlist_size);//malloc(sizeof(wire_instance_data)*(def->implement_func->num_wires)); | |
| 415 DEBUGPRINTF("wirelist at %X\n", instance->wirelist);*/ | |
| 416 | |
| 417 | |
| 418 instance->callback = callback; | |
| 419 instance->worker_in_caller = aworker; | |
| 420 instance->callback_data = callback_data; | |
| 421 instance->caller_instance = caller; | |
| 422 VIS_InitializeCriticalSection(instance->counter_lock); | |
| 423 instance->in_progress_count = 0; | |
| 424 instance->in_queue_count = 0; | |
| 425 | |
| 426 if(def->num_stores) | |
| 427 { | |
| 428 instance->trans = MALLOC(sizeof(transaction) + sizeof(global_store_use) *(def->num_stores - 1),"transaction"); | |
| 429 VIS_EnterCriticalSection(global_store_lock); | |
| 430 for(i = 0; i < def->num_stores; ++i) | |
| 431 { | |
| 432 temp_params[0] = add_ref(global_store_dict); | |
| 433 temp_params[1] = make_string(def->uses_stores[i], -1, def->program); | |
| 434 vis_dict_index(temp_params, NULL); | |
| 435 if(!temp_params[0]) | |
| 436 { | |
| 437 printf("Error: Global store %s is not initialized\n", def->uses_stores[i]); | |
| 438 DEBUGPRINTF("Error: Global store %s is not initialized\n", def->uses_stores[i]); | |
| 439 VIS_LeaveCriticalSection(global_store_lock); | |
| 440 return NULL; | |
| 441 } | |
| 442 instance->trans->stores[i].store = temp_params[0]->c.generic.data; | |
| 443 instance->trans->stores[i].instance_data = instance->trans->stores[i].begin_data = add_ref(instance->trans->stores[i].store->data); | |
| 444 VIS_InitializeCriticalSection(instance->trans->stores[i].lock); | |
| 445 //Is this really necessary? | |
| 446 release_ref(temp_params[0]); | |
| 447 } | |
| 448 VIS_LeaveCriticalSection(global_store_lock); | |
| 449 instance->trans->num_stores = def->num_stores; | |
| 450 if((def->transaction_flags & TRANSACTION_WRITE) && (def->transaction_flags & TRANSACTION_TYPE_MASK) == TRANSACTION_RETRY) | |
| 451 { | |
| 452 release_params = FALSE; | |
| 453 for(i = 0; i < def->num_inputs; ++i) | |
| 454 instance->trans->params[i] = params[i]; | |
| 455 } | |
| 456 } else { | |
| 457 instance->trans = NULL; | |
| 458 } | |
| 459 | |
| 460 | |
| 461 init_workerlist: | |
| 462 //DEBUGPUTS("init worker values\n"); | |
| 463 for(i = 0; i < instance->num_workers; ++i) | |
| 464 { | |
| 465 // DEBUGPRINTF("InitializeCriticalSection on workerlist[%d].worker_lock (%X)\n", i, &(instance->workerlist[i].worker_lock)); | |
| 466 VIS_InitializeCriticalSection(instance->workerlist[i].worker_lock); | |
| 467 //DEBUGPUTS("ready_count = 0\n"); | |
| 468 instance->workerlist[i].ready_count = 0; | |
| 469 if(def->implement_func->workerlist[i].type == INPUT && params) | |
| 470 instance->workerlist[i].value = add_ref(params[def->implement_func->workerlist[i].io_num]); | |
| 471 else //if(def->implement_func->workerlist[i].type != 2) | |
| 472 instance->workerlist[i].value = NULL; | |
| 473 //DEBUGPRINTF("instance->workerlist[%d].value = %X\n", i, instance->workerlist[i].value); | |
| 474 for(j = 0; j <= def->implement_func->workerlist[i].num_inputs; ++j) | |
| 475 instance->workerlist[i].params[j] = NULL; | |
| 476 //DEBUGPRINTF("num_inputs: %d, null_input: %d\n", def->implement_func->workerlist[i].num_inputs, def->implement_func->workerlist[i].null_input); | |
| 477 | |
| 478 //There's still a potential race condition here, but it's unlikely to occur except on a system with an insane number of cores/processors | |
| 479 //and only on custom workers that have more than 32 items that will be initially ready | |
| 480 if(!def->implement_func->workerlist[i].num_inputs && !def->implement_func->workerlist[i].null_input) | |
| 481 { | |
| 482 DEBUGPRINTF("adding worker %s(%d) to queue\n", def->implement_func->workerlist[i].name, i); | |
| 483 add_index[add_index_count++] = i; | |
| 484 if(add_index_count == 32) | |
| 485 { | |
| 486 add_multiple(add_index, add_index_count, instance); | |
| 487 add_index_count = 0; | |
| 488 } | |
| 489 //add_queue(i,instance); | |
| 490 } | |
| 491 } | |
| 492 | |
| 493 if(params) | |
| 494 { | |
| 495 if(release_params) | |
| 496 { | |
| 497 //DEBUGPUTS("release params\n"); | |
| 498 for(i = 0; i < def->num_inputs; ++i) | |
| 499 release_ref(params[i]); | |
| 500 } | |
| 501 } | |
| 502 if(add_index_count > 0) | |
| 503 add_multiple(add_index, add_index_count, instance); | |
| 504 VIS_PROFILE_END(PROF_INIT_CUSTOM); | |
| 505 | |
| 506 return instance; | |
| 507 } | |
| 508 | |
| 509 worker_instance * init_custom_worker(int aworker, worker_instance * caller, worker_def * def, instance_callback callback, void * callback_data, datum ** params) | |
| 510 { | |
| 511 return init_custom_worker_type(aworker, caller, def, callback, callback_data, params, WORKER); | |
| 512 } | |
| 513 | |
| 514 void cleanup_check(queue_entry aworker) | |
| 515 { | |
| 516 char msg[256]; | |
| 517 VIS_EnterCriticalSection(aworker.instance->counter_lock); | |
| 518 --(aworker.instance->in_progress_count); | |
| 519 DEBUGPRINTF( "Cleanup Check on %s<%d>:%X, in_progress: %d, in_queue: %d\n", aworker.instance->def->name, aworker.instance->worker_in_caller, aworker.instance, aworker.instance->in_progress_count,aworker.instance->in_queue_count); | |
| 520 | |
| 521 if(aworker.instance->in_progress_count == 0 && aworker.instance->in_queue_count == 0) | |
| 522 { | |
| 523 VIS_LeaveCriticalSection(aworker.instance->counter_lock); | |
| 524 cleanup_custom_worker(aworker.instance, aworker.worker_num); | |
| 525 } | |
| 526 else | |
| 527 { | |
| 528 VIS_LeaveCriticalSection(aworker.instance->counter_lock); | |
| 529 } | |
| 530 } | |
| 531 | |
| 532 void cleanup_custom_worker(worker_instance * instance, int worker_num) | |
| 533 { | |
| 534 BOOL do_commit = TRUE; | |
| 535 int i,j; | |
| 536 queue_entry incaller; | |
| 537 global_store * store; | |
| 538 #ifdef USER_PROFILE | |
| 539 LARGE_INTEGER end; | |
| 540 LARGE_INTEGER duration; | |
| 541 #endif | |
| 542 if(instance->trans) | |
| 543 { | |
| 544 if(instance->def->transaction_flags & TRANSACTION_WRITE) | |
| 545 { | |
| 546 VIS_EnterCriticalSection(global_store_lock); | |
| 547 if((instance->def->transaction_flags & TRANSACTION_TYPE_MASK) != TRANSACTION_FORCE) | |
| 548 { | |
| 549 for(i = 0; i < instance->trans->num_stores; ++i) | |
| 550 { | |
| 551 if(instance->trans->stores[i].begin_data != instance->trans->stores[i].store->data) | |
| 552 { | |
| 553 do_commit = FALSE; | |
| 554 break; | |
| 555 } | |
| 556 } | |
| 557 } | |
| 558 if(do_commit) | |
| 559 { | |
| 560 for(i = 0; i < instance->trans->num_stores; ++i) | |
| 561 { | |
| 562 release_ref(instance->trans->stores[i].store->data); | |
| 563 instance->trans->stores[i].store->data = instance->trans->stores[i].instance_data; | |
| 564 } | |
| 565 } | |
| 566 VIS_LeaveCriticalSection(global_store_lock); | |
| 567 if(!do_commit)//retry transaction | |
| 568 { | |
| 569 for(i = 0; i < instance->trans->num_stores; ++i) | |
| 570 release_ref(instance->trans->stores[i].instance_data); | |
| 571 puts("retrying transaction"); | |
| 572 init_custom_worker(instance->worker_in_caller, instance->caller_instance, instance->def, instance->callback, instance->callback_data, instance->trans->params); | |
| 573 } | |
| 574 else if((instance->def->transaction_flags & TRANSACTION_TYPE_MASK) == TRANSACTION_RETRY) | |
| 575 for(i = 0; i < instance->def->num_inputs; ++i) | |
| 576 release_ref(instance->trans->params[i]); | |
| 577 } | |
| 578 else | |
| 579 { | |
| 580 for(i = 0; i < instance->trans->num_stores; ++i) | |
| 581 release_ref(instance->trans->stores[i].instance_data); | |
| 582 } | |
| 583 VIS_FREE(instance->trans, "transaction"); | |
| 584 } | |
| 585 VIS_PROFILE_START(PROF_CLEANUP_CUSTOM); | |
| 586 DEBUGPRINTF("Cleaning up custom worker: %s:%X\n", instance->def->name, instance); | |
| 587 | |
| 588 VIS_PROFILE_START(PROF_SUB_CALLBACK); | |
| 589 if(instance->callback && do_commit) | |
| 590 instance->callback(instance->caller_instance, instance->worker_in_caller, instance, instance->callback_data); | |
| 591 //DEBUGPUTS("About to release refs\n"); | |
| 592 VIS_PROFILE_END(PROF_SUB_CALLBACK); | |
| 593 VIS_PROFILE_START(PROF_CLEANUP_RELEASE_REFS); | |
| 594 /*for(i = 0; i < instance->def->implement_func->num_wires; ++i) | |
| 595 { | |
| 596 if(instance->wirelist[i].data) | |
| 597 { | |
| 598 DEBUGPRINTF("release_ref on wire %d\n", i); | |
| 599 | |
| 600 release_ref(instance->wirelist[i].data); | |
| 601 } | |
| 602 }*/ | |
| 603 for(i = 0; i < instance->num_workers; ++i) | |
| 604 { | |
| 605 if(instance->def->implement_func->workerlist[i].type != WORKER && instance->def->implement_func->workerlist[i].type != TAIL_RECURSE && instance->def->implement_func->workerlist[i].type != TAIL_CALL && instance->workerlist[i].value) | |
| 606 { | |
| 607 DEBUGPRINTF( "release_ref on worker %d in instance %X\n", i, instance); | |
| 608 release_ref(instance->workerlist[i].value); | |
| 609 } | |
| 610 if(instance->workerlist[i].ready_count && instance->workerlist[i].ready_count < (instance->def->implement_func->workerlist[i].num_inputs + (instance->def->implement_func->workerlist[i].null_input ? 1 : 0))) | |
| 611 { | |
| 612 DEBUGPRINTF("Freeing params for worker number %d, ready_count: %d, num_inputs: %d, null_input: %d, instance: %X\n", i, instance->workerlist[i].ready_count,instance->def->implement_func->workerlist[i].num_inputs, instance->def->implement_func->workerlist[i].null_input, instance); | |
| 613 for(j = 0; j <= instance->def->implement_func->workerlist[i].num_inputs; ++j) | |
| 614 { | |
| 615 DEBUGPRINTF("Releasing param %d of worker %d\n", j, i); | |
| 616 release_ref(instance->workerlist[i].params[j]); | |
| 617 } | |
| 618 } | |
| 619 VIS_DeleteCriticalSection(instance->workerlist[i].worker_lock); | |
| 620 } | |
| 621 VIS_PROFILE_END(PROF_CLEANUP_RELEASE_REFS); | |
| 622 VIS_DeleteCriticalSection(instance->counter_lock); | |
| 623 //DEBUGPUTS("freeing lists\n"); | |
| 624 #ifdef USER_PROFILE | |
| 625 if(do_commit) | |
| 626 { | |
| 627 QueryPerformanceCounter(&end); | |
| 628 duration.QuadPart = end.QuadPart - instance->start.QuadPart; | |
| 629 VIS_EnterCriticalSection(instance->def->lock); | |
| 630 instance->def->total.QuadPart += duration.QuadPart; | |
| 631 ++instance->def->count; | |
| 632 if(duration.QuadPart > instance->def->worst.QuadPart) | |
| 633 instance->def->worst.QuadPart = duration.QuadPart; | |
| 634 VIS_LeaveCriticalSection(instance->def->lock); | |
| 635 } | |
| 636 #endif | |
| 637 /*VIS_PROFILE_START(PROF_CLEANUP_FREELISTS); | |
| 638 free(instance->workerlist); | |
| 639 free(instance->wirelist); | |
| 640 VIS_PROFILE_END(PROF_CLEANUP_FREELISTS);*/ | |
| 641 VIS_PROFILE_START(PROF_CLEANUP_CHECK); | |
| 642 if(instance->caller_instance && do_commit) | |
| 643 { | |
| 644 incaller.worker_num = instance->worker_in_caller; | |
| 645 incaller.instance = instance->caller_instance; | |
| 646 DEBUGPUTS("Calling cleanup_check on parent\n"); | |
| 647 cleanup_check(incaller); | |
| 648 } | |
| 649 if(do_commit && instance->callback == main_callback) | |
| 650 release_program_ref(instance->def->program); | |
| 651 VIS_PROFILE_END(PROF_CLEANUP_CHECK); | |
| 652 VIS_PROFILE_START(PROF_CLEANUP_FREELISTS); | |
| 653 VIS_FREE(instance, "worker instance"); | |
| 654 VIS_PROFILE_END(PROF_CLEANUP_FREELISTS); | |
| 655 VIS_PROFILE_END(PROF_CLEANUP_CUSTOM); | |
| 656 } | |
| 657 /* | |
| 658 void worker_complete(queue_entry aworker) | |
| 659 { | |
| 660 int i,j; | |
| 661 wire * wirelist; | |
| 662 int * workers_to_wires_down; | |
| 663 VIS_PROFILE_START(PROF_WORKER_COMPLETE); | |
| 664 DEBUGPUTS("worker_complete()\n"); | |
| 665 | |
| 666 | |
| 667 i = aworker.instance->def->implement_func->workerlist[aworker.worker_num].wire_down_lookup; | |
| 668 wirelist = aworker.instance->def->implement_func->wirelist; | |
| 669 workers_to_wires_down = aworker.instance->def->implement_func->workers_to_wires_down; | |
| 670 while(wirelist[j=workers_to_wires_down[i]].start_worker == aworker.worker_num && j >= 0) | |
| 671 { | |
| 672 if(aworker.instance->wirelist[j].data) | |
| 673 { | |
| 674 DEBUGPRINTF("end_worker: %d, wirelist[%d].data = %X\n", wirelist[j].end_worker, j, aworker.instance->wirelist[j].data); | |
| 675 add_if_ready(wirelist[j].end_worker, aworker.instance); | |
| 676 } | |
| 677 ++i; | |
| 678 } | |
| 679 DEBUGPUTS("worker_complete done\n"); | |
| 680 VIS_PROFILE_END(PROF_WORKER_COMPLETE); | |
| 681 }*/ | |
| 682 | |
| 683 void process_outputs(datum ** params, int aworker, worker_instance * instance) | |
| 684 { | |
| 685 BOOL flag=FALSE; | |
| 686 int i,j; | |
| 687 worker_def * def = instance->def; | |
| 688 //custom_worker *implement_func = def->implement_func; | |
| 689 wire * def_wires = def->implement_func->wirelist; | |
| 690 worker * def_workers = def->implement_func->workerlist; | |
| 691 VIS_PROFILE_START(PROF_PROCESS_OUTPUTS); | |
| 692 DEBUGPRINTF("Process outputs for worker %d in instance %X\n", aworker, instance); | |
| 693 DEBUGPRINTF("Num_inputs: %d, num_outputs: %d\n", def_workers[aworker].num_inputs, def_workers[aworker].num_outputs); | |
| 694 if(def_workers[aworker].num_outputs && instance->workerlist) | |
| 695 { | |
| 696 //DEBUGPRINTF("num_outputs: %d\n", def_workers[aworker].num_outputs); | |
| 697 i = def_workers[aworker].wire_down_lookup; | |
| 698 while((j=def->implement_func->workers_to_wires_down[i]) >= 0 && def_wires[j].start_worker == aworker) | |
| 699 { | |
| 700 //DEBUGPRINTF("Checking output: %d\n", def_wires[j].output_num); | |
| 701 DEBUGPRINTF("output[%d] = %X\n", def_wires[j].output_num, params[def_wires[j].output_num]); | |
| 702 DEBUGPRINTF("wire leads to worker %d, instance->workerlist: %X\n", def_wires[j].end_worker, instance->workerlist); | |
| 703 VIS_EnterCriticalSection(instance->workerlist[def_wires[j].end_worker].worker_lock); | |
| 704 if(params[def_wires[j].output_num] && !instance->workerlist[def_wires[j].end_worker].params[def_wires[j].input_num+1]) | |
| 705 { | |
| 706 //DEBUGPRINTF( "add_ref on output %d\n", def_wires[j].output_num); | |
| 707 instance->workerlist[def_wires[j].end_worker].params[def_wires[j].input_num+1]=add_ref(params[def_wires[j].output_num]); | |
| 708 //DEBUGPRINTF("Ready count was: %d, ", instance->workerlist[def_wires[j].end_worker].ready_count); | |
| 709 ++instance->workerlist[def_wires[j].end_worker].ready_count; | |
| 710 DEBUGPRINTF("Ready count is now: %d\n", instance->workerlist[def_wires[j].end_worker].ready_count); | |
| 711 DEBUGPRINTF("num inputs: %d, null input: %d\n", instance->def->implement_func->workerlist[def_wires[j].end_worker].num_inputs, instance->def->implement_func->workerlist[def_wires[j].end_worker].null_input); | |
| 712 if(instance->workerlist[def_wires[j].end_worker].ready_count >= (instance->def->implement_func->workerlist[def_wires[j].end_worker].num_inputs + (instance->def->implement_func->workerlist[def_wires[j].end_worker].null_input ? 1 : 0))) | |
| 713 { | |
| 714 //DEBUGPUTS("flag = true\n"); | |
| 715 flag = TRUE; | |
| 716 instance->workerlist[def_wires[j].end_worker].ready_count=0; | |
| 717 } | |
| 718 } | |
| 719 VIS_LeaveCriticalSection(instance->workerlist[def_wires[j].end_worker].worker_lock); | |
| 720 if(flag) | |
| 721 { | |
| 722 DEBUGPUTS("add_queue\n"); | |
| 723 add_queue(def_wires[j].end_worker, instance); | |
| 724 //add_if_ready(def_wires[j].end_worker, instance); | |
| 725 flag = FALSE; | |
| 726 } | |
| 727 ++i; | |
| 728 } | |
| 729 //DEBUGPUTS("releasing refs\n"); | |
| 730 | |
| 731 for(i = 0; i < def_workers[aworker].num_outputs; ++i) | |
| 732 release_ref(params[i]); | |
| 733 } | |
| 734 VIS_PROFILE_END(PROF_PROCESS_OUTPUTS); | |
| 735 } | |
| 736 | |
| 737 void main_callback(worker_instance * junkinst, int junk, worker_instance * main_instance, void * data) | |
| 738 { | |
| 739 //MessageBox(NULL, "Main Callback", "Visuality Debug", MB_OK); | |
| 740 VIS_EnterCriticalSection(program_count_lock); | |
| 741 --program_count; | |
| 742 if(program_count <= 0) | |
| 743 { | |
| 744 execute_active = FALSE; | |
| 745 VIS_SetEvent(queue_add_event); | |
| 746 } | |
| 747 VIS_LeaveCriticalSection(program_count_lock); | |
| 748 if(data) | |
| 749 release_ref((datum *)data); | |
| 750 } | |
| 751 | |
| 752 void sub_callback(worker_instance * caller_instance, int caller_workernum, worker_instance * done_instance, void * data) | |
| 753 { | |
| 754 int i; | |
| 755 queue_entry incaller; | |
| 756 datum * params[32]; | |
| 757 worker_def * def = done_instance->def; | |
| 758 custom_worker * implement_func = def->implement_func; | |
| 759 | |
| 760 incaller.worker_num = caller_workernum; | |
| 761 incaller.instance = caller_instance; | |
| 762 for(i = 0; i < def->num_outputs; ++i) | |
| 763 params[i] = NULL; | |
| 764 for(i = 0; i < implement_func->num_workers; ++i) | |
| 765 { | |
| 766 if(implement_func->workerlist[i].type == 4) | |
| 767 { | |
| 768 if(!params[implement_func->workerlist[i].io_num]) | |
| 769 { | |
| 770 params[implement_func->workerlist[i].io_num] = done_instance->workerlist[i].value; | |
| 771 DEBUGPRINTF("Output[%d] = %X\n", implement_func->workerlist[i].io_num, done_instance->workerlist[i].value); | |
| 772 done_instance->workerlist[i].value = NULL; | |
| 773 } | |
| 774 } | |
| 775 } | |
| 776 process_outputs(params, caller_workernum, caller_instance); | |
| 777 //worker_complete(incaller); | |
| 778 } | |
| 779 | |
| 780 void pack_list_sub_callback(worker_instance * caller_instance, int caller_workernum, worker_instance * done_instance, void * data) | |
| 781 { | |
| 782 int i; | |
| 783 queue_entry incaller; | |
| 784 datum * params[32]; | |
| 785 datum * workparams[2]; | |
| 786 | |
| 787 incaller.worker_num = caller_workernum; | |
| 788 incaller.instance = caller_instance; | |
| 789 for(i = 0; i < done_instance->def->num_outputs; ++i) | |
| 790 params[i] = NULL; | |
| 791 for(i = 0; i < done_instance->def->implement_func->num_workers; ++i) | |
| 792 { | |
| 793 if(done_instance->def->implement_func->workerlist[i].type == 4) | |
| 794 { | |
| 795 if(!params[done_instance->def->implement_func->workerlist[i].io_num]) | |
| 796 { | |
| 797 params[done_instance->def->implement_func->workerlist[i].io_num] = done_instance->workerlist[i].value; | |
| 798 done_instance->workerlist[i].value = NULL; | |
| 799 } | |
| 800 } | |
| 801 } | |
| 802 workparams[0] = create_list(done_instance->def->program); | |
| 803 for(i = 0; i < done_instance->def->num_outputs; ++i) | |
| 804 { | |
| 805 workparams[1] = params[i]; | |
| 806 vis_list_append(workparams, NULL); | |
| 807 } | |
| 808 process_outputs(workparams, caller_workernum, caller_instance); | |
| 809 //worker_complete(incaller); | |
| 810 } | |
| 811 | |
| 812 void transaction_sub_callback(worker_instance * caller_instance, int caller_workernum, worker_instance * done_instance, void * data) | |
| 813 { | |
| 814 int i; | |
| 815 | |
| 816 pack_list_sub_callback(caller_instance, caller_workernum, done_instance, NULL); | |
| 817 } | |
| 818 | |
| 819 int global_argc; | |
| 820 char ** global_argv; | |
| 821 int spin_counter; | |
| 822 | |
| 823 void prep_program(program * prog) | |
| 824 { | |
| 825 defchunk * current; | |
| 826 int i,j; | |
| 827 make_lookup_arrays(prog); | |
| 828 current = prog->defs; | |
| 829 while(current) | |
| 830 { | |
| 831 for(i = 0; i < current->num_defs; ++i) | |
| 832 { | |
| 833 #ifdef USER_PROFILE | |
| 834 current->deflist[i].count = 0; | |
| 835 current->deflist[i].total.QuadPart = 0; | |
| 836 current->deflist[i].worst.QuadPart = 0; | |
| 837 VIS_InitializeCriticalSection(current->deflist[i].lock); | |
| 838 #endif // USER_PROFILE | |
| 839 //DEBUGPRINTF("Checking worker %s with type %X\n", current->deflist[i].name, current->deflist[i].type); | |
| 840 if(current->deflist[i].type & USER_FLAG && (current->deflist[i].type & TYPE_MASK) == WORKER_TYPE) | |
| 841 { | |
| 842 //DEBUGPRINTF("Checking for constants in worker %s\n", current->deflist[i].name); | |
| 843 for(j = 0; j < current->deflist[i].implement_func->num_workers; ++j) | |
| 844 if(current->deflist[i].implement_func->workerlist[j].type == CONSTANT) | |
| 845 { | |
| 846 //current->deflist[i].implement_func->workerlist[j].value_index = (int)(get_constant(current->deflist[i].implement_func->workerlist[j].name,-1, initial_prog)); | |
| 847 //DEBUGPRINTF("Set value_index for constant to %X in worker %s at index %d\n", current->deflist[i].implement_func->workerlist[j].value_index, current->deflist[i].name, j); | |
| 848 } | |
| 849 else if(current->deflist[i].implement_func->workerlist[j].type == WORKER || current->deflist[i].implement_func->workerlist[j].type == TAIL_CALL || current->deflist[i].implement_func->workerlist[j].type == TAIL_RECURSE) | |
| 850 { | |
| 851 current->deflist[i].implement_func->workerlist[j].num_inputs = ((worker_def *)current->deflist[i].implement_func->workerlist[j].value_index)->num_inputs; | |
| 852 current->deflist[i].implement_func->workerlist[j].num_outputs = ((worker_def *)current->deflist[i].implement_func->workerlist[j].value_index)->num_outputs; | |
| 853 } | |
| 854 else | |
| 855 current->deflist[i].implement_func->workerlist[j].value_index = 0; | |
| 856 //DEBUGPRINTF("optimize %d\n", i); | |
| 857 #ifdef ENABLE_OPT | |
| 858 optimize(current->deflist + i); | |
| 859 #endif | |
| 860 } | |
| 861 } | |
| 862 current = current->next; | |
| 863 } | |
| 864 } | |
| 865 | |
| 866 void interp_start(int num_threads, BOOL use_this_thread, int argc, char ** argv, program * initial_prog) | |
| 867 { | |
| 868 defchunk * current; | |
| 869 datum * params[2]; | |
| 870 int i, junk,create_threads,j; | |
| 871 #ifdef USER_PROFILE | |
| 872 LARGE_INTEGER frequency; | |
| 873 #endif | |
| 874 lock_fail_counter = 0; | |
| 875 lock_counter = 0; | |
| 876 spin_counter = 0; | |
| 877 | |
| 878 #ifdef WIN32 | |
| 879 //_CrtSetDbgFlag(_CRTDBG_CHECK_ALWAYS_DF | _CRTDBG_CHECK_CRT_DF | _CRTDBG_ALLOC_MEM_DF); | |
| 880 WSAStartup(MAKEWORD(1, 1), &wsa_data); | |
| 881 #endif | |
| 882 VIS_InitializeCriticalSection(randlock); | |
| 883 | |
| 884 DEBUGPUTS("interp_start\n"); | |
| 885 #ifdef ENABLE_PROFILING | |
| 886 for(i = 0; i < NUM_PROFS; ++i) | |
| 887 { | |
| 888 vis_profile_running_total[i] = 0; | |
| 889 vis_profile_counts[i] = 0; | |
| 890 } | |
| 891 VIS_PROFILE_START(PROF_EMPTYFUNC); | |
| 892 empty_test(NULL,NULL); | |
| 893 VIS_PROFILE_END(PROF_EMPTYFUNC); | |
| 894 VIS_PROFILE_START(PROF_NOCODE); | |
| 895 VIS_PROFILE_END(PROF_NOCODE); | |
| 896 #endif | |
| 897 global_argc = argc; | |
| 898 global_argv = argv; | |
| 899 init_sync_primitives(); | |
| 900 init_datum_storage(); | |
| 901 init_global_storage(initial_prog); | |
| 902 //init queue | |
| 903 current_section = &first_section; | |
| 904 DEBUGPRINTF("current_section = %X, ¤t_section = %X\n", current_section, ¤t_section); | |
| 905 worker_queue = current_section->entries; | |
| 906 current_section->last = NULL; | |
| 907 current_section->next = NULL; | |
| 908 queue_start = queue_len = 0; | |
| 909 // deflist[0].num_workers = num_workers; | |
| 910 // deflist[0].num_wires = num_wires; | |
| 911 prep_program(initial_prog); | |
| 912 //MessageBox(NULL, "Before fopen", "visdbg", MB_OK); | |
| 913 init_genrand(time(NULL)); | |
| 914 | |
| 915 execute_active = TRUE; | |
| 916 DEBUGPUTS("Before init_custom_worker on Main\n"); | |
| 917 params[0] = create_list(initial_prog); | |
| 918 for(i = 0; i < argc; ++i) | |
| 919 { | |
| 920 params[1] = make_string(argv[i], -1, initial_prog); | |
| 921 vis_list_append(params, NULL); | |
| 922 } | |
| 923 main_instance = init_custom_worker(-1, NULL, initial_prog->defs->deflist, main_callback, NULL, params); | |
| 924 | |
| 925 //num_datum = 0; | |
| 926 #if COMPILE_THREADS > 0 | |
| 927 create_threads = COMPILE_THREADS; | |
| 928 if(num_threads > 0) | |
| 929 create_threads = num_threads; | |
| 930 if(use_this_thread) | |
| 931 --create_threads; | |
| 932 | |
| 933 for(i = 0; i < create_threads; ++i) | |
| 934 { | |
| 935 #ifdef WIN32 | |
| 936 CreateThread(NULL, 0, worker_thread, NULL, 0, &junk); | |
| 937 #else | |
| 938 #ifdef SYLLABLE | |
| 939 resume_thread(spawn_thread("vis_worker", worker_thread, 1, 0, NULL)); | |
| 940 #else | |
| 941 pthread_t pid; | |
| 942 pthread_create(&pid, NULL, worker_thread, NULL); | |
| 943 #endif | |
| 944 #endif | |
| 945 } | |
| 946 if(use_this_thread) | |
| 947 worker_thread(NULL); | |
| 948 #else | |
| 949 worker_thread(NULL); | |
| 950 #endif | |
| 951 #ifdef ENABLE_PROFILING | |
| 952 for(i = 0; i < NUM_PROFS; ++i) | |
| 953 printf("%d:\t%f,\tcount: %d,\taverage: %f\n", i, (double)vis_profile_running_total[i], vis_profile_counts[i], ((double)vis_profile_running_total[i])/((double)vis_profile_counts[i])); | |
| 954 #endif | |
| 955 | |
| 956 #ifdef USER_PROFILE | |
| 957 printf("%-33s%12s%7s%15s%12s\n\n", "Worker", "Total", "Count", "Average", "Worst"); | |
| 958 current = initial_prog->defs; | |
| 959 while(current) | |
| 960 { | |
| 961 for(i = 0; i < current->num_defs; ++i) | |
| 962 { | |
| 963 if(current->deflist[i].count > 0) | |
| 964 { | |
| 965 printf("%-33s%12.0f%7d%15.2f%12.0f\n", current->deflist[i].name, (double)current->deflist[i].total.QuadPart, current->deflist[i].count, (double)current->deflist[i].total.QuadPart / (double)current->deflist[i].count, (double)current->deflist[i].worst.QuadPart); | |
| 966 } | |
| 967 } | |
| 968 current = current->next; | |
| 969 } | |
| 970 QueryPerformanceFrequency(&frequency); | |
| 971 printf("%.0f ticks per second\n", (double)frequency.QuadPart); | |
| 972 #endif | |
| 973 interp_stop(); | |
| 974 } | |
| 975 | |
| 976 void interp_stop() | |
| 977 { | |
| 978 int i; | |
| 979 execute_active = FALSE; | |
| 980 close_sync_primitives(); | |
| 981 // Doesn't make sense in the context of multiple programs | |
| 982 // cleanup_custom_worker(main_instance); | |
| 983 #ifdef WIN32 | |
| 984 WSACleanup(); | |
| 985 #endif | |
| 986 #ifdef TEXT_FILE_DEBUG | |
| 987 fclose(debugfile); | |
| 988 #endif | |
| 989 } | |
| 990 | |
| 991 extern | |
| 992 void init_sync_primitives() | |
| 993 { | |
| 994 int i; | |
| 995 DEBUGPUTS("Initializing data_lock\n"); | |
| 996 VIS_InitializeCriticalSection(data_lock); | |
| 997 DEBUGPUTS("Initializing worker_queue_lock\n"); | |
| 998 VIS_InitializeCriticalSection(worker_queue_lock); | |
| 999 DEBUGPUTS("Initializing text_buf_lock\n"); | |
| 1000 VIS_InitializeCriticalSection(text_buf_lock); | |
| 13 | 1001 #ifdef GUI_LIB |
| 0 | 1002 #ifdef SYLLABLE |
| 1003 DEBUGPUTS("vis_window_init\n"); | |
| 1004 vis_window_init(); | |
| 1005 #endif | |
| 13 | 1006 #endif //GUI_LIB |
| 0 | 1007 VIS_CreateEvent(queue_add_event);//No security parameter, auto reset, starts signaled, no name |
| 1008 | |
| 1009 } | |
| 1010 | |
| 1011 void close_sync_primitives() | |
| 1012 { | |
| 1013 int i; | |
| 1014 VIS_DeleteCriticalSection(data_lock); | |
| 1015 VIS_DeleteCriticalSection(worker_queue_lock); | |
| 1016 VIS_DestroyEvent(queue_add_event); | |
| 1017 | |
| 1018 } | |
| 1019 | |
| 1020 void init_global_storage(program * prog) | |
| 1021 { | |
| 1022 VIS_InitializeCriticalSection(global_store_lock); | |
| 1023 global_store_dict = create_dict(prog); | |
| 1024 } | |
| 1025 | |
| 1026 void add_multiple(int * data, int num, worker_instance * instance) | |
| 1027 { | |
| 1028 int i, index; | |
| 1029 queue_section * temp; | |
| 1030 DEBUGPRINTF( "Adding %d workers\n", num); | |
| 1031 | |
| 1032 VIS_EnterCriticalSection(instance->counter_lock); | |
| 1033 instance->in_queue_count += num; | |
| 1034 VIS_LeaveCriticalSection(instance->counter_lock); | |
| 1035 VIS_EnterCriticalSection(worker_queue_lock); | |
| 1036 for(i = 0; i < num; ++i) | |
| 1037 { | |
| 1038 if(queue_len >= QUEUE_SIZE) | |
| 1039 { | |
| 1040 if(current_section->next) | |
| 1041 { | |
| 1042 //DEBUGPUTS("Moving to next queue_section\n"); | |
| 1043 current_section = current_section->next; | |
| 1044 } | |
| 1045 else | |
| 1046 { | |
| 1047 //DEBUGPUTS("Allocating new queue_section\n"); | |
| 1048 VIS_PROFILE_START(PROF_ADDQUEUE_MALLOC); | |
| 1049 temp = MALLOC(sizeof(queue_section),"queue section"); | |
| 1050 VIS_PROFILE_END(PROF_ADDQUEUE_MALLOC); | |
| 1051 temp->last = current_section; | |
| 1052 temp->next = NULL; | |
| 1053 current_section->next = temp; | |
| 1054 current_section = temp; | |
| 1055 } | |
| 1056 worker_queue = current_section->entries; | |
| 1057 queue_start = queue_len = 0; | |
| 1058 } | |
| 1059 if(queue_start+queue_len < QUEUE_SIZE) | |
| 1060 index = queue_start+queue_len; | |
| 1061 else | |
| 1062 index = queue_start+queue_len-QUEUE_SIZE; | |
| 1063 worker_queue[index].worker_num=data[i]; | |
| 1064 worker_queue[index].instance = instance; | |
| 1065 ++queue_len; | |
| 1066 } | |
| 1067 VIS_LeaveCriticalSection(worker_queue_lock); | |
| 1068 //DEBUGPUTS("SetEvent\n"); | |
| 1069 VIS_SetEvent(queue_add_event); | |
| 1070 } | |
| 1071 | |
| 1072 void requeue(int data, worker_instance * instance) | |
| 1073 { | |
| 1074 add_queue(data, instance); | |
| 1075 VIS_EnterCriticalSection(instance->counter_lock); | |
| 1076 --(instance->in_progress_count); | |
| 1077 VIS_LeaveCriticalSection(instance->counter_lock); | |
| 1078 } | |
| 1079 | |
| 1080 void add_queue(int data, worker_instance * instance) | |
| 1081 { | |
| 1082 int index; | |
| 1083 queue_section * temp; | |
| 1084 VIS_PROFILE_START(PROF_ADDQUEUE); | |
| 1085 VIS_EnterCriticalSection(instance->counter_lock); | |
| 1086 ++(instance->in_queue_count); | |
| 1087 VIS_LeaveCriticalSection(instance->counter_lock); | |
| 1088 VIS_EnterCriticalSection(worker_queue_lock); | |
| 1089 if(queue_len >= QUEUE_SIZE) | |
| 1090 { | |
| 1091 if(current_section->next) | |
| 1092 { | |
| 1093 //DEBUGPUTS("Moving to next queue_section\n"); | |
| 1094 current_section = current_section->next; | |
| 1095 } | |
| 1096 else | |
| 1097 { | |
| 1098 //DEBUGPUTS("Allocating new queue_section\n"); | |
| 1099 VIS_PROFILE_START(PROF_ADDQUEUE_MALLOC); | |
| 1100 temp = MALLOC(sizeof(queue_section),"queue section"); | |
| 1101 VIS_PROFILE_END(PROF_ADDQUEUE_MALLOC); | |
| 1102 temp->last = current_section; | |
| 1103 temp->next = NULL; | |
| 1104 current_section->next = temp; | |
| 1105 current_section = temp; | |
| 1106 } | |
| 1107 worker_queue = current_section->entries; | |
| 1108 queue_start = queue_len = 0; | |
| 1109 } | |
| 1110 else if(queue_len == 0) | |
| 1111 { | |
| 1112 VIS_SetEvent(queue_add_event); | |
| 1113 //DEBUGPUTS("SetEvent\n"); | |
| 1114 } | |
| 1115 | |
| 1116 if(queue_start+queue_len < QUEUE_SIZE) | |
| 1117 index = queue_start+queue_len; | |
| 1118 else | |
| 1119 index = queue_start+queue_len-QUEUE_SIZE; | |
| 1120 worker_queue[index].worker_num=data; | |
| 1121 worker_queue[index].instance = instance; | |
| 1122 ++queue_len; | |
| 1123 | |
| 1124 VIS_LeaveCriticalSection(worker_queue_lock); | |
| 1125 VIS_PROFILE_END(PROF_ADDQUEUE); | |
| 1126 } | |
| 1127 | |
| 1128 /** | |
| 1129 * Retrieves a ready worker from the queue | |
| 1130 */ | |
| 1131 queue_entry get_queue() | |
| 1132 { | |
| 1133 queue_entry data; | |
| 1134 queue_section * temp; | |
| 1135 //DEBUGPUTS("Begin get_queue()\n"); | |
| 1136 | |
| 1137 VIS_EnterCriticalSection(worker_queue_lock); | |
| 1138 while(!queue_len && execute_active) | |
| 1139 { | |
| 1140 //DEBUGPUTS("Queue empty, resetting event\n"); | |
| 1141 VIS_ResetEvent(queue_add_event); | |
| 1142 VIS_LeaveCriticalSection(worker_queue_lock); | |
| 1143 //DEBUGPUTS("Waiting for queue_add_event\n"); | |
| 1144 VIS_WaitEvent(queue_add_event); | |
| 1145 #ifdef NINTENDO_DS | |
| 1146 //TODO make the processor sleep while waiting for IRQs | |
| 1147 if(irq_queue_count > 0) | |
| 1148 run_queued_irqs(); | |
| 1149 #endif | |
| 1150 VIS_EnterCriticalSection(worker_queue_lock); | |
| 1151 } | |
| 1152 if(queue_len > 0) | |
| 1153 { | |
| 1154 data = worker_queue[queue_start]; | |
| 1155 //DEBUGPRINTF( "Next worker in queue: %d\n", data.worker_num); | |
| 1156 //DEBUGPRINTF("data.instance: %X, data.instance->workerlist: %X\n", data.instance, data.instance->workerlist); | |
| 1157 /*VIS_EnterCriticalSection(data.instance->workerlist[data.worker_num].worker_lock); | |
| 1158 DEBUGPUTS("Adjusting ready_count"); | |
| 1159 data.instance->workerlist[data.worker_num].ready_count=0; | |
| 1160 VIS_LeaveCriticalSection(data.instance->workerlist[data.worker_num].worker_lock);*/ | |
| 1161 ++queue_start; | |
| 1162 --queue_len; | |
| 1163 //DEBUGPUTS("Adjusted ready count.\n"); | |
| 1164 //DEBUGPRINTF("current_section: %X\n", current_section); | |
| 1165 if(queue_len == 0 && current_section->last) | |
| 1166 { | |
| 1167 if(current_section->next != NULL) | |
| 1168 { | |
| 1169 //DEBUGPUTS("Freeing current_section->next.\n"); | |
| 1170 VIS_FREE(current_section->next, "ready queue node"); | |
| 1171 current_section->next = NULL; | |
| 1172 } | |
| 1173 current_section = current_section->last; | |
| 1174 worker_queue = current_section->entries; | |
| 1175 queue_start = 0; | |
| 1176 queue_len = QUEUE_SIZE; | |
| 1177 } | |
| 1178 else if(queue_start == QUEUE_SIZE) | |
| 1179 queue_start = 0; | |
| 1180 } | |
| 1181 else | |
| 1182 { | |
| 1183 //DEBUGPUTS("Queue empty\n"); | |
| 1184 data.worker_num = -2; | |
| 1185 } | |
| 1186 VIS_LeaveCriticalSection(worker_queue_lock); | |
| 1187 //DEBUGPUTS("Left worker_queue_lock\n"); | |
| 1188 //MessageBox(NULL,"AfterLeave","visdbg",MB_OK); | |
| 1189 if(data.worker_num >= 0) | |
| 1190 { | |
| 1191 VIS_EnterCriticalSection(data.instance->counter_lock); | |
| 1192 //DEBUGPUTS("Adjusting in_queue/in_progress counts.\n"); | |
| 1193 --(data.instance->in_queue_count); | |
| 1194 ++(data.instance->in_progress_count); | |
| 1195 DEBUGPRINTF( "Counts for %s<%d> Instance:%X after get_queue: in_queue: %d in_progress: %d\n",data.instance->def->name, data.instance->worker_in_caller, data.instance, data.instance->in_queue_count, data.instance->in_progress_count); | |
| 1196 | |
| 1197 VIS_LeaveCriticalSection(data.instance->counter_lock); | |
| 1198 } | |
| 1199 //DEBUGPUTS("End get_queue()\n"); | |
| 1200 | |
| 1201 return data; | |
| 1202 } | |
| 1203 | |
| 1204 void def_make_lookup(worker_def * def) | |
| 1205 { | |
| 1206 int i, j, upoffset, offset; | |
| 1207 VIS_EnterCriticalSection(def->implement_func->lock); | |
| 1208 if(def->implement_func->dirty) | |
| 1209 { | |
| 1210 upoffset = offset = 0; | |
| 1211 for(i = 0; i < def->implement_func->num_workers; ++i) | |
| 1212 { | |
| 1213 def->implement_func->workerlist[i].wire_down_lookup=offset; | |
| 1214 def->implement_func->workerlist[i].wire_up_lookup=upoffset; | |
| 1215 for(j = 0; j < def->implement_func->num_wires; ++j) | |
| 1216 { | |
| 1217 if(def->implement_func->wirelist[j].start_worker == i) | |
| 1218 def->implement_func->workers_to_wires_down[offset++]=j; | |
| 1219 if(def->implement_func->wirelist[j].end_worker == i) | |
| 1220 def->implement_func->workers_to_wires_up[upoffset++]=j; | |
| 1221 } | |
| 1222 //Clear tail call info | |
| 1223 if(def->implement_func->workerlist[i].type == TAIL_CALL || def->implement_func->workerlist[i].type == TAIL_RECURSE) | |
| 1224 def->implement_func->workerlist[i].type = WORKER; | |
| 1225 } | |
| 1226 def->implement_func->workers_to_wires_down[offset]=-1; | |
| 1227 def->implement_func->workers_to_wires_up[upoffset]=-1; | |
| 1228 check_tail(def); | |
| 1229 def->implement_func->dirty = FALSE; | |
| 1230 } | |
| 1231 VIS_LeaveCriticalSection(def->implement_func->lock); | |
| 1232 } | |
| 1233 | |
| 1234 /** | |
| 1235 * Generates lookup array to ease navigation between workers | |
| 1236 */ | |
| 1237 void make_lookup_arrays(program * prog) | |
| 1238 { | |
| 1239 int i,j,k, offset, upoffset; | |
| 1240 worker_def * deflist; | |
| 1241 defchunk * current = prog->defs; | |
| 1242 while(current) | |
| 1243 { | |
| 1244 deflist = current->deflist; | |
| 1245 for(k = 0; k < current->num_defs; ++k) | |
| 1246 { | |
| 1247 if(deflist[k].type & USER_FLAG && (deflist[k].type & TYPE_MASK) == WORKER_TYPE) | |
| 1248 def_make_lookup(deflist + k); | |
| 1249 } | |
| 1250 current = current->next; | |
| 1251 } | |
| 1252 } | |
| 1253 extern char _end_bss[]; | |
| 1254 void initpredefworkers(program * prog) | |
| 1255 { | |
| 1256 int current_def = 1; | |
| 1257 int current_company = 0; | |
| 1258 int current_method; | |
| 1259 int comp_room; | |
| 1260 company * this_comp; | |
| 1261 worker_def * aworker; | |
| 1262 create_company(prog, "Any Type", 0, 0, FALSE); | |
| 1263 create_company(prog, "Yes No", 0, 0, FALSE); | |
| 1264 | |
| 1265 aworker = create_worker(prog, "Print", 1, 1, WORKER_TYPE); | |
| 1266 aworker->implement_func = (custom_worker *)vis_print; | |
| 1267 aworker->input_types[0] = BUILTIN_TYPE_STRING; | |
| 1268 | |
| 1269 aworker = create_worker(prog, "Random", 0, 1, WORKER_TYPE); | |
| 1270 aworker->implement_func = (custom_worker *)vis_random; | |
| 1271 | |
| 1272 aworker = create_worker(prog, "Build", 1, 1, WORKER_TYPE); | |
| 1273 aworker->implement_func = (custom_worker *)vis_build; | |
| 1274 aworker->input_types[0] = BUILTIN_TYPE_STRING; | |
| 1275 | |
| 1276 aworker = create_worker(prog, "End", 1, 0, WORKER_TYPE); | |
| 1277 aworker->implement_func = (custom_worker *)vis_end; | |
| 1278 aworker->input_types[0] = ANY_TYPE; | |
| 1279 | |
| 1280 create_worker(prog, "Append", 2, 1, MAGIC_TYPE); | |
| 1281 create_worker(prog, "+", 2, 1, MAGIC_TYPE); | |
| 1282 create_worker(prog, "-", 2, 1, MAGIC_TYPE); | |
| 1283 create_worker(prog, "*", 2, 1, MAGIC_TYPE); | |
| 1284 create_worker(prog, "/", 2, 1, MAGIC_TYPE); | |
| 1285 create_worker(prog, ">", 2, 1, MAGIC_TYPE); | |
| 1286 create_worker(prog, "<", 2, 1, MAGIC_TYPE); | |
| 1287 create_worker(prog, "=", 2, 1, MAGIC_TYPE); | |
| 1288 | |
| 1289 aworker = create_worker(prog, "Get Input", 0, 1, WORKER_TYPE); | |
| 1290 aworker->implement_func = (custom_worker *)vis_getinput; | |
| 1291 | |
| 1292 aworker = create_worker(prog, "If",1, 2, WORKER_TYPE); | |
| 1293 aworker->implement_func=(custom_worker *)vis_if; | |
| 1294 aworker->input_types[0] = BUILTIN_TYPE_YESNO; | |
| 1295 | |
| 1296 aworker = create_worker(prog, "Type Of",1, 1, WORKER_TYPE); | |
| 1297 aworker->implement_func=(custom_worker *)vis_type_of; | |
| 1298 aworker->input_types[0] = ANY_TYPE; | |
| 1299 | |
| 1300 aworker = create_worker(prog, "Init Store",1, 0, WORKER_TYPE); | |
| 1301 aworker->implement_func=(custom_worker *)init_global_store; | |
| 1302 aworker->input_types[0] = BUILTIN_TYPE_STRING; | |
| 1303 | |
| 1304 aworker = create_worker(prog, "Wait Forever", 0, 0, WORKER_TYPE); | |
| 1305 aworker->implement_func=(custom_worker *)vis_wait_forever; | |
| 1306 | |
| 1307 #ifdef NINTENDO_DS | |
| 1308 aworker = create_worker(prog, "Register Handler", 2, 1, WORKER_TYPE); | |
| 1309 aworker->implement_func = (custom_worker *)vis_register_handler; | |
| 1310 aworker->input_types[0] = BUILTIN_TYPE_WHOLE; | |
| 1311 aworker->input_types[1] = BUILTIN_TYPE_WORKER; | |
| 1312 | |
| 1313 aworker = create_worker(prog, "Clear Handler", 1, 1, WORKER_TYPE); | |
| 1314 aworker->implement_func = (custom_worker *)vis_clear_handler; | |
| 1315 aworker->input_types[0] = BUILTIN_TYPE_WHOLE; | |
| 1316 | |
| 1317 aworker = create_worker(prog, "Held Keys", 0, 1, WORKER_TYPE); | |
| 1318 aworker->implement_func = (custom_worker *)vis_held_keys; | |
| 1319 | |
| 1320 aworker = create_worker(prog, "Touch Position", 0, 2, WORKER_TYPE); | |
| 1321 aworker->implement_func = (custom_worker *)vis_touch_position; | |
| 1322 #endif | |
| 1323 | |
| 1324 current_method = 0; | |
| 1325 //strcpy(companylist[current_company].name, "String"); | |
| 1326 #ifdef SEGA | |
| 1327 this_comp = create_company(prog, "String", 6, 0, FALSE); | |
| 1328 #else | |
| 1329 this_comp = create_company(prog, "String", 7, 0, FALSE); | |
| 1330 #endif | |
| 1331 aworker = create_worker(prog, "<Whole Number@String",1, 1, WORKER_TYPE); | |
| 1332 aworker->implement_func=(custom_worker *)vis_inttostring; | |
| 1333 aworker->input_types[0] = BUILTIN_TYPE_WHOLE; | |
| 1334 //add_method(this_comp, aworker); | |
| 1335 | |
| 1336 #ifndef SEGA | |
| 1337 | |
| 1338 aworker = create_worker(prog, "<Real Number@String",1, 1, WORKER_TYPE); | |
| 1339 aworker->implement_func=(custom_worker *)vis_realtostring; | |
| 1340 aworker->input_types[0] = BUILTIN_TYPE_REAL; | |
| 1341 //add_method(this_comp, aworker); | |
| 1342 #endif | |
| 1343 | |
| 1344 aworker = create_worker(prog, "=@String",2, 1, WORKER_TYPE); | |
| 1345 aworker->implement_func=(custom_worker *)vis_stringequal; | |
| 1346 aworker->input_types[0] = BUILTIN_TYPE_STRING; | |
| 1347 aworker->input_types[1] = BUILTIN_TYPE_STRING; | |
| 1348 //add_method(this_comp, aworker); | |
| 1349 | |
| 1350 aworker = create_worker(prog, "<Yes No@String",1, 1, WORKER_TYPE); | |
| 1351 aworker->implement_func=(custom_worker *)vis_yesnotostring; | |
| 1352 aworker->input_types[0] = BUILTIN_TYPE_YESNO; | |
| 1353 //add_method(this_comp, aworker); | |
| 1354 | |
| 1355 aworker = create_worker(prog, ">@String",2, 1, WORKER_TYPE); | |
| 1356 aworker->implement_func=(custom_worker *)vis_greaterstring; | |
| 1357 aworker->input_types[0] = BUILTIN_TYPE_STRING; | |
| 1358 aworker->input_types[1] = BUILTIN_TYPE_STRING; | |
| 1359 //add_method(this_comp, aworker); | |
| 1360 | |
| 1361 aworker = create_worker(prog, "<@String",2, 1, WORKER_TYPE); | |
| 1362 aworker->implement_func=(custom_worker *)vis_lesserstring; | |
| 1363 aworker->input_types[0] = BUILTIN_TYPE_STRING; | |
| 1364 aworker->input_types[1] = BUILTIN_TYPE_STRING; | |
| 1365 //add_method(this_comp, aworker); | |
| 1366 | |
| 1367 aworker = create_worker(prog, "Append@String",2, 1, WORKER_TYPE); | |
| 1368 aworker->implement_func=(custom_worker *)vis_append; | |
| 1369 aworker->input_types[0] = BUILTIN_TYPE_STRING; | |
| 1370 aworker->input_types[1] = BUILTIN_TYPE_STRING; | |
| 1371 //add_method(this_comp, aworker); | |
| 1372 | |
| 1373 aworker = create_worker(prog, "Split@String",2, 1, WORKER_TYPE); | |
| 1374 aworker->implement_func=(custom_worker *)vis_string_split; | |
| 1375 aworker->input_types[0] = BUILTIN_TYPE_STRING; | |
| 1376 aworker->input_types[1] = BUILTIN_TYPE_STRING; | |
| 1377 | |
| 1378 aworker = create_worker(prog, "Get Raw@String",2, 2, WORKER_TYPE); | |
| 1379 aworker->implement_func=(custom_worker *)vis_string_get_raw; | |
| 1380 aworker->input_types[0] = BUILTIN_TYPE_STRING; | |
| 1381 aworker->input_types[1] = ANY_TYPE; | |
| 1382 | |
| 1383 aworker = create_worker(prog, "Put Raw@String",2, 1, WORKER_TYPE); | |
| 1384 aworker->implement_func=(custom_worker *)vis_string_put_raw; | |
| 1385 aworker->input_types[0] = BUILTIN_TYPE_STRING; | |
| 1386 aworker->input_types[1] = ANY_TYPE; | |
| 1387 | |
| 1388 aworker = create_worker(prog, "Slice@String",2, 2, WORKER_TYPE); | |
| 1389 aworker->implement_func=(custom_worker *)vis_string_slice; | |
| 1390 aworker->input_types[0] = BUILTIN_TYPE_STRING; | |
| 1391 aworker->input_types[1] = BUILTIN_TYPE_WHOLE; | |
| 1392 | |
| 1393 aworker = create_worker(prog, "Reverse@String",1, 1, WORKER_TYPE); | |
| 1394 aworker->implement_func=(custom_worker *)vis_string_reverse; | |
| 1395 aworker->input_types[0] = BUILTIN_TYPE_STRING; | |
| 1396 | |
| 1397 aworker = create_worker(prog, "Length@String",1, 1, WORKER_TYPE); | |
| 1398 aworker->implement_func=(custom_worker *)vis_string_length; | |
| 1399 aworker->input_types[0] = BUILTIN_TYPE_STRING; | |
| 1400 | |
| 1401 aworker = create_worker(prog, "Put Byte@String",2, 1, WORKER_TYPE); | |
| 1402 aworker->implement_func=(custom_worker *)vis_string_put_byte; | |
| 1403 aworker->input_types[0] = BUILTIN_TYPE_STRING; | |
| 1404 aworker->input_types[1] = BUILTIN_TYPE_WHOLE; | |
| 1405 | |
| 1406 aworker = create_worker(prog, "Get DString@String",2, 4, WORKER_TYPE); | |
| 1407 aworker->implement_func=(custom_worker *)vis_string_get_dstring; | |
| 1408 aworker->input_types[0] = BUILTIN_TYPE_STRING; | |
| 1409 aworker->input_types[1] = ANY_TYPE; | |
| 1410 | |
| 1411 current_method = 0; | |
| 1412 this_comp = create_company(prog, "Whole Number", 6, 0, FALSE); | |
| 1413 aworker = create_worker(prog, "<String@Whole Number",1, 1, WORKER_TYPE); | |
| 1414 aworker->implement_func=(custom_worker *)vis_stringtoint; | |
| 1415 aworker->input_types[0] = BUILTIN_TYPE_STRING; | |
| 1416 | |
| 1417 aworker = create_worker(prog, "From Hex@Whole Number",1, 1, WORKER_TYPE); | |
| 1418 aworker->implement_func=(custom_worker *)vis_whole_fromhex; | |
| 1419 aworker->input_types[0] = BUILTIN_TYPE_STRING; | |
| 1420 //add_method(this_comp, aworker); | |
| 1421 | |
| 1422 aworker = create_worker(prog, "=@Whole Number",2, 1, WORKER_TYPE); | |
| 1423 aworker->implement_func=(custom_worker *)vis_wholeequal; | |
| 1424 aworker->input_types[0] = BUILTIN_TYPE_WHOLE; | |
| 1425 aworker->input_types[1] = BUILTIN_TYPE_WHOLE; | |
| 1426 //add_method(this_comp, aworker); | |
| 1427 | |
| 1428 aworker = create_worker(prog, ">@Whole Number",2, 1, WORKER_TYPE); | |
| 1429 aworker->implement_func=(custom_worker *)vis_greaterint; | |
| 1430 aworker->input_types[0] = BUILTIN_TYPE_WHOLE; | |
| 1431 aworker->input_types[1] = BUILTIN_TYPE_WHOLE; | |
| 1432 //add_method(this_comp, aworker); | |
| 1433 | |
| 1434 aworker = create_worker(prog, "<@Whole Number",2, 1, WORKER_TYPE); | |
| 1435 aworker->implement_func=(custom_worker *)vis_lesserint; | |
| 1436 aworker->input_types[0] = BUILTIN_TYPE_WHOLE; | |
| 1437 aworker->input_types[1] = BUILTIN_TYPE_WHOLE; | |
| 1438 | |
| 1439 //add_method(this_comp, aworker); | |
| 1440 | |
| 1441 aworker = create_worker(prog, "+@Whole Number", 2, 1, WORKER_TYPE); | |
| 1442 aworker->implement_func=(custom_worker *)vis_whole_add; | |
| 1443 aworker->input_types[0] = BUILTIN_TYPE_WHOLE; | |
| 1444 aworker->input_types[1] = BUILTIN_TYPE_WHOLE; | |
| 1445 | |
| 1446 //add_method(this_comp, aworker); | |
| 1447 | |
| 1448 aworker = create_worker(prog, "-@Whole Number", 2, 1, WORKER_TYPE); | |
| 1449 aworker->implement_func=(custom_worker *)vis_whole_subtract; | |
| 1450 aworker->input_types[0] = BUILTIN_TYPE_WHOLE; | |
| 1451 aworker->input_types[1] = BUILTIN_TYPE_WHOLE; | |
| 1452 | |
| 1453 aworker = create_worker(prog, "*@Whole Number", 2, 1, WORKER_TYPE); | |
| 1454 aworker->implement_func=(custom_worker *)vis_whole_mult; | |
| 1455 aworker->input_types[0] = BUILTIN_TYPE_WHOLE; | |
| 1456 aworker->input_types[1] = BUILTIN_TYPE_WHOLE; | |
| 1457 | |
| 1458 //add_method(this_comp, aworker); | |
| 1459 | |
| 1460 aworker = create_worker(prog, "/@Whole Number", 2, 1, WORKER_TYPE); | |
| 1461 aworker->implement_func=(custom_worker *)vis_whole_div; | |
| 1462 aworker->input_types[0] = BUILTIN_TYPE_WHOLE; | |
| 1463 aworker->input_types[1] = BUILTIN_TYPE_WHOLE; | |
| 1464 | |
| 1465 aworker = create_worker(prog, "&@Whole Number", 2, 1, WORKER_TYPE); | |
| 1466 aworker->implement_func=(custom_worker *)vis_whole_and; | |
| 1467 aworker->input_types[0] = BUILTIN_TYPE_WHOLE; | |
| 1468 aworker->input_types[1] = BUILTIN_TYPE_WHOLE; | |
| 1469 | |
| 1470 aworker = create_worker(prog, "|@Whole Number", 2, 1, WORKER_TYPE); | |
| 1471 aworker->implement_func=(custom_worker *)vis_whole_or; | |
| 1472 aworker->input_types[0] = BUILTIN_TYPE_WHOLE; | |
| 1473 aworker->input_types[1] = BUILTIN_TYPE_WHOLE; | |
| 1474 | |
| 1475 aworker = create_worker(prog, "LShift@Whole Number", 2, 1, WORKER_TYPE); | |
| 1476 aworker->implement_func=(custom_worker *)vis_whole_lsh; | |
| 1477 aworker->input_types[0] = BUILTIN_TYPE_WHOLE; | |
| 1478 aworker->input_types[1] = BUILTIN_TYPE_WHOLE; | |
| 1479 | |
| 1480 aworker = create_worker(prog, "RShift@Whole Number", 2, 1, WORKER_TYPE); | |
| 1481 aworker->implement_func=(custom_worker *)vis_whole_rsh; | |
| 1482 aworker->input_types[0] = BUILTIN_TYPE_WHOLE; | |
| 1483 aworker->input_types[1] = BUILTIN_TYPE_WHOLE; | |
| 1484 | |
| 1485 //add_method(this_comp, aworker); | |
| 1486 | |
| 1487 current_method = 0; | |
| 1488 this_comp = create_company(prog, "Real Number", 6, 0, FALSE);//<string, =, >, <, +, - | |
| 1489 aworker = create_worker(prog, "<String@Real Number", 1, 1, WORKER_TYPE); | |
| 1490 aworker->implement_func=(custom_worker *)vis_stringtoreal; | |
| 1491 aworker->input_types[0] = BUILTIN_TYPE_STRING; | |
| 1492 //add_method(this_comp, aworker); | |
| 1493 | |
| 1494 aworker = create_worker(prog, "=@Real Number", 2, 1, WORKER_TYPE); | |
| 1495 aworker->implement_func=(custom_worker *)vis_realequal; | |
| 1496 aworker->input_types[0] = BUILTIN_TYPE_REAL; | |
| 1497 aworker->input_types[1] = BUILTIN_TYPE_REAL; | |
| 1498 | |
| 1499 //add_method(this_comp, aworker); | |
| 1500 | |
| 1501 aworker = create_worker(prog, ">@Real Number", 2, 1, WORKER_TYPE); | |
| 1502 aworker->implement_func=(custom_worker *)vis_greaterreal; | |
| 1503 aworker->input_types[0] = BUILTIN_TYPE_REAL; | |
| 1504 aworker->input_types[1] = BUILTIN_TYPE_REAL; | |
| 1505 | |
| 1506 //add_method(this_comp, aworker); | |
| 1507 | |
| 1508 aworker = create_worker(prog, "<@Real Number", 2, 1, WORKER_TYPE); | |
| 1509 aworker->implement_func=(custom_worker *)vis_lesserreal; | |
| 1510 aworker->input_types[0] = BUILTIN_TYPE_REAL; | |
| 1511 aworker->input_types[1] = BUILTIN_TYPE_REAL; | |
| 1512 | |
| 1513 //add_method(this_comp, aworker); | |
| 1514 | |
| 1515 aworker = create_worker(prog, "+@Real Number", 2, 1, WORKER_TYPE); | |
| 1516 aworker->implement_func=(custom_worker *)vis_real_add; | |
| 1517 aworker->input_types[0] = BUILTIN_TYPE_REAL; | |
| 1518 aworker->input_types[1] = BUILTIN_TYPE_REAL; | |
| 1519 | |
| 1520 //add_method(this_comp, aworker); | |
| 1521 | |
| 1522 aworker = create_worker(prog, "-@Real Number", 2, 1, WORKER_TYPE); | |
| 1523 aworker->implement_func=(custom_worker *)vis_real_subtract; | |
| 1524 aworker->input_types[0] = BUILTIN_TYPE_REAL; | |
| 1525 aworker->input_types[1] = BUILTIN_TYPE_REAL; | |
| 1526 | |
| 1527 aworker = create_worker(prog, "/@Real Number", 2, 1, WORKER_TYPE); | |
| 1528 aworker->implement_func=(custom_worker *)vis_real_div; | |
| 1529 aworker->input_types[0] = BUILTIN_TYPE_REAL; | |
| 1530 aworker->input_types[1] = BUILTIN_TYPE_REAL; | |
|
28
d8b4d38fceb6
Merged in the worker registration code for the math functions added for ICFP 08
Mike Pavone <pavone@retrodev.com>
parents:
26
diff
changeset
|
1531 |
|
d8b4d38fceb6
Merged in the worker registration code for the math functions added for ICFP 08
Mike Pavone <pavone@retrodev.com>
parents:
26
diff
changeset
|
1532 aworker = create_worker(prog, "Cosine@Real Number", 1, 1, WORKER_TYPE); |
|
d8b4d38fceb6
Merged in the worker registration code for the math functions added for ICFP 08
Mike Pavone <pavone@retrodev.com>
parents:
26
diff
changeset
|
1533 aworker->implement_func=(custom_worker *)vis_real_cos; |
|
d8b4d38fceb6
Merged in the worker registration code for the math functions added for ICFP 08
Mike Pavone <pavone@retrodev.com>
parents:
26
diff
changeset
|
1534 aworker->input_types[0] = BUILTIN_TYPE_REAL; |
|
d8b4d38fceb6
Merged in the worker registration code for the math functions added for ICFP 08
Mike Pavone <pavone@retrodev.com>
parents:
26
diff
changeset
|
1535 |
|
d8b4d38fceb6
Merged in the worker registration code for the math functions added for ICFP 08
Mike Pavone <pavone@retrodev.com>
parents:
26
diff
changeset
|
1536 aworker = create_worker(prog, "Sine@Real Number", 1, 1, WORKER_TYPE); |
|
d8b4d38fceb6
Merged in the worker registration code for the math functions added for ICFP 08
Mike Pavone <pavone@retrodev.com>
parents:
26
diff
changeset
|
1537 aworker->implement_func=(custom_worker *)vis_real_sin; |
|
d8b4d38fceb6
Merged in the worker registration code for the math functions added for ICFP 08
Mike Pavone <pavone@retrodev.com>
parents:
26
diff
changeset
|
1538 aworker->input_types[0] = BUILTIN_TYPE_REAL; |
|
d8b4d38fceb6
Merged in the worker registration code for the math functions added for ICFP 08
Mike Pavone <pavone@retrodev.com>
parents:
26
diff
changeset
|
1539 |
|
d8b4d38fceb6
Merged in the worker registration code for the math functions added for ICFP 08
Mike Pavone <pavone@retrodev.com>
parents:
26
diff
changeset
|
1540 aworker = create_worker(prog, "Tangent@Real Number", 1, 1, WORKER_TYPE); |
|
d8b4d38fceb6
Merged in the worker registration code for the math functions added for ICFP 08
Mike Pavone <pavone@retrodev.com>
parents:
26
diff
changeset
|
1541 aworker->implement_func=(custom_worker *)vis_real_tan; |
|
d8b4d38fceb6
Merged in the worker registration code for the math functions added for ICFP 08
Mike Pavone <pavone@retrodev.com>
parents:
26
diff
changeset
|
1542 aworker->input_types[0] = BUILTIN_TYPE_REAL; |
|
d8b4d38fceb6
Merged in the worker registration code for the math functions added for ICFP 08
Mike Pavone <pavone@retrodev.com>
parents:
26
diff
changeset
|
1543 |
|
d8b4d38fceb6
Merged in the worker registration code for the math functions added for ICFP 08
Mike Pavone <pavone@retrodev.com>
parents:
26
diff
changeset
|
1544 aworker = create_worker(prog, "Arc Cosine@Real Number", 1, 1, WORKER_TYPE); |
|
d8b4d38fceb6
Merged in the worker registration code for the math functions added for ICFP 08
Mike Pavone <pavone@retrodev.com>
parents:
26
diff
changeset
|
1545 aworker->implement_func=(custom_worker *)vis_real_arccos; |
|
d8b4d38fceb6
Merged in the worker registration code for the math functions added for ICFP 08
Mike Pavone <pavone@retrodev.com>
parents:
26
diff
changeset
|
1546 aworker->input_types[0] = BUILTIN_TYPE_REAL; |
|
d8b4d38fceb6
Merged in the worker registration code for the math functions added for ICFP 08
Mike Pavone <pavone@retrodev.com>
parents:
26
diff
changeset
|
1547 |
|
d8b4d38fceb6
Merged in the worker registration code for the math functions added for ICFP 08
Mike Pavone <pavone@retrodev.com>
parents:
26
diff
changeset
|
1548 aworker = create_worker(prog, "Arc Sine@Real Number", 1, 1, WORKER_TYPE); |
|
d8b4d38fceb6
Merged in the worker registration code for the math functions added for ICFP 08
Mike Pavone <pavone@retrodev.com>
parents:
26
diff
changeset
|
1549 aworker->implement_func=(custom_worker *)vis_real_arcsin; |
|
d8b4d38fceb6
Merged in the worker registration code for the math functions added for ICFP 08
Mike Pavone <pavone@retrodev.com>
parents:
26
diff
changeset
|
1550 aworker->input_types[0] = BUILTIN_TYPE_REAL; |
|
d8b4d38fceb6
Merged in the worker registration code for the math functions added for ICFP 08
Mike Pavone <pavone@retrodev.com>
parents:
26
diff
changeset
|
1551 |
|
d8b4d38fceb6
Merged in the worker registration code for the math functions added for ICFP 08
Mike Pavone <pavone@retrodev.com>
parents:
26
diff
changeset
|
1552 aworker = create_worker(prog, "Arc Tangent@Real Number", 1, 1, WORKER_TYPE); |
|
d8b4d38fceb6
Merged in the worker registration code for the math functions added for ICFP 08
Mike Pavone <pavone@retrodev.com>
parents:
26
diff
changeset
|
1553 aworker->implement_func=(custom_worker *)vis_real_arctan; |
|
d8b4d38fceb6
Merged in the worker registration code for the math functions added for ICFP 08
Mike Pavone <pavone@retrodev.com>
parents:
26
diff
changeset
|
1554 aworker->input_types[0] = BUILTIN_TYPE_REAL; |
|
d8b4d38fceb6
Merged in the worker registration code for the math functions added for ICFP 08
Mike Pavone <pavone@retrodev.com>
parents:
26
diff
changeset
|
1555 |
|
d8b4d38fceb6
Merged in the worker registration code for the math functions added for ICFP 08
Mike Pavone <pavone@retrodev.com>
parents:
26
diff
changeset
|
1556 aworker = create_worker(prog, "^@Real Number", 2, 1, WORKER_TYPE); |
|
d8b4d38fceb6
Merged in the worker registration code for the math functions added for ICFP 08
Mike Pavone <pavone@retrodev.com>
parents:
26
diff
changeset
|
1557 aworker->implement_func=(custom_worker *)vis_real_exp; |
|
d8b4d38fceb6
Merged in the worker registration code for the math functions added for ICFP 08
Mike Pavone <pavone@retrodev.com>
parents:
26
diff
changeset
|
1558 aworker->input_types[0] = BUILTIN_TYPE_REAL; |
|
d8b4d38fceb6
Merged in the worker registration code for the math functions added for ICFP 08
Mike Pavone <pavone@retrodev.com>
parents:
26
diff
changeset
|
1559 aworker->input_types[1] = BUILTIN_TYPE_REAL; |
|
d8b4d38fceb6
Merged in the worker registration code for the math functions added for ICFP 08
Mike Pavone <pavone@retrodev.com>
parents:
26
diff
changeset
|
1560 |
|
d8b4d38fceb6
Merged in the worker registration code for the math functions added for ICFP 08
Mike Pavone <pavone@retrodev.com>
parents:
26
diff
changeset
|
1561 aworker = create_worker(prog, "Square Root@Real Number", 1, 1, WORKER_TYPE); |
|
d8b4d38fceb6
Merged in the worker registration code for the math functions added for ICFP 08
Mike Pavone <pavone@retrodev.com>
parents:
26
diff
changeset
|
1562 aworker->implement_func=(custom_worker *)vis_real_sqrt; |
|
d8b4d38fceb6
Merged in the worker registration code for the math functions added for ICFP 08
Mike Pavone <pavone@retrodev.com>
parents:
26
diff
changeset
|
1563 aworker->input_types[0] = BUILTIN_TYPE_REAL; |
| 0 | 1564 |
| 1565 //add_method(this_comp, aworker); | |
| 1566 | |
| 1567 current_method = 0; | |
| 1568 this_comp = create_company(prog, "List", 7, 1, FALSE);//Index, Append, Swap, Insert, Remove, Set, Length, New | |
| 1569 comp_room = add_comp_room(this_comp, "Length", 0, 0, ROOM_NO_ACCESS, ROOM_LONG); | |
| 1570 | |
| 1571 aworker = create_worker(prog, "Index@List", 2, 2, WORKER_TYPE); | |
| 1572 aworker->implement_func=(custom_worker *)vis_list_index; | |
| 1573 aworker->input_types[0] = BUILTIN_TYPE_LIST; | |
| 1574 aworker->input_types[1] = BUILTIN_TYPE_WHOLE; | |
| 1575 | |
| 1576 //add_method(this_comp, aworker); | |
| 1577 | |
| 1578 aworker = create_worker(prog, "Append@List", 2, 1, WORKER_TYPE); | |
| 1579 aworker->implement_func=(custom_worker *)vis_list_append; | |
| 1580 aworker->input_types[0] = BUILTIN_TYPE_LIST; | |
| 1581 aworker->input_types[1] = ANY_TYPE; | |
| 1582 | |
| 1583 //add_method(this_comp, aworker); | |
| 1584 | |
| 1585 aworker = create_worker(prog, "Swap@List",3, 1, WORKER_TYPE); | |
| 1586 aworker->implement_func=(custom_worker *)vis_list_swap; | |
| 1587 aworker->input_types[0] = BUILTIN_TYPE_LIST; | |
| 1588 aworker->input_types[1] = BUILTIN_TYPE_WHOLE; | |
| 1589 aworker->input_types[2] = BUILTIN_TYPE_WHOLE; | |
| 1590 | |
| 1591 //add_method(this_comp, aworker); | |
| 1592 | |
| 1593 aworker = create_worker(prog, "Insert@List",3, 1, WORKER_TYPE); | |
| 1594 aworker->implement_func=(custom_worker *)vis_list_insert; | |
| 1595 aworker->input_types[0] = BUILTIN_TYPE_LIST; | |
| 1596 aworker->input_types[1] = BUILTIN_TYPE_WHOLE; | |
| 1597 aworker->input_types[2] = ANY_TYPE; | |
| 1598 | |
| 1599 //add_method(this_comp, aworker); | |
| 1600 | |
| 1601 aworker = create_worker(prog, "Remove@List", 2, 1, WORKER_TYPE); | |
| 1602 aworker->implement_func=(custom_worker *)vis_list_remove; | |
| 1603 aworker->input_types[0] = BUILTIN_TYPE_LIST; | |
| 1604 aworker->input_types[1] = BUILTIN_TYPE_WHOLE; | |
| 1605 | |
| 1606 //add_method(this_comp, aworker); | |
| 1607 | |
| 1608 aworker = create_worker(prog, "Set@List",3, 1, WORKER_TYPE); | |
| 1609 aworker->implement_func=(custom_worker *)vis_list_set; | |
| 1610 aworker->input_types[0] = BUILTIN_TYPE_LIST; | |
| 1611 aworker->input_types[1] = BUILTIN_TYPE_WHOLE; | |
| 1612 aworker->input_types[2] = ANY_TYPE; | |
| 1613 | |
| 1614 //add_method(this_comp, aworker); | |
| 1615 | |
| 1616 aworker = create_worker(prog, "Length@List", 1, 1, WORKER_TYPE); | |
| 1617 aworker->implement_func = (custom_worker *)vis_list_length; | |
| 1618 aworker->input_types[0] = BUILTIN_TYPE_LIST; | |
| 1619 //add_method(this_comp, aworker); | |
| 1620 | |
| 1621 aworker = create_worker(prog, "New@List",0, 1, WORKER_TYPE); | |
| 1622 aworker->implement_func=(custom_worker *)vis_list_new; | |
| 1623 //add_method(this_comp, aworker); | |
| 1624 | |
| 1625 aworker = create_worker(prog, "First@List", 1, 2, WORKER_TYPE); | |
| 1626 aworker->implement_func=(custom_worker *)vis_list_first; | |
| 1627 aworker->input_types[0] = BUILTIN_TYPE_LIST; | |
| 1628 | |
| 1629 aworker = create_worker(prog, "Next@List", 2, 2, WORKER_TYPE); | |
| 1630 aworker->implement_func=(custom_worker *)vis_list_next; | |
| 1631 aworker->input_types[0] = BUILTIN_TYPE_LIST; | |
| 1632 aworker->input_types[1] = BUILTIN_TYPE_WHOLE; | |
| 1633 | |
| 1634 current_method = 0; | |
| 1635 this_comp = create_company(prog, "Dictionary", 5, 0, FALSE);//Index, Swap, Remove, Set, Length, New | |
| 1636 aworker = create_worker(prog, "Index@Dictionary", 2, 2, WORKER_TYPE); | |
| 1637 aworker->implement_func=(custom_worker *)vis_dict_index; | |
| 1638 aworker->input_types[0] = BUILTIN_TYPE_DICT; | |
| 1639 aworker->input_types[1] = BUILTIN_TYPE_STRING; | |
| 1640 | |
| 1641 //add_method(this_comp, aworker); | |
| 1642 | |
| 1643 aworker = create_worker(prog, "Swap@Dictionary",3, 1, WORKER_TYPE); | |
| 1644 aworker->implement_func=(custom_worker *)vis_dict_swap; | |
| 1645 aworker->input_types[0] = BUILTIN_TYPE_DICT; | |
| 1646 aworker->input_types[1] = BUILTIN_TYPE_STRING; | |
| 1647 aworker->input_types[2] = BUILTIN_TYPE_STRING; | |
| 1648 | |
| 1649 //add_method(this_comp, aworker); | |
| 1650 | |
| 1651 aworker = create_worker(prog, "Remove@Dictionary", 2, 1, WORKER_TYPE); | |
| 1652 aworker->implement_func=(custom_worker *)vis_dict_remove; | |
| 1653 aworker->input_types[0] = BUILTIN_TYPE_DICT; | |
| 1654 aworker->input_types[1] = BUILTIN_TYPE_STRING; | |
| 1655 | |
| 1656 //add_method(this_comp, aworker); | |
| 1657 | |
| 1658 aworker = create_worker(prog, "Set@Dictionary",3, 1, WORKER_TYPE); | |
| 1659 aworker->implement_func=(custom_worker *)vis_dict_set; | |
| 1660 aworker->input_types[0] = BUILTIN_TYPE_DICT; | |
| 1661 aworker->input_types[1] = BUILTIN_TYPE_STRING; | |
| 1662 aworker->input_types[2] = ANY_TYPE; | |
| 1663 | |
| 1664 aworker = create_worker(prog, "Length@Dictionary", 1, 1, WORKER_TYPE); | |
| 1665 aworker->implement_func=(custom_worker *)vis_dict_length; | |
| 1666 aworker->input_types[0] = BUILTIN_TYPE_DICT; | |
| 1667 | |
| 1668 //add_method(this_comp, aworker); | |
| 1669 | |
| 1670 aworker = create_worker(prog, "New@Dictionary",0, 1, WORKER_TYPE); | |
| 1671 aworker->implement_func=(custom_worker *)vis_dict_new; | |
| 1672 //add_method(this_comp, aworker); | |
| 1673 | |
| 1674 aworker = create_worker(prog, "First@Dictionary", 1, 2, WORKER_TYPE); | |
| 1675 aworker->implement_func=(custom_worker *)vis_dict_first; | |
| 1676 aworker->input_types[0] = BUILTIN_TYPE_DICT; | |
| 1677 | |
| 1678 aworker = create_worker(prog, "Next@Dictionary", 2, 2, WORKER_TYPE); | |
| 1679 aworker->implement_func=(custom_worker *)vis_dict_next; | |
| 1680 aworker->input_types[0] = BUILTIN_TYPE_DICT; | |
| 1681 aworker->input_types[1] = BUILTIN_TYPE_STRING; | |
| 1682 | |
| 1683 current_method = 0; | |
| 1684 #ifdef SEGA | |
| 1685 this_comp = create_company(prog, "File", 0, 0, FALSE); | |
| 1686 #else | |
| 1687 | |
| 1688 this_comp = create_company(prog, "File", 7, 0, FALSE);//<String, Get FString, Get DString, Get Byte, Get Word, Get Long, Put String | |
| 1689 aworker = create_worker(prog, "<String@File", 1, 1, WORKER_TYPE); | |
| 1690 aworker->implement_func=(custom_worker *)vis_file_from_string; | |
| 1691 aworker->input_types[0] = BUILTIN_TYPE_STRING; | |
| 1692 //add_method(this_comp, aworker); | |
| 1693 | |
| 1694 aworker = create_worker(prog, "Get FString@File", 2, 2, WORKER_TYPE); | |
| 1695 aworker->implement_func=(custom_worker *)vis_file_get_fstring; | |
| 1696 aworker->input_types[0] = BUILTIN_TYPE_FILE; | |
| 1697 aworker->input_types[1] = BUILTIN_TYPE_WHOLE; | |
| 1698 | |
| 1699 //add_method(this_comp, aworker); | |
| 1700 | |
| 1701 aworker = create_worker(prog, "Get DString@File", 2, 4, WORKER_TYPE); | |
| 1702 aworker->implement_func=(custom_worker *)vis_file_get_dstring; | |
| 1703 aworker->input_types[0] = BUILTIN_TYPE_FILE; | |
| 1704 aworker->input_types[1] = ANY_TYPE; | |
| 1705 | |
| 1706 //add_method(this_comp, aworker); | |
| 1707 | |
| 1708 aworker = create_worker(prog, "Get Byte@File", 1, 3, WORKER_TYPE); | |
| 1709 aworker->implement_func=(custom_worker *)vis_file_get_byte; | |
| 1710 aworker->input_types[0] = BUILTIN_TYPE_FILE; | |
| 1711 //add_method(this_comp, aworker); | |
| 1712 | |
| 1713 aworker = create_worker(prog, "Get Word@File", 1, 3, WORKER_TYPE); | |
| 1714 aworker->implement_func=(custom_worker *)vis_file_get_word; | |
| 1715 aworker->input_types[0] = BUILTIN_TYPE_FILE; | |
| 1716 //add_method(this_comp, aworker); | |
| 1717 | |
| 1718 aworker = create_worker(prog, "Get Long@File", 1, 3, WORKER_TYPE); | |
| 1719 aworker->implement_func=(custom_worker *)vis_file_get_long; | |
| 1720 aworker->input_types[0] = BUILTIN_TYPE_FILE; | |
| 1721 //add_method(this_comp, aworker); | |
| 1722 | |
| 26 | 1723 aworker = create_worker(prog, "Get Double@File", 1, 3, WORKER_TYPE); |
| 1724 aworker->implement_func=(custom_worker *)vis_file_get_double; | |
| 1725 aworker->input_types[0] = BUILTIN_TYPE_FILE; | |
| 1726 | |
| 0 | 1727 aworker = create_worker(prog, "Put String@File", 2, 1, WORKER_TYPE); |
| 1728 aworker->implement_func=(custom_worker *)vis_file_put_string; | |
| 1729 aworker->input_types[0] = BUILTIN_TYPE_FILE; | |
| 1730 aworker->input_types[1] = BUILTIN_TYPE_STRING; | |
| 1731 | |
| 1732 aworker = create_worker(prog, "Length@File", 1, 1, WORKER_TYPE); | |
| 1733 aworker->implement_func=(custom_worker *)vis_file_length; | |
| 1734 aworker->input_types[0] = BUILTIN_TYPE_FILE; | |
| 1735 | |
| 1736 //add_method(this_comp, aworker); | |
| 1737 #endif | |
| 1738 | |
| 1739 current_method = 0; | |
| 1740 | |
| 1741 this_comp = create_company(prog, "Worker", 3, 0, FALSE);//<String, Do, Later: methods for manipulating | |
| 1742 | |
| 1743 aworker = create_worker(prog, "<String@Worker", 1, 1, WORKER_TYPE); | |
| 1744 aworker->implement_func=(custom_worker *)vis_worker_from_string; | |
| 1745 aworker->input_types[0] = BUILTIN_TYPE_STRING; | |
| 1746 //add_method(this_comp, aworker); | |
| 1747 | |
| 1748 aworker = create_worker(prog, "Do@Worker", 2, 1, WORKER_TYPE); | |
| 1749 aworker->implement_func=(custom_worker *)vis_worker_do; | |
| 1750 aworker->input_types[0] = BUILTIN_TYPE_WORKER; | |
| 1751 aworker->input_types[1] = BUILTIN_TYPE_LIST; | |
| 1752 | |
| 1753 aworker = create_worker(prog, "Set Input@Worker", 3, 1, WORKER_TYPE); | |
| 1754 aworker->implement_func=(custom_worker *)vis_worker_setinput; | |
| 1755 aworker->input_types[0] = BUILTIN_TYPE_WORKER; | |
| 1756 aworker->input_types[1] = BUILTIN_TYPE_WHOLE; | |
| 1757 aworker->input_types[2] = ANY_TYPE; | |
| 1758 //add_method(this_comp, aworker); | |
| 1759 | |
| 1760 aworker = create_worker(prog, "Add Worker Call@Worker", 2, 2, WORKER_TYPE); | |
| 1761 aworker->implement_func=(custom_worker *)vis_worker_add_worker_call; | |
| 1762 aworker->input_types[0] = BUILTIN_TYPE_WORKER; | |
| 1763 aworker->input_types[1] = BUILTIN_TYPE_WORKER; | |
| 1764 | |
| 1765 aworker = create_worker(prog, "Add Wire@Worker", 5, 1, WORKER_TYPE); | |
| 1766 aworker->implement_func=(custom_worker *)vis_worker_add_wire; | |
| 1767 aworker->input_types[0] = BUILTIN_TYPE_WORKER; | |
| 1768 aworker->input_types[1] = BUILTIN_TYPE_WHOLE; | |
| 1769 aworker->input_types[2] = BUILTIN_TYPE_WHOLE; | |
| 1770 aworker->input_types[3] = BUILTIN_TYPE_WHOLE; | |
| 1771 aworker->input_types[4] = BUILTIN_TYPE_WHOLE; | |
| 1772 | |
| 1773 aworker = create_worker(prog, "Add Constant@Worker", 2, 2, WORKER_TYPE); | |
| 1774 aworker->implement_func=(custom_worker *)vis_worker_add_constant; | |
| 1775 aworker->input_types[0] = BUILTIN_TYPE_WORKER; | |
| 1776 aworker->input_types[1] = ANY_TYPE; | |
| 1777 | |
| 1778 aworker = create_worker(prog, "Add Input@Worker", 3, 2, WORKER_TYPE); | |
| 1779 aworker->implement_func=(custom_worker *)vis_worker_add_input; | |
| 1780 aworker->input_types[0] = BUILTIN_TYPE_WORKER; | |
| 1781 aworker->input_types[1] = BUILTIN_TYPE_STRING; | |
| 1782 aworker->input_types[2] = BUILTIN_TYPE_WHOLE; | |
| 1783 | |
| 1784 aworker = create_worker(prog, "Add Output@Worker", 3, 2, WORKER_TYPE); | |
| 1785 aworker->implement_func=(custom_worker *)vis_worker_add_output; | |
| 1786 aworker->input_types[0] = BUILTIN_TYPE_WORKER; | |
| 1787 aworker->input_types[1] = BUILTIN_TYPE_STRING; | |
| 1788 aworker->input_types[2] = BUILTIN_TYPE_WHOLE; | |
| 1789 | |
| 1790 aworker = create_worker(prog, "Add Object Get@Worker", 2, 2, WORKER_TYPE); | |
| 1791 aworker->implement_func=(custom_worker *)vis_worker_add_objectget; | |
| 1792 aworker->input_types[0] = BUILTIN_TYPE_WORKER; | |
| 1793 aworker->input_types[1] = BUILTIN_TYPE_STRING; | |
| 1794 | |
| 1795 aworker = create_worker(prog, "Add Object Set@Worker", 2, 2, WORKER_TYPE); | |
| 1796 aworker->implement_func=(custom_worker *)vis_worker_add_objectset; | |
| 1797 aworker->input_types[0] = BUILTIN_TYPE_WORKER; | |
| 1798 aworker->input_types[1] = BUILTIN_TYPE_STRING; | |
| 1799 | |
| 1800 aworker = create_worker(prog, "Add Global Get@Worker", 3, 2, WORKER_TYPE); | |
| 1801 aworker->implement_func=(custom_worker *)vis_worker_add_globalget; | |
| 1802 aworker->input_types[0] = BUILTIN_TYPE_WORKER; | |
| 1803 aworker->input_types[1] = BUILTIN_TYPE_STRING; | |
| 1804 aworker->input_types[2] = BUILTIN_TYPE_STRING; | |
| 1805 | |
| 1806 aworker = create_worker(prog, "Add Global Set@Worker", 3, 2, WORKER_TYPE); | |
| 1807 aworker->implement_func=(custom_worker *)vis_worker_add_globalset; | |
| 1808 aworker->input_types[0] = BUILTIN_TYPE_WORKER; | |
| 1809 aworker->input_types[1] = BUILTIN_TYPE_STRING; | |
| 1810 aworker->input_types[2] = BUILTIN_TYPE_STRING; | |
| 1811 | |
| 1812 aworker = create_worker(prog, "Clear@Worker", 1, 1, WORKER_TYPE); | |
| 1813 aworker->implement_func=(custom_worker *)vis_worker_clear; | |
| 1814 aworker->input_types[0] = BUILTIN_TYPE_WORKER; | |
| 1815 | |
| 1816 aworker = create_worker(prog, "Uses@Worker", 2, 1, WORKER_TYPE); | |
| 1817 aworker->implement_func=(custom_worker *)vis_worker_uses; | |
| 1818 aworker->input_types[0] = BUILTIN_TYPE_WORKER; | |
| 1819 aworker->input_types[1] = BUILTIN_TYPE_LIST; | |
| 1820 | |
| 1821 aworker = create_worker(prog, "Set IO Counts@Worker", 3, 1, WORKER_TYPE); | |
| 1822 aworker->implement_func=(custom_worker *)vis_worker_setio_counts; | |
| 1823 aworker->input_types[0] = BUILTIN_TYPE_WORKER; | |
| 1824 aworker->input_types[1] = BUILTIN_TYPE_WHOLE; | |
| 1825 aworker->input_types[2] = BUILTIN_TYPE_WHOLE; | |
| 1826 | |
| 1827 aworker = create_worker(prog, "New@Worker", 1, 1, WORKER_TYPE); | |
| 1828 aworker->implement_func=(custom_worker *)vis_worker_new; | |
| 1829 aworker->input_types[0] = BUILTIN_TYPE_STRING; | |
| 1830 | |
| 1831 #ifdef GUI_LIB | |
| 1832 current_method = 0; | |
| 1833 | |
| 1834 this_comp = create_company(prog, "Window", 3, 0, FALSE); | |
| 1835 | |
| 1836 aworker = create_worker(prog, "New@Window", 3, 1, WORKER_TYPE); | |
| 1837 aworker->implement_func=(custom_worker *)vis_window_new; | |
| 1838 aworker->input_types[0] = BUILTIN_TYPE_STRING; | |
| 1839 aworker->input_types[1] = BUILTIN_TYPE_REAL; | |
| 1840 aworker->input_types[2] = BUILTIN_TYPE_REAL; | |
| 1841 //add_method(this_comp, aworker); | |
| 1842 | |
| 1843 aworker = create_worker(prog, "Add Widget@Window", 5, 1, WORKER_TYPE); | |
| 1844 aworker->implement_func=(custom_worker *)vis_window_add_widget; | |
| 1845 aworker->input_types[0] = BUILTIN_TYPE_WINDOW; | |
| 1846 aworker->input_types[1] = BUILTIN_TYPE_STRING; | |
| 1847 aworker->input_types[2] = ANY_TYPE; | |
| 1848 aworker->input_types[3] = BUILTIN_TYPE_REAL; | |
| 1849 aworker->input_types[4] = BUILTIN_TYPE_REAL; | |
| 1850 //add_method(this_comp, aworker); | |
| 1851 | |
| 1852 aworker = create_worker(prog, "Show@Window", 3, 1, WORKER_TYPE); | |
| 1853 aworker->implement_func=(custom_worker *)vis_window_show; | |
| 1854 aworker->input_types[0] = BUILTIN_TYPE_WINDOW; | |
| 1855 aworker->input_types[1] = BUILTIN_TYPE_REAL; | |
| 1856 aworker->input_types[2] = BUILTIN_TYPE_REAL; | |
| 1857 //add_method(this_comp, aworker); | |
| 1858 | |
| 1859 current_method = 0; | |
| 1860 this_comp = create_company(prog, "Screen Window", 3, 0, FALSE); | |
| 1861 | |
| 1862 aworker = create_worker(prog, "Get Value@Screen Window", 2, 1, WORKER_TYPE); | |
| 1863 aworker->implement_func=(custom_worker *)vis_window_get_value; | |
| 1864 aworker->input_types[0] = BUILTIN_TYPE_WINDOW_SHOWN; | |
| 1865 aworker->input_types[1] = BUILTIN_TYPE_STRING; | |
| 1866 //add_method(this_comp, aworker); | |
| 1867 | |
| 1868 aworker = create_worker(prog, "Set Value@Screen Window", 3, 0, WORKER_TYPE); | |
| 1869 aworker->implement_func=(custom_worker *)vis_window_set_value; | |
| 1870 aworker->input_types[0] = BUILTIN_TYPE_WINDOW_SHOWN; | |
| 1871 aworker->input_types[1] = BUILTIN_TYPE_STRING; | |
| 1872 #ifdef SYLLABLE | |
| 1873 aworker->input_types[2] = ANY_TYPE; | |
| 1874 #else | |
| 1875 aworker->input_types[2] = BUILTIN_TYPE_STRING; | |
| 1876 #endif | |
| 1877 //add_method(this_comp, aworker); | |
| 1878 | |
| 1879 aworker = create_worker(prog, "Wait Close@Screen Window", 1, 1, WORKER_TYPE); | |
| 1880 aworker->implement_func=(custom_worker *)vis_window_wait_close; | |
| 1881 aworker->input_types[0] = BUILTIN_TYPE_WINDOW_SHOWN; | |
| 1882 //add_method(this_comp, aworker); | |
| 1883 | |
| 1884 #ifdef SYLLABLE | |
| 1885 aworker = create_worker(prog, "Add Widget@Screen Window", 5, 1, WORKER_TYPE); | |
| 1886 aworker->implement_func=(custom_worker *)vis_window_shown_addwidget; | |
| 1887 aworker->input_types[0] = BUILTIN_TYPE_WINDOW_SHOWN; | |
| 1888 aworker->input_types[1] = BUILTIN_TYPE_STRING; | |
| 1889 aworker->input_types[2] = ANY_TYPE; | |
| 1890 aworker->input_types[3] = BUILTIN_TYPE_REAL; | |
| 1891 aworker->input_types[4] = BUILTIN_TYPE_REAL; | |
| 1892 #endif | |
| 1893 | |
| 1894 current_method = 0; | |
| 1895 create_company(prog, "Button", 2, 0, FALSE); | |
| 1896 | |
| 1897 aworker = create_worker(prog, "New@Button", 3, 1, WORKER_TYPE); | |
| 1898 aworker->implement_func=(custom_worker *)vis_button_new; | |
| 1899 aworker->input_types[0] = BUILTIN_TYPE_STRING; | |
| 1900 aworker->input_types[1] = BUILTIN_TYPE_REAL; | |
| 1901 aworker->input_types[2] = BUILTIN_TYPE_REAL; | |
| 1902 //add_method(this_comp, aworker); | |
| 1903 | |
| 1904 aworker = create_worker(prog, "Set Handler@Button", 3, 1, WORKER_TYPE); | |
| 1905 aworker->implement_func=(custom_worker *)vis_button_set_handler; | |
| 1906 aworker->input_types[0] = BUILTIN_TYPE_BUTTON; | |
| 1907 aworker->input_types[1] = BUILTIN_TYPE_STRING; | |
| 1908 aworker->input_types[2] = BUILTIN_TYPE_WORKER; | |
| 1909 //add_method(this_comp, aworker); | |
| 1910 | |
| 1911 current_method = 0; | |
| 1912 create_company(prog, "Input Box", 2, 0, FALSE); | |
| 1913 | |
| 1914 aworker = create_worker(prog, "New@Input Box", 3, 1, WORKER_TYPE); | |
| 1915 aworker->implement_func=(custom_worker *)vis_inputbox_new; | |
| 1916 aworker->input_types[0] = BUILTIN_TYPE_STRING; | |
| 1917 aworker->input_types[1] = BUILTIN_TYPE_REAL; | |
| 1918 aworker->input_types[2] = BUILTIN_TYPE_REAL; | |
| 1919 //add_method(this_comp, aworker); | |
| 1920 | |
| 1921 aworker = create_worker(prog, "Set Type@Input Box", 2, 1, WORKER_TYPE); | |
| 1922 aworker->implement_func=(custom_worker *)vis_inputbox_settype; | |
| 1923 aworker->input_types[0] = BUILTIN_TYPE_INPUTBOX; | |
| 1924 aworker->input_types[1] = BUILTIN_TYPE_STRING; | |
| 1925 //add_method(this_comp, aworker); | |
| 1926 | |
| 1927 #endif | |
| 1928 #ifndef NO_NET | |
| 1929 this_comp = create_company(prog, "Net Client", 3, 0, FALSE); | |
| 1930 aworker = create_worker(prog, "New@Net Client", 2, 1, WORKER_TYPE); | |
| 1931 aworker->implement_func =(custom_worker *)net_client_new; | |
| 1932 aworker->input_types[0] = BUILTIN_TYPE_STRING; | |
| 1933 aworker->input_types[1] = BUILTIN_TYPE_WHOLE; | |
| 1934 | |
| 1935 aworker = create_worker(prog, "Put String@Net Client", 2, 2, WORKER_TYPE); | |
| 1936 aworker->implement_func = (custom_worker *)net_client_put_string; | |
| 1937 aworker->input_types[0] = BUILTIN_TYPE_NETCLIENT; | |
| 1938 aworker->input_types[1] = BUILTIN_TYPE_STRING; | |
| 1939 | |
| 1940 aworker = create_worker(prog, "Get FString@Net Client", 2, 3, WORKER_TYPE); | |
| 1941 aworker->implement_func = (custom_worker *)net_client_get_fstring; | |
| 1942 aworker->input_types[0] = BUILTIN_TYPE_NETCLIENT; | |
| 1943 aworker->input_types[1] = BUILTIN_TYPE_WHOLE; | |
| 1944 | |
| 1945 aworker = create_worker(prog, "Get DString@Net Client", 2, 4, WORKER_TYPE); | |
| 1946 aworker->implement_func = (custom_worker *)net_client_get_dstring; | |
| 1947 aworker->input_types[0] = BUILTIN_TYPE_NETCLIENT; | |
| 1948 aworker->input_types[1] = ANY_TYPE; | |
| 1949 | |
| 1950 aworker = create_worker(prog, "Put Raw@Net Client", 2, 2, WORKER_TYPE); | |
| 1951 aworker->implement_func = (custom_worker *)net_client_put_raw; | |
| 1952 aworker->input_types[0] = BUILTIN_TYPE_NETCLIENT; | |
| 1953 aworker->input_types[1] = ANY_TYPE; | |
| 1954 | |
| 1955 aworker = create_worker(prog, "Get Raw@Net Client", 2, 3, WORKER_TYPE); | |
| 1956 aworker->implement_func = (custom_worker *)net_client_get_raw; | |
| 1957 aworker->input_types[0] = BUILTIN_TYPE_NETCLIENT; | |
| 1958 aworker->input_types[1] = ANY_TYPE; | |
| 1959 | |
| 1960 aworker = create_worker(prog, "Listen on Port", 2, 0, WORKER_TYPE); | |
| 1961 aworker->implement_func = (custom_worker *)vis_net_listenport; | |
| 1962 aworker->input_types[0] = BUILTIN_TYPE_WHOLE; | |
| 1963 aworker->input_types[1] = BUILTIN_TYPE_WORKER; | |
| 1964 #endif | |
| 1965 | |
| 1966 create_company(prog, "Global Store", 0, 0, FALSE); | |
| 1967 | |
| 1968 create_company(prog, "Program", 5, 0, FALSE); | |
| 1969 | |
| 1970 aworker = create_worker(prog, "New@Program", 0, 1, WORKER_TYPE); | |
| 1971 aworker->implement_func = (custom_worker *)vis_program_new; | |
| 1972 | |
| 1973 aworker = create_worker(prog, "New Worker@Program", 2, 2, WORKER_TYPE); | |
| 1974 aworker->implement_func = (custom_worker *)vis_program_new_worker; | |
| 1975 aworker->input_types[0] = BUILTIN_TYPE_PROGRAM; | |
| 1976 aworker->input_types[1] = BUILTIN_TYPE_STRING; | |
| 1977 | |
| 1978 aworker = create_worker(prog, "Add Worker@Program", 2, 2, WORKER_TYPE); | |
| 1979 aworker->implement_func = (custom_worker *)vis_program_add_worker; | |
| 1980 aworker->input_types[0] = BUILTIN_TYPE_PROGRAM; | |
| 1981 aworker->input_types[1] = BUILTIN_TYPE_WORKER; | |
| 1982 | |
| 1983 aworker = create_worker(prog, "Add Builtins@Program", 1, 1, WORKER_TYPE); | |
| 1984 aworker->implement_func = (custom_worker *)vis_program_add_builtins; | |
| 1985 aworker->input_types[0] = BUILTIN_TYPE_PROGRAM; | |
| 1986 | |
| 1987 aworker = create_worker(prog, "Run@Program", 2, 1, WORKER_TYPE); | |
| 1988 aworker->implement_func = (custom_worker *)vis_program_run; | |
| 1989 aworker->input_types[0] = BUILTIN_TYPE_PROGRAM; | |
| 1990 aworker->input_types[1] = ANY_TYPE; | |
| 1991 | |
| 1992 aworker = create_worker(prog, "Find Worker@Program", 2, 2, WORKER_TYPE); | |
| 1993 aworker->implement_func = (custom_worker *)vis_program_find_worker; | |
| 1994 aworker->input_types[0] = BUILTIN_TYPE_PROGRAM; | |
| 1995 aworker->input_types[1] = BUILTIN_TYPE_STRING; | |
| 1996 | |
| 1997 #ifdef GUI_LIB | |
| 1998 #ifdef SYLLABLE | |
| 1999 create_company(prog, "Custom Widget", 2, 0, FALSE); | |
| 2000 | |
| 2001 aworker = create_worker(prog, "New@Custom Widget", 3, 1, WORKER_TYPE); | |
| 2002 aworker->implement_func=(custom_worker *)vis_customwidget_new; | |
| 2003 aworker->input_types[0] = BUILTIN_TYPE_STRING; | |
| 2004 aworker->input_types[1] = BUILTIN_TYPE_REAL; | |
| 2005 aworker->input_types[2] = BUILTIN_TYPE_REAL; | |
| 2006 //add_method(this_comp, aworker); | |
| 2007 | |
| 2008 aworker = create_worker(prog, "Set Handler@Custom Widget", 3, 1, WORKER_TYPE); | |
| 2009 aworker->implement_func=(custom_worker *)vis_button_set_handler; | |
| 2010 aworker->input_types[0] = BUILTIN_TYPE_CUSTOM_WIDGET; | |
| 2011 aworker->input_types[1] = BUILTIN_TYPE_STRING; | |
| 2012 aworker->input_types[2] = BUILTIN_TYPE_WORKER; | |
| 2013 //add_method(this_comp, aworker); | |
| 2014 | |
| 2015 create_company(prog, "Screen Custom Widget", 3, 0, FALSE); | |
| 2016 | |
| 2017 aworker = create_worker(prog, "Default Draw@Screen Custom Widget", 1, 1, WORKER_TYPE); | |
| 2018 aworker->implement_func=(custom_worker *)vis_screen_custom_defaultpaint; | |
| 2019 aworker->input_types[0] = BUILTIN_TYPE_SCREEN_CUSTOM; | |
| 2020 //add_method(this_comp, aworker); | |
| 2021 | |
| 2022 aworker = create_worker(prog, "Draw Line@Screen Custom Widget", 5, 1, WORKER_TYPE); | |
| 2023 aworker->implement_func=(custom_worker *)vis_screen_custom_drawline; | |
| 2024 aworker->input_types[0] = BUILTIN_TYPE_SCREEN_CUSTOM; | |
| 2025 aworker->input_types[1] = BUILTIN_TYPE_REAL; | |
| 2026 aworker->input_types[2] = BUILTIN_TYPE_REAL; | |
| 2027 aworker->input_types[3] = BUILTIN_TYPE_REAL; | |
| 2028 aworker->input_types[4] = BUILTIN_TYPE_REAL; | |
| 2029 //add_method(this_comp, aworker); | |
| 2030 | |
| 2031 aworker = create_worker(prog, "Draw String@Screen Custom Widget", 4, 1, WORKER_TYPE); | |
| 2032 aworker->implement_func=(custom_worker *)vis_screen_custom_drawstring; | |
| 2033 aworker->input_types[0] = BUILTIN_TYPE_SCREEN_CUSTOM; | |
| 2034 aworker->input_types[1] = BUILTIN_TYPE_STRING; | |
| 2035 aworker->input_types[2] = BUILTIN_TYPE_REAL; | |
| 2036 aworker->input_types[3] = BUILTIN_TYPE_REAL; | |
| 2037 | |
| 2038 aworker = create_worker(prog, "Set Draw Color@Screen Custom Widget", 5, 1, WORKER_TYPE); | |
| 2039 aworker->implement_func=(custom_worker *)vis_screen_custom_setdrawcolor; | |
| 2040 aworker->input_types[0] = BUILTIN_TYPE_SCREEN_CUSTOM; | |
| 2041 aworker->input_types[1] = BUILTIN_TYPE_WHOLE; | |
| 2042 aworker->input_types[2] = BUILTIN_TYPE_WHOLE; | |
| 2043 aworker->input_types[3] = BUILTIN_TYPE_WHOLE; | |
| 2044 aworker->input_types[4] = BUILTIN_TYPE_WHOLE; | |
| 2045 | |
| 2046 aworker = create_worker(prog, "Move By@Screen Custom Widget", 3, 1, WORKER_TYPE); | |
| 2047 aworker->implement_func=(custom_worker *)vis_screen_custom_moveby; | |
| 2048 aworker->input_types[0] = BUILTIN_TYPE_SCREEN_CUSTOM; | |
| 2049 aworker->input_types[1] = BUILTIN_TYPE_REAL; | |
| 2050 aworker->input_types[2] = BUILTIN_TYPE_REAL; | |
| 2051 | |
| 2052 aworker = create_worker(prog, "Set Handler@Screen Custom Widget", 3, 1, WORKER_TYPE); | |
| 2053 aworker->implement_func=(custom_worker *)vis_screen_custom_sethandler; | |
| 2054 aworker->input_types[0] = BUILTIN_TYPE_SCREEN_CUSTOM; | |
| 2055 aworker->input_types[1] = BUILTIN_TYPE_STRING; | |
| 2056 aworker->input_types[2] = BUILTIN_TYPE_WORKER; | |
| 2057 | |
| 2058 aworker = create_worker(prog, "Remove Handler@Screen Custom Widget", 2, 1, WORKER_TYPE); | |
| 2059 aworker->implement_func=(custom_worker *)vis_screen_custom_removehandler; | |
| 2060 aworker->input_types[0] = BUILTIN_TYPE_SCREEN_CUSTOM; | |
| 2061 aworker->input_types[1] = BUILTIN_TYPE_STRING; | |
| 2062 | |
| 2063 aworker = create_worker(prog, "Give Focus@Screen Custom Widget", 2, 1, WORKER_TYPE); | |
| 2064 aworker->implement_func=(custom_worker *)vis_screen_custom_givefocus; | |
| 2065 aworker->input_types[0] = BUILTIN_TYPE_SCREEN_CUSTOM; | |
| 2066 aworker->input_types[1] = BUILTIN_TYPE_YESNO; | |
| 2067 | |
| 2068 aworker = create_worker(prog, "Add Widget@Screen Custom Widget", 5, 1, WORKER_TYPE); | |
| 2069 aworker->implement_func=(custom_worker *)vis_screen_custom_addwidget; | |
| 2070 aworker->input_types[0] = BUILTIN_TYPE_SCREEN_CUSTOM; | |
| 2071 aworker->input_types[1] = BUILTIN_TYPE_STRING; | |
| 2072 aworker->input_types[2] = ANY_TYPE; | |
| 2073 aworker->input_types[3] = BUILTIN_TYPE_REAL; | |
| 2074 aworker->input_types[4] = BUILTIN_TYPE_REAL; | |
| 2075 | |
| 2076 #endif | |
| 2077 #endif | |
| 2078 create_company(prog, "Buffer", 7, 0, FALSE); | |
| 2079 | |
| 2080 aworker = create_worker(prog, "New@Buffer", 1, 1, WORKER_TYPE); | |
| 2081 aworker->implement_func=(custom_worker *)vis_buffer_new; | |
| 2082 aworker->input_types[0] = BUILTIN_TYPE_WHOLE; | |
| 2083 | |
| 2084 aworker = create_worker(prog, "Lock@Buffer", 1, 1, WORKER_TYPE); | |
| 2085 aworker->implement_func=(custom_worker *)vis_buffer_lock; | |
| 2086 aworker->input_types[0] = BUILTIN_TYPE_BUFFER; | |
| 2087 | |
| 2088 aworker = create_worker(prog, "Unlock@Buffer", 1, 1, WORKER_TYPE); | |
| 2089 aworker->implement_func=(custom_worker *)vis_buffer_unlock; | |
| 2090 aworker->input_types[0] = BUILTIN_TYPE_BUFFER; | |
| 2091 | |
| 2092 aworker = create_worker(prog, "Put Byte@Buffer", 2, 1, WORKER_TYPE); | |
| 2093 aworker->implement_func=(custom_worker *)vis_buffer_putbyte; | |
| 2094 aworker->input_types[0] = BUILTIN_TYPE_BUFFER; | |
| 2095 aworker->input_types[1] = BUILTIN_TYPE_WHOLE; | |
| 2096 | |
| 2097 aworker = create_worker(prog, "Write Byte@Buffer", 2, 1, WORKER_TYPE); | |
| 2098 aworker->implement_func=(custom_worker *)vis_buffer_writebyte; | |
| 2099 aworker->input_types[0] = BUILTIN_TYPE_BUFFER; | |
| 2100 aworker->input_types[1] = BUILTIN_TYPE_WHOLE; | |
| 2101 | |
| 2102 aworker = create_worker(prog, "Put Word@Buffer", 2, 1, WORKER_TYPE); | |
| 2103 aworker->implement_func=(custom_worker *)vis_buffer_putshort; | |
| 2104 aworker->input_types[0] = BUILTIN_TYPE_BUFFER; | |
| 2105 aworker->input_types[1] = BUILTIN_TYPE_WHOLE; | |
| 2106 | |
| 2107 aworker = create_worker(prog, "Write Word@Buffer", 2, 1, WORKER_TYPE); | |
| 2108 aworker->implement_func=(custom_worker *)vis_buffer_writeshort; | |
| 2109 aworker->input_types[0] = BUILTIN_TYPE_BUFFER; | |
| 2110 aworker->input_types[1] = BUILTIN_TYPE_WHOLE; | |
| 2111 | |
| 2112 aworker = create_worker(prog, "Put Long@Buffer", 2, 1, WORKER_TYPE); | |
| 2113 aworker->implement_func=(custom_worker *)vis_buffer_putlong; | |
| 2114 aworker->input_types[0] = BUILTIN_TYPE_BUFFER; | |
| 2115 aworker->input_types[1] = BUILTIN_TYPE_WHOLE; | |
| 2116 | |
| 2117 aworker = create_worker(prog, "Write Long@Buffer", 2, 1, WORKER_TYPE); | |
| 2118 aworker->implement_func=(custom_worker *)vis_buffer_writelong; | |
| 2119 aworker->input_types[0] = BUILTIN_TYPE_BUFFER; | |
| 2120 aworker->input_types[1] = BUILTIN_TYPE_WHOLE; | |
| 2121 | |
| 2122 aworker = create_worker(prog, "Reset@Buffer", 1, 1, WORKER_TYPE); | |
| 2123 aworker->implement_func=(custom_worker *)vis_buffer_reset; | |
| 2124 aworker->input_types[0] = BUILTIN_TYPE_BUFFER; | |
| 2125 | |
| 2126 #if defined(SEGA) || defined(NINTENDO_DS) | |
| 2127 | |
| 2128 aworker = create_worker(prog, "From Address@Buffer", 2, 1, WORKER_TYPE); | |
| 2129 aworker->implement_func=(custom_worker *)vis_buffer_fromaddress; | |
| 2130 aworker->input_types[0] = BUILTIN_TYPE_WHOLE; | |
| 2131 aworker->input_types[1] = BUILTIN_TYPE_WHOLE; | |
| 2132 #endif //SEGA | |
| 2133 | |
| 2134 create_company(prog, "Blueprint", 4, 0, FALSE); | |
| 2135 | |
| 2136 aworker = create_worker(prog, "New@Blueprint", 1, 1, WORKER_TYPE); | |
| 2137 aworker->implement_func=(custom_worker *)vis_blueprint_new; | |
| 2138 aworker->input_types[0] = BUILTIN_TYPE_STRING; | |
| 2139 | |
| 2140 aworker = create_worker(prog, "Add Field@Blueprint", 3, 1, WORKER_TYPE); | |
| 2141 aworker->implement_func=(custom_worker *)vis_blueprint_addfield; | |
| 2142 aworker->input_types[0] = BUILTIN_TYPE_BLUEPRINT; | |
| 2143 aworker->input_types[1] = BUILTIN_TYPE_STRING; | |
| 2144 aworker->input_types[2] = BUILTIN_TYPE_STRING; | |
| 2145 | |
| 2146 aworker = create_worker(prog, "Name@Blueprint", 1, 1, WORKER_TYPE); | |
| 2147 aworker->implement_func=(custom_worker *)vis_blueprint_name; | |
| 2148 aworker->input_types[0] = BUILTIN_TYPE_BLUEPRINT; | |
| 2149 | |
| 2150 aworker = create_worker(prog, "Get Fields@Blueprint", 1, 1, WORKER_TYPE); | |
| 2151 aworker->implement_func=(custom_worker *)vis_blueprint_getfields; | |
| 2152 aworker->input_types[0] = BUILTIN_TYPE_BLUEPRINT; | |
| 2153 | |
| 2154 aworker = create_worker(prog, "Blueprint Of", 1, 1, WORKER_TYPE); | |
| 2155 aworker->implement_func=(custom_worker *)vis_get_blueprint; | |
| 2156 aworker->input_types[0] = ANY_TYPE; | |
| 2157 | |
| 2158 aworker = create_worker(prog, "Get Field", 2, 2, WORKER_TYPE); | |
| 2159 aworker->implement_func=(custom_worker *)vis_get_field; | |
| 2160 aworker->input_types[0] = ANY_TYPE; | |
| 2161 aworker->input_types[1] = BUILTIN_TYPE_STRING; | |
| 2162 | |
| 2163 aworker = create_worker(prog, "Set Field", 3, 1, WORKER_TYPE); | |
| 2164 aworker->implement_func=(custom_worker *)vis_set_field; | |
| 2165 aworker->input_types[0] = ANY_TYPE; | |
| 2166 aworker->input_types[1] = BUILTIN_TYPE_STRING; | |
| 2167 aworker->input_types[2] = ANY_TYPE; | |
| 2168 | |
| 2169 aworker = create_worker(prog, "New Blueprint@Program", 2, 2, WORKER_TYPE); | |
| 2170 aworker->implement_func=(custom_worker *)vis_program_newblueprint; | |
| 2171 aworker->input_types[0] = BUILTIN_TYPE_PROGRAM; | |
| 2172 aworker->input_types[1] = BUILTIN_TYPE_STRING; | |
| 2173 | |
| 13 | 2174 #ifdef GUI_LIB |
| 0 | 2175 #ifdef SYLLABLE |
| 2176 create_company(prog, "Checkbox", 2, 0, FALSE); | |
| 2177 | |
| 2178 aworker = create_worker(prog, "New@Checkbox", 4, 1, WORKER_TYPE); | |
| 2179 aworker->implement_func=(custom_worker *)vis_checkbox_new; | |
| 2180 aworker->input_types[0] = BUILTIN_TYPE_STRING; | |
| 2181 aworker->input_types[1] = BUILTIN_TYPE_REAL; | |
| 2182 aworker->input_types[2] = BUILTIN_TYPE_REAL; | |
| 2183 aworker->input_types[3] = BUILTIN_TYPE_YESNO; | |
| 2184 | |
| 2185 aworker = create_worker(prog, "Set Handler@Checkbox", 3, 1, WORKER_TYPE); | |
| 2186 aworker->implement_func=(custom_worker *)vis_button_set_handler; | |
| 2187 aworker->input_types[0] = BUILTIN_TYPE_CHECKBOX; | |
| 2188 aworker->input_types[1] = BUILTIN_TYPE_STRING; | |
| 2189 aworker->input_types[2] = BUILTIN_TYPE_WORKER; | |
| 2190 | |
| 2191 create_company(prog, "Dropdown", 4, 0, FALSE); | |
| 2192 | |
| 2193 aworker = create_worker(prog, "New@Dropdown", 3, 1, WORKER_TYPE); | |
| 2194 aworker->implement_func=(custom_worker *)vis_dropdown_new; | |
| 2195 aworker->input_types[0] = BUILTIN_TYPE_LIST; | |
| 2196 aworker->input_types[1] = BUILTIN_TYPE_REAL; | |
| 2197 aworker->input_types[2] = BUILTIN_TYPE_REAL; | |
| 2198 | |
| 2199 aworker = create_worker(prog, "Set Handler@Dropdown", 3, 1, WORKER_TYPE); | |
| 2200 aworker->implement_func=(custom_worker *)vis_button_set_handler; | |
| 2201 aworker->input_types[0] = BUILTIN_TYPE_DROPDOWN; | |
| 2202 aworker->input_types[1] = BUILTIN_TYPE_STRING; | |
| 2203 aworker->input_types[2] = BUILTIN_TYPE_WORKER; | |
| 2204 | |
| 2205 aworker = create_worker(prog, "Set Text@Dropdown", 2, 1, WORKER_TYPE); | |
| 2206 aworker->implement_func=(custom_worker *)vis_dropdown_settext; | |
| 2207 aworker->input_types[0] = BUILTIN_TYPE_DROPDOWN; | |
| 2208 aworker->input_types[1] = BUILTIN_TYPE_STRING; | |
| 2209 | |
| 2210 aworker = create_worker(prog, "Select@Dropdown", 2, 1, WORKER_TYPE); | |
| 2211 aworker->implement_func=(custom_worker *)vis_dropdown_select; | |
| 2212 aworker->input_types[0] = BUILTIN_TYPE_DROPDOWN; | |
| 2213 aworker->input_types[1] = BUILTIN_TYPE_WHOLE; | |
| 2214 #endif | |
| 13 | 2215 #endif |
| 0 | 2216 |
| 2217 /*if(current_def > num_defs) | |
| 2218 num_defs = current_def; | |
| 2219 if(current_company > num_companies) | |
| 2220 num_companies = current_company;*/ | |
| 2221 } | |
| 2222 | |
| 2223 void initworkers(program * prog) | |
| 2224 { | |
| 2225 //num_defs=0; | |
| 2226 //num_companies=0; | |
| 2227 create_worker(prog, "Main", 0, 0, USER_FLAG | WORKER_TYPE); | |
| 2228 | |
| 2229 initpredefworkers(prog); | |
| 2230 | |
| 2231 } | |
| 2232 /* | |
| 2233 void add_if_ready(int workerNum, worker_instance * instance) | |
| 2234 { | |
| 2235 //int i, j, n, old_ready_count; | |
| 2236 BOOL ready=FALSE; | |
| 2237 //int paramstore[32]; | |
| 2238 //int * params = paramstore; | |
| 2239 DEBUGPUTS("add_if_ready\n"); | |
| 2240 if(!instance || !instance->def) | |
| 2241 return; | |
| 2242 VIS_PROFILE_START(PROF_ADDREADY); | |
| 2243 DEBUGPRINTF( "add_if_ready on %s\n", instance->def->implement_func->workerlist[workerNum].name); | |
| 2244 VIS_EnterCriticalSection(instance->workerlist[workerNum].worker_lock); | |
| 2245 ++instance->workerlist[workerNum].ready_count; | |
| 2246 if(instance->workerlist[workerNum].ready_count >= (instance->def->implement_func->workerlist[workerNum].num_inputs + (instance->def->implement_func->workerlist[workerNum].null_input ? 1 : 0))) | |
| 2247 { | |
| 2248 ready = TRUE; | |
| 2249 instance->workerlist[workerNum].ready_count = 0; | |
| 2250 } | |
| 2251 VIS_LeaveCriticalSection(instance->workerlist[workerNum].worker_lock); | |
| 2252 if(ready) | |
| 2253 { | |
| 2254 DEBUGPRINTF("add_queue on %s\n", instance->def->implement_func->workerlist[workerNum].name); | |
| 2255 add_queue(workerNum, instance); | |
| 2256 } | |
| 2257 VIS_PROFILE_END(PROF_ADDREADY); | |
| 2258 }*/ | |
| 2259 #define RETURN_CODE_EXIT 0xABCE1234 | |
| 2260 #define RETURN_CODE_IDLE 0x00BADFAD | |
| 2261 #define RETURN_CODE_NORMAL 0xABBAABBA | |
| 2262 #define RETURN_CODE_PARALLEL 0xC001D00D | |
| 2263 #define GET_OP1(opcode) ((opcode & 0xF0000000) >> 28) | |
| 2264 #define GET_OP2(opcode) ((opcode & 0x0F000000) >> 24) | |
| 2265 #define GET_INST(opcode) ((opcode & 0x00FF0000) >> 16) | |
| 2266 | |
| 2267 #define MOVE_INST 0x00 | |
| 2268 #define ADDREF_INST 0x01 | |
| 2269 #define RELEASE_INST 0x02 | |
| 2270 #define LOAD_INST 0x03 | |
| 2271 #define CALL_INST 0x04 | |
| 2272 #define CALLB_INST 0x05 | |
| 2273 #define CALLP_INST 0x06 | |
| 2274 #define CALLBP_INST 0x07 | |
| 2275 #define RETURN_INST 0x08 | |
| 2276 #define BRANCH_INST 0x09 | |
| 2277 #define BRANCHT_INST 0x0A | |
| 2278 #define BRANCHF_INST 0x0B | |
| 2279 #define WAIT_INST 0x0C | |
| 2280 #define ADD_INST 0x0D | |
| 2281 #define SUB_INST 0x0E | |
| 2282 #define SUBR_INST 0x0F | |
| 2283 #define GREATER_INST 0x10 | |
| 2284 #define LESSER_INST 0x11 | |
| 2285 | |
| 2286 #define REGISTER_BIT 0x8 | |
| 2287 #define NO_OPERAND 0x7 | |
| 2288 #define OP_REG_MASK 0x7 | |
| 2289 #define GET_REGNUM1(opcode) ((opcode & 0x0000FF00) >> 8) | |
| 2290 #define GET_REGNUM2(opcode) (opcode & 0x000000FF) | |
| 2291 | |
| 2292 #define REG_DIRECT 0 | |
| 2293 #define REG_INDIRECT 1 | |
| 2294 #define IMMED_8 2 | |
| 2295 #define IMMED_32 3 | |
| 2296 #define STACK_8 4 | |
| 2297 #define REG_REL_32 5 | |
| 2298 #define PC_REL_8 6 | |
| 2299 | |
| 2300 #define STACK_REG 31 | |
| 2301 #define PC_REG 30 | |
| 2302 | |
| 2303 #define OPC(inst, op1, reg1, op2, reg2) ((op1 << 28) | (op2 << 24) | (inst << 16) | ((reg1 & 0xff) << 8) | (reg2 & 0xFF)) | |
| 2304 | |
| 2305 //unsigned long test_program[] = | |
| 2306 //{ | |
| 2307 // OPC(LOAD_INST, PC_REL_8, 8 /* Hi */, REG_DIRECT, 0), | |
| 2308 // OPC(CALLB_INST, IMMED_8, 1/* Print */, NO_OPERAND, 0), | |
| 2309 // OPC(RETURN_INST, NO_OPERAND, 0, NO_OPERAND, 0), | |
| 2310 // 26952//Hi | |
| 2311 //}; | |
| 2312 | |
| 2313 unsigned long test_program[] = | |
| 2314 { | |
| 2315 //Main: | |
| 2316 OPC(LOAD_INST, PC_REL_8, 20/* 10 */, REG_DIRECT, 0), | |
| 2317 OPC(LOAD_INST, PC_REL_8, 20/* 2 */, PC_REL_8, 28), | |
| 2318 OPC(LOAD_INST, PC_REL_8, 20/* 1 */, PC_REL_8, 28), | |
| 2319 OPC(CALL_INST, PC_REL_8, 28/* Fib: */, NO_OPERAND, 0), | |
| 2320 OPC(CALLB_INST, IMMED_8, 1/* Print */, NO_OPERAND, 0), | |
| 2321 OPC(RETURN_INST, NO_OPERAND, 0, NO_OPERAND, 0), | |
| 2322 0x3033,//'30' | |
| 2323 0x32,//'2' | |
| 2324 0x31,//'1' | |
| 2325 0,//2 storage | |
| 2326 0,//1 storage | |
| 2327 //Fib: | |
| 2328 OPC(ADD_INST, IMMED_8, 8, REG_DIRECT, STACK_REG), | |
| 2329 OPC(MOVE_INST, REG_DIRECT, 0, STACK_8, -4), | |
| 2330 OPC(ADDREF_INST, REG_INDIRECT, 0, NO_OPERAND, 0), | |
| 2331 OPC(ADDREF_INST, REG_INDIRECT, 0, NO_OPERAND, 0), | |
| 2332 OPC(MOVE_INST, PC_REL_8, -28/* 2 */, REG_DIRECT, 1), | |
| 2333 OPC(ADDREF_INST, REG_INDIRECT, 1, NO_OPERAND, 0), | |
| 2334 OPC(CALLB_INST, IMMED_8, 8/* < */, NO_OPERAND, 0), | |
| 2335 OPC(CALLB_INST, IMMED_8, 11/* If */, NO_OPERAND, 0), | |
| 2336 OPC(BRANCHT_INST, PC_REL_8, 64/* _Base */, REG_DIRECT, 0), | |
| 2337 | |
| 2338 OPC(RELEASE_INST, REG_INDIRECT, 1, NO_OPERAND, 0), | |
| 2339 OPC(MOVE_INST, STACK_8, -4, REG_DIRECT, 0), | |
| 2340 OPC(MOVE_INST, PC_REL_8, -56/* 2 */, REG_DIRECT, 1), | |
| 2341 OPC(ADDREF_INST, REG_INDIRECT, 1, NO_OPERAND, 0), | |
| 2342 OPC(CALLB_INST, IMMED_8, 6/* - */, NO_OPERAND, 0), | |
| 2343 OPC(CALL_INST, PC_REL_8, -60/* Fib */, NO_OPERAND, 0), | |
| 2344 OPC(MOVE_INST, REG_DIRECT, 0, STACK_8, -8), | |
| 2345 OPC(MOVE_INST, STACK_8, -4, REG_DIRECT, 0), | |
| 2346 OPC(MOVE_INST, PC_REL_8, -76/* 1 */, REG_DIRECT, 1), | |
| 2347 OPC(ADDREF_INST, REG_INDIRECT, 1, NO_OPERAND, 0), | |
| 2348 OPC(CALLB_INST, IMMED_8, 6/* - */, NO_OPERAND, 0), | |
| 2349 OPC(CALL_INST, PC_REL_8, -84/* Fib */, NO_OPERAND, 0), | |
| 2350 OPC(MOVE_INST, STACK_8, -8, REG_DIRECT, 1), | |
| 2351 OPC(CALLB_INST, IMMED_8, 5/* + */, NO_OPERAND, 0), | |
| 2352 OPC(SUBR_INST, IMMED_8, 8, REG_DIRECT, STACK_REG), | |
| 2353 OPC(RETURN_INST, NO_OPERAND, 0, NO_OPERAND, 0), | |
| 2354 //_Base: | |
| 2355 OPC(RELEASE_INST, REG_INDIRECT, 0, NO_OPERAND, 0), | |
| 2356 OPC(MOVE_INST, PC_REL_8, -112/* 1 */, REG_DIRECT, 0), | |
| 2357 OPC(ADDREF_INST, REG_INDIRECT, 0, NO_OPERAND, 0), | |
| 2358 OPC(SUBR_INST, IMMED_8, 8, REG_DIRECT, STACK_REG), | |
| 2359 OPC(RETURN_INST, NO_OPERAND, 0, NO_OPERAND, 0), | |
| 2360 | |
| 2361 }; | |
| 2362 | |
| 2363 unsigned long * get_effective_address(char op, unsigned short regnum, unsigned long ** pc, unsigned long * registers, unsigned long * immed) | |
| 2364 { | |
| 2365 unsigned long * add = NULL; | |
| 2366 unsigned long work; | |
| 2367 if(op != NO_OPERAND) | |
| 2368 { | |
| 2369 if(op & REGISTER_BIT) | |
| 2370 add = (unsigned long *)(registers[regnum] + registers[op & OP_REG_MASK]); | |
| 2371 else | |
| 2372 { | |
| 2373 switch(op) | |
| 2374 { | |
| 2375 case REG_DIRECT: | |
| 2376 add = registers + regnum; | |
| 2377 break; | |
| 2378 case REG_INDIRECT: | |
| 2379 add = (unsigned long *) registers[regnum]; | |
| 2380 break; | |
| 2381 case IMMED_8: | |
| 2382 *immed = (char)regnum; | |
| 2383 add = (unsigned long *)immed; | |
| 2384 break; | |
| 2385 case IMMED_32: | |
| 2386 *immed = *((*pc)++); | |
| 2387 add = (unsigned long *)immed; | |
| 2388 break; | |
| 2389 case STACK_8: | |
| 2390 work = (char)regnum; | |
| 2391 add = (unsigned long *)(registers[STACK_REG] + work); | |
| 2392 break; | |
| 2393 case REG_REL_32: | |
| 2394 work = *((*pc)++); | |
| 2395 add = (unsigned long *)(registers[regnum] + work); | |
| 2396 break; | |
| 2397 case PC_REL_8: | |
| 2398 work = (char)regnum; | |
| 2399 add = (unsigned long *)(registers[PC_REG] + work); | |
| 2400 break; | |
| 2401 default: | |
| 2402 break; | |
| 2403 } | |
| 2404 } | |
| 2405 } | |
| 2406 return add; | |
| 2407 } | |
| 2408 | |
| 2409 DWORD WINAPI virtual_processor(unsigned long * program, BOOL main) | |
| 2410 { | |
| 2411 int i; | |
| 2412 unsigned long **pc; | |
| 2413 unsigned long **stack; | |
| 2414 unsigned long registers[32]; | |
| 2415 unsigned long opcode; | |
| 2416 unsigned long extra, extra2; | |
| 2417 queue_entry entry; | |
| 2418 stack_segment initial_stack; | |
| 2419 stack_segment * current = &initial_stack; | |
| 2420 char slot_usage[7]; | |
| 2421 char op1, op2; | |
| 2422 char inst; | |
| 2423 unsigned long *add1, *add2; | |
| 2424 long immed1, immed2; | |
| 2425 initial_stack.size = MIN_STACK_SIZE; | |
| 2426 initial_stack.parent = initial_stack.child = NULL; | |
| 2427 initial_stack.data[0] = main ? RETURN_CODE_EXIT : RETURN_CODE_IDLE; | |
| 2428 pc = (unsigned long **)(&(registers[PC_REG])); | |
| 2429 stack = (unsigned long **)(&(registers[STACK_REG])); | |
| 2430 *pc = program; | |
| 2431 *stack = (unsigned long *)(initial_stack.data + 1); | |
| 2432 entry.instance = NULL; | |
| 2433 entry.worker_num = 0; | |
| 2434 DEBUGPRINTF("Virtual processor, Program start: %X\n", program); | |
| 2435 #ifdef ENABLE_PROFILING | |
| 2436 for(i = 0; i < NUM_PROFS; ++i) | |
| 2437 { | |
| 2438 vis_profile_running_total[i] = 0; | |
| 2439 vis_profile_counts[i] = 0; | |
| 2440 } | |
| 2441 VIS_PROFILE_START(PROF_EMPTYFUNC); | |
| 2442 empty_test(NULL,NULL); | |
| 2443 VIS_PROFILE_END(PROF_EMPTYFUNC); | |
| 2444 VIS_PROFILE_START(PROF_NOCODE); | |
| 2445 VIS_PROFILE_END(PROF_NOCODE); | |
| 2446 #endif | |
| 2447 while(execute_active) | |
| 2448 { | |
| 2449 VIS_PROFILE_START(PROF_VIRTUAL_DECODE); | |
| 2450 DEBUGPRINTF("PC: %X\n", *pc); | |
| 2451 opcode = *((*pc)++); | |
| 2452 op1 = GET_OP1(opcode); | |
| 2453 op2 = GET_OP2(opcode); | |
| 2454 add1 = get_effective_address(op1, GET_REGNUM1(opcode), pc, registers, &immed1); | |
| 2455 add2 = get_effective_address(op2, GET_REGNUM2(opcode), pc, registers, &immed2); | |
| 2456 DEBUGPRINTF("Opcode: %X, Instruction: %X, op1 %X, op2 %X\n", opcode, GET_INST(opcode), op1, op2); | |
| 2457 inst = GET_INST(opcode); | |
| 2458 VIS_PROFILE_END(PROF_VIRTUAL_DECODE); | |
| 2459 VIS_PROFILE_START(PROF_VIRTUAL_EXECUTE); | |
| 2460 switch(inst) | |
| 2461 { | |
| 2462 case MOVE_INST: | |
| 2463 *add2 = *add1; | |
| 2464 break; | |
| 2465 case ADDREF_INST: | |
| 2466 add_ref((datum *)add1); | |
| 2467 break; | |
| 2468 case RELEASE_INST: | |
| 2469 release_ref((datum *)add1); | |
| 2470 break; | |
| 2471 /* | |
| 2472 Temporarily commented out until multiple program support is finished | |
| 2473 case LOAD_INST: | |
| 2474 *add2 = (long)get_constant((char *)add1, -1); | |
| 2475 break; | |
| 2476 */ | |
| 2477 case CALL_INST: | |
| 2478 *((*stack)++) = (unsigned long)*pc; | |
| 2479 *((*stack)++) = RETURN_CODE_NORMAL; | |
| 2480 *pc = add1; | |
| 2481 break; | |
| 2482 /* | |
| 2483 Temporarily commented out until multiple program support is finished | |
| 2484 case CALLB_INST: | |
| 2485 //TODO: Needs to be made 100% correct | |
| 2486 DEBUGPRINTF("Calling builtin: %s\n", deflist[*add1].name); | |
| 2487 execute_def(deflist + *add1, entry, (datum **)registers, NULL); | |
| 2488 break;*/ | |
| 2489 case CALLP_INST: | |
| 2490 //TODO Implement me | |
| 2491 break; | |
| 2492 case CALLBP_INST: | |
| 2493 //TODO Implement me | |
| 2494 break; | |
| 2495 case RETURN_INST: | |
| 2496 switch(*(--(*stack))) | |
| 2497 { | |
| 2498 case RETURN_CODE_EXIT: | |
| 2499 execute_active = FALSE; | |
| 2500 break; | |
| 2501 case RETURN_CODE_IDLE: | |
| 2502 //TODO: Implement me | |
| 2503 break; | |
| 2504 case RETURN_CODE_NORMAL: | |
| 2505 *pc = (unsigned long *)*(--(*stack)); | |
| 2506 break; | |
| 2507 default: | |
| 2508 break; | |
| 2509 } | |
| 2510 break; | |
| 2511 case BRANCH_INST: | |
| 2512 *pc = add1; | |
| 2513 break; | |
| 2514 case BRANCHT_INST: | |
| 2515 if(*add2) | |
| 2516 *pc = add1; | |
| 2517 break; | |
| 2518 case BRANCHF_INST: | |
| 2519 if(!*add2) | |
| 2520 *pc = add1; | |
| 2521 break; | |
| 2522 case WAIT_INST: | |
| 2523 //TODO: Implement Me | |
| 2524 break; | |
| 2525 case ADD_INST: | |
| 2526 *add2 = *add1 + *add2; | |
| 2527 break; | |
| 2528 case SUB_INST: | |
| 2529 *add2 = *add1 - *add2; | |
| 2530 break; | |
| 2531 case SUBR_INST: | |
| 2532 *add2 = *add2 - *add1; | |
| 2533 break; | |
| 2534 case GREATER_INST: | |
| 2535 *add2 = *add1 > *add2; | |
| 2536 break; | |
| 2537 case LESSER_INST: | |
| 2538 *add2 = *add1 < *add2; | |
| 2539 break; | |
| 2540 default: | |
| 2541 break; | |
| 2542 } | |
| 2543 VIS_PROFILE_END(PROF_VIRTUAL_EXECUTE); | |
| 2544 } | |
| 2545 #ifdef ENABLE_PROFILING | |
| 2546 for(i = 0; i < NUM_PROFS; ++i) | |
| 2547 printf("%d:\t%f,\tcount: %d,\taverage: %f\n", i, (double)vis_profile_running_total[i], vis_profile_counts[i], ((double)vis_profile_running_total[i])/((double)vis_profile_counts[i])); | |
| 2548 #endif | |
| 2549 return 0; | |
| 2550 } | |
| 2551 | |
| 2552 void test_virtual() | |
| 2553 { | |
| 2554 // int i,j,k; | |
| 2555 program * prog = new_program(START_DEF_STORAGE, START_COMP_STORAGE); | |
| 2556 initpredefworkers(prog); | |
| 2557 init_sync_primitives(); | |
| 2558 init_datum_storage(); | |
| 2559 //TODO Uncomment me | |
| 2560 // init_global_storage(); | |
| 2561 execute_active = TRUE; | |
| 2562 /* for(i = MOVE_INST; i <= LESSER_INST; ++i) | |
| 2563 { | |
| 2564 for(j = 0; j < 0x10; ++j) | |
| 2565 { | |
| 2566 for(k = 0; k < 0x10; ++k) | |
| 2567 { | |
| 2568 DEBUGPRINTF("i: %X, j: %X, k: %X, OPC: %X\n", i, j, k, OPC(i, j, j, k, k)); | |
| 2569 } | |
| 2570 } | |
| 2571 }*/ | |
| 2572 virtual_processor(test_program, TRUE); | |
| 2573 } | |
| 2574 | |
| 2575 DWORD WINAPI worker_thread(LPVOID param) | |
| 2576 { | |
| 2577 queue_entry aworker; | |
| 2578 int temp_queue_len; | |
| 2579 while(execute_active) | |
| 2580 { | |
| 2581 VIS_PROFILE_START(PROF_WORKER_THREAD); | |
| 2582 #ifdef NINTENDO_DS | |
| 2583 if(irq_queue_count > 0) | |
| 2584 run_queued_irqs(); | |
| 2585 #endif | |
| 2586 //DEBUGPUTS("Before WaitForSingleObect\n"); | |
| 2587 /*VIS_EnterCriticalSection(worker_queue_lock); | |
| 2588 temp_queue_len = queue_len; | |
| 2589 VIS_LeaveCriticalSection(worker_queue_lock);*/ | |
| 2590 //DEBUGPUTS("After WaitForSingleObject\n"); | |
| 2591 aworker = get_queue(); | |
| 2592 //DEBUGPUTS("After get_queue()\n"); | |
| 2593 //while(execute_active && aworker.worker_num < 0)//temp_queue_len == 0 && execute_active) | |
| 2594 //{ | |
| 2595 // VIS_WaitEvent(queue_add_event); | |
| 2596 // aworker = get_queue(); | |
| 2597 /*#if COMPILE_THREADS > 0 | |
| 2598 #ifdef WIN32 | |
| 2599 Sleep(0); | |
| 2600 #else | |
| 2601 sleep(0); | |
| 2602 #endif | |
| 2603 #endif | |
| 2604 VIS_EnterCriticalSection(worker_queue_lock); | |
| 2605 temp_queue_len = queue_len; | |
| 2606 VIS_LeaveCriticalSection(worker_queue_lock);*/ | |
| 2607 //} | |
| 2608 | |
| 2609 if(aworker.worker_num >= 0) | |
| 2610 { | |
| 2611 //DEBUGPUTS("Before EnterCriticalSection\n"); | |
| 2612 | |
| 2613 /* VIS_EnterCriticalSection(worker_queue_lock); | |
| 2614 if(queue_len > 0) | |
| 2615 { | |
| 2616 DEBUGPUTS("SetEvent\n"); | |
| 2617 VIS_SetEvent(queue_add_event); | |
| 2618 } | |
| 2619 VIS_LeaveCriticalSection(worker_queue_lock);*/ | |
| 2620 DEBUGPRINTF( "\nExecuting: %s<%d>, Instance: %X\n", aworker.instance->def->implement_func->workerlist[aworker.worker_num].name,aworker.worker_num,aworker.instance); | |
| 2621 | |
| 2622 if(process_worker(aworker) == 0) | |
| 2623 { | |
| 2624 //worker_complete(aworker); | |
| 2625 cleanup_check(aworker); | |
| 2626 //DEBUGPUTS("After cleanup_check\n"); | |
| 2627 | |
| 2628 } | |
| 2629 | |
| 2630 } | |
| 2631 VIS_PROFILE_END(PROF_WORKER_THREAD); | |
| 2632 } | |
| 2633 VIS_SetEvent(queue_add_event); | |
| 2634 return 0; | |
| 2635 } | |
| 2636 | |
| 2637 int set_comp_room(datum ** params, int room_index, queue_entry * entry, program * prog) | |
| 2638 { | |
| 2639 int i; | |
| 2640 char * data; | |
| 2641 //DEBUGPRINTF("params[0]->ref_count: %d\n", params[0]->ref_count); | |
| 2642 params[0] = copy_datum(params[0], 0); | |
| 2643 data = ((char *)(params[0]->c.generic.data) + (int)params[0]->company->room_list[room_index].set_func); | |
| 2644 DEBUGPRINTF("Set comp room: c.generic.data = %X, +get_func = %X\n", params[0]->c.generic.data, data); | |
| 2645 //TODO: input conversion | |
| 2646 switch(params[0]->company->room_list[room_index].get_func_type) | |
| 2647 { | |
| 2648 case ROOM_BYTE: | |
| 2649 *data = params[1]->c.integers.num_a; | |
| 2650 release_ref(params[1]); | |
| 2651 break; | |
| 2652 case ROOM_SHORT: | |
| 2653 *((short *)data) = params[1]->c.integers.num_a; | |
| 2654 release_ref(params[1]); | |
| 2655 break; | |
| 2656 case ROOM_LONG: | |
| 2657 *((long *)data) = params[1]->c.integers.num_a; | |
| 2658 release_ref(params[1]); | |
| 2659 break; | |
| 2660 case ROOM_SINGLE: | |
| 2661 *((float *)data) = params[1]->c.real; | |
| 2662 release_ref(params[1]); | |
| 2663 break; | |
| 2664 case ROOM_DOUBLE: | |
| 2665 *((double *)data) = params[1]->c.real; | |
| 2666 release_ref(params[1]); | |
| 2667 break; | |
| 2668 case ROOM_VIS_REF: | |
| 2669 release_ref(*((datum **)data)); | |
| 2670 *((datum **)data) = params[1]; | |
| 2671 break; | |
| 2672 case ROOM_CSTRING: //not implemented | |
| 2673 case ROOM_CSTRING_STRUCT: | |
| 2674 case ROOM_PSTRING: | |
| 2675 case ROOM_PSTRING_STRUCT: | |
| 2676 case ROOM_WORKER://not implemented | |
| 2677 case ROOM_VIS_OBJECT://not implemented | |
| 2678 default: | |
| 2679 release_ref(params[0]); | |
| 2680 release_ref(params[1]); | |
| 2681 params[0] = params[1] = NULL; | |
| 2682 puts("unimplemented company room type\n"); | |
| 2683 break; | |
| 2684 } | |
| 2685 return 0; | |
| 2686 } | |
| 2687 | |
| 2688 int set_comp_room_by_name(datum ** company, char * name, int * room_index_ret, queue_entry * entry, program * prog) | |
| 2689 { | |
| 2690 int i; | |
| 2691 for (i = 0; i < company[0]->company->num_rooms; ++i) | |
| 2692 if(!strcmp(name,company[0]->company->room_list[i].name)) | |
| 2693 { | |
| 2694 if(room_index_ret) | |
| 2695 *room_index_ret = i; | |
| 2696 return set_comp_room(company, i, entry, prog); | |
| 2697 } | |
| 2698 if(room_index_ret) | |
| 2699 *room_index_ret = -1; | |
| 2700 return -1; | |
| 2701 } | |
| 2702 | |
| 2703 int get_comp_room(datum ** company, int room_index, queue_entry * entry, program * prog) | |
| 2704 { | |
| 2705 int i; | |
| 2706 datum * out; | |
| 2707 queue_entry empty; | |
| 2708 char * data = ((char *)(company[0]->c.generic.data) + (int)company[0]->company->room_list[room_index].get_func); | |
| 2709 company[1] = NULL; | |
| 2710 DEBUGPRINTF("Get comp room: c.generic.data = %X, +get_func = %X\n", company[0]->c.generic.data, data); | |
| 2711 switch(company[0]->company->room_list[room_index].get_func_type) | |
| 2712 { | |
| 2713 case ROOM_BYTE: | |
| 2714 out = new_datum(BUILTIN_TYPE_WHOLE, 2, 0, prog); | |
| 2715 out->c.integers.num_a = *data; | |
| 2716 break; | |
| 2717 case ROOM_SHORT: | |
| 2718 out = new_datum(BUILTIN_TYPE_WHOLE, 2, 0, prog); | |
| 2719 out->c.integers.num_a = *((short *)data); | |
| 2720 break; | |
| 2721 case ROOM_LONG: | |
| 2722 out = new_datum(BUILTIN_TYPE_WHOLE, 2, 0, prog); | |
| 2723 out->c.integers.num_a = *((long *)data); | |
| 2724 break; | |
| 2725 case ROOM_SINGLE: | |
| 2726 out = new_datum(BUILTIN_TYPE_REAL, 3, 0, prog); | |
| 2727 out->c.real = *((float *)data); | |
| 2728 break; | |
| 2729 case ROOM_DOUBLE: | |
| 2730 out = new_datum(BUILTIN_TYPE_REAL, 3, 0, prog); | |
| 2731 out->c.real = *((double *)data); | |
| 2732 break; | |
| 2733 case ROOM_CSTRING: | |
| 2734 data = *((char **)data); | |
| 2735 case ROOM_CSTRING_STRUCT: | |
| 2736 out = new_datum(BUILTIN_TYPE_STRING, 1, strlen(data)+1, prog); | |
| 2737 strcpy(out->c.generic.data, data); | |
| 2738 break; | |
| 2739 case ROOM_PSTRING: | |
| 2740 data = *((char **)data); | |
| 2741 case ROOM_PSTRING_STRUCT: | |
| 2742 out = new_datum(BUILTIN_TYPE_STRING, 1, *((unsigned char *)data), prog); | |
| 2743 memcpy(out->c.generic.data, data, *((unsigned char *)data)); | |
| 2744 ((char *)out->c.generic.data)[*((unsigned char *)data)] = '\0'; | |
| 2745 break; | |
| 2746 case ROOM_VIS_REF: | |
| 2747 out = add_ref(*((datum **)data)); | |
| 2748 if(!out) { | |
| 2749 company[1] = company[0]; | |
| 2750 company[0] = NULL; | |
| 2751 } | |
| 2752 break; | |
| 2753 case ROOM_WORKER: | |
| 2754 if(entry) | |
| 2755 return execute_def((worker_def *)(company[0]->company->room_list[room_index].get_func), *entry, company, sub_callback); | |
| 2756 else | |
| 2757 { | |
| 2758 empty.instance = NULL; | |
| 2759 empty.worker_num = -1; | |
| 2760 return execute_def((worker_def *)(company[0]->company->room_list[room_index].get_func), empty, company, sub_callback); | |
| 2761 } | |
| 2762 case ROOM_VIS_OBJECT://not implemented | |
| 2763 default: | |
| 2764 out = NULL; | |
| 2765 puts("unimplemented company room type\n"); | |
| 2766 break; | |
| 2767 } | |
| 2768 release_ref(company[0]); | |
| 2769 company[0] = out; | |
| 2770 return 0; | |
| 2771 } | |
| 2772 | |
| 2773 int get_comp_room_by_name(datum ** company, char * name, int * room_index_ret, queue_entry * entry, program * prog) | |
| 2774 { | |
| 2775 int i; | |
| 2776 for (i = 0; i < company[0]->company->num_rooms; ++i) | |
| 2777 if(!strcmp(name,company[0]->company->room_list[i].name)) | |
| 2778 { | |
| 2779 if(room_index_ret) | |
| 2780 *room_index_ret = i; | |
| 2781 return get_comp_room(company, i, entry, prog); | |
| 2782 } | |
| 2783 if(room_index_ret) | |
| 2784 *room_index_ret = -1; | |
| 2785 return -1; | |
| 2786 } | |
| 2787 | |
| 2788 datum * literal_string(char * value, int len, program * prog) | |
| 2789 { | |
| 2790 char literalchar; | |
| 2791 BOOL literal; | |
| 2792 int i, bufpos, lenstr; | |
| 2793 datum * returnval; | |
| 2794 | |
| 2795 if(len < 0) { | |
| 2796 len = strlen(value); | |
| 2797 } | |
| 2798 | |
| 2799 literal = FALSE; | |
| 2800 lenstr = 0; | |
| 2801 for(i = 0; i < len; ++i) | |
| 2802 if(literal) | |
| 2803 literal = FALSE; | |
| 2804 else | |
| 2805 { | |
| 2806 ++lenstr; | |
| 2807 if(value[i] == '\\') | |
| 2808 literal = TRUE; | |
| 2809 } | |
| 2810 //DEBUGPRINTF("Allocating %d bytes for string constant\n", lenstr+1); | |
| 2811 returnval = new_datum(BUILTIN_TYPE_STRING, 1, lenstr+1, prog); | |
| 2812 bufpos = 0; | |
| 2813 for(i = 0; i < len; ++i) | |
| 2814 { | |
| 2815 if(literal) | |
| 2816 { | |
| 2817 literal = FALSE; | |
| 2818 switch(value[i]) | |
| 2819 { | |
| 2820 case 'n': //newline | |
| 2821 literalchar = '\n'; | |
| 2822 break; | |
| 2823 case 'r': //carriage return | |
| 2824 literalchar = '\r'; | |
| 2825 break; | |
| 2826 case 't': // tab | |
| 2827 literalchar = '\t'; | |
| 2828 break; | |
| 2829 case '0': //NULL | |
| 2830 literalchar = '\0'; | |
| 2831 break; | |
| 2832 default: | |
| 2833 literalchar = value[i]; | |
| 2834 break; | |
| 2835 } | |
| 2836 ((char *)returnval->c.generic.data)[bufpos++] = literalchar; | |
| 2837 } | |
| 2838 else | |
| 2839 { | |
| 2840 if(value[i] == '\\') | |
| 2841 literal = TRUE; | |
| 2842 else | |
| 2843 { | |
| 2844 ((char *)returnval->c.generic.data)[bufpos++] = value[i]; | |
| 2845 } | |
| 2846 } | |
| 2847 } | |
| 2848 //DEBUGPRINTF("bufpos: %d\n", bufpos); | |
| 2849 ((char *)returnval->c.generic.data)[bufpos] = '\0'; | |
| 2850 DEBUGPUTS("Constant Type: String\n"); | |
| 2851 return returnval; | |
| 2852 } | |
| 2853 | |
| 2854 datum * get_constant(char * value, int len, program * prog) | |
| 2855 { | |
| 2856 datum * params[2]; | |
| 2857 datum * returnval; | |
| 2858 int i = 0,bufpos; | |
| 2859 int start; | |
| 2860 int lenstr; | |
| 2861 int leftcurly; | |
| 2862 int dotcount = 0; | |
| 2863 char literalchar; | |
| 2864 unsigned short const_type = ANY_TYPE; | |
| 2865 BOOL literal; | |
| 2866 if((len == 3 && memcmp(value, "Yes", len) == 0) || (len < 0 && strcmp(value, "Yes") == 0)) | |
| 2867 { | |
| 2868 DEBUGPUTS("Constnat: Yes\n"); | |
| 2869 returnval = new_datum(BUILTIN_TYPE_YESNO, 2, 0, prog); | |
| 2870 returnval->c.integers.num_a = 1; | |
| 2871 DEBUGPRINTF("Company: %s, integers.num_a: %d\n", returnval->company->name, returnval->c.integers.num_a); | |
| 2872 return returnval; | |
| 2873 } | |
| 2874 else if((len == 2 && memcmp(value, "No", len) == 0) || (len < 0 && strcmp(value, "No") == 0)) | |
| 2875 { | |
| 2876 DEBUGPUTS("Constant: No\n"); | |
| 2877 returnval = new_datum(BUILTIN_TYPE_YESNO, 2, 0, prog); | |
| 2878 returnval->c.integers.num_a = 0; | |
| 2879 DEBUGPRINTF("Company: %s, integers.num_a: %d\n", returnval->company->name, returnval->c.integers.num_a); | |
| 2880 return returnval; | |
| 2881 } | |
| 2882 if(value[0] == '{') | |
| 2883 { | |
| 2884 DEBUGPUTS("Constant type: List"); | |
| 2885 params[0] = create_list(prog); | |
| 2886 i = start = 1; | |
| 2887 literal = FALSE; | |
| 2888 leftcurly = 0; | |
| 2889 for(;value[i] != 0 && (len < 0 || i < len); ++i) | |
| 2890 { | |
| 2891 if(literal) | |
| 2892 literal = FALSE; | |
| 2893 else | |
| 2894 { | |
| 2895 if(value[i] == '\\') | |
| 2896 literal = TRUE; | |
| 2897 else if(value[i] == '}') | |
| 2898 if(leftcurly) | |
| 2899 --leftcurly; | |
| 2900 else | |
| 2901 break; | |
| 2902 else if(value[i] == '{') | |
| 2903 ++leftcurly; | |
| 2904 else if(value[i] == ',' && !leftcurly) | |
| 2905 { | |
| 2906 params[1] = get_constant(value+start, i-start, prog); | |
| 2907 vis_list_append(params, NULL); | |
| 2908 start = i+1; | |
| 2909 } | |
| 2910 } | |
| 2911 } | |
| 2912 params[1]= get_constant(value+start, i-start, prog); | |
| 2913 vis_list_append(params, NULL); | |
| 2914 returnval = params[0]; | |
| 2915 } | |
| 2916 else if(value[0] == '"') | |
| 2917 { | |
| 2918 if(len < 0) { | |
| 2919 len = strlen(value); | |
| 2920 } | |
| 2921 len -= 2; | |
| 2922 returnval = literal_string(value+1, len, prog); | |
| 2923 | |
| 2924 } | |
| 2925 else | |
| 2926 { | |
| 2927 while(value[i] != 0 && (len < 0 || i < len)) | |
| 2928 { | |
| 2929 if(value[i] >= '0' && value[i] <= '9') | |
| 2930 { | |
| 2931 if(const_type == ANY_TYPE) | |
| 2932 const_type = BUILTIN_TYPE_WHOLE; | |
| 2933 } | |
| 2934 else if(value[i] == '.') | |
| 2935 { | |
| 2936 if(dotcount) | |
| 2937 { | |
| 2938 const_type = BUILTIN_TYPE_STRING; | |
| 2939 } | |
| 2940 else | |
| 2941 { | |
| 2942 ++dotcount; | |
| 2943 if(const_type == BUILTIN_TYPE_WHOLE) | |
| 2944 const_type = BUILTIN_TYPE_REAL; | |
| 2945 } | |
| 2946 } | |
| 2947 else | |
| 2948 { | |
| 2949 //DEBUGPRINTF("Current character: %c resulted in String\n", value[i]); | |
| 2950 const_type = BUILTIN_TYPE_STRING; | |
| 2951 break; | |
| 2952 } | |
| 2953 ++i; | |
| 2954 } | |
| 2955 | |
| 2956 if(const_type == BUILTIN_TYPE_WHOLE) | |
| 2957 { | |
| 2958 returnval = new_datum(const_type, 2, 0, prog); | |
| 2959 returnval->c.integers.num_a = atol(value); | |
| 2960 DEBUGPUTS("Constant Type: Whole Number\n"); | |
| 2961 } | |
| 2962 else if(const_type == BUILTIN_TYPE_REAL) | |
| 2963 { | |
| 2964 returnval = new_datum(const_type, 3, 0, prog); | |
| 2965 returnval->c.real = atof(value); | |
| 2966 DEBUGPUTS("Constant Type: Real Number\n"); | |
| 2967 } | |
| 2968 else | |
| 2969 { | |
| 2970 /* literal = FALSE; | |
| 2971 lenstr = 0; | |
| 2972 for(i = 0; (i < len || len < 0) && value[i] != 0; ++i) | |
| 2973 if(literal) | |
| 2974 literal = FALSE; | |
| 2975 else | |
| 2976 { | |
| 2977 ++lenstr; | |
| 2978 if(value[i] == '\\') | |
| 2979 literal = TRUE; | |
| 2980 } | |
| 2981 DEBUGPRINTF("Allocating %d bytes for string constant\n", lenstr+1); | |
| 2982 returnval = new_datum(BUILTIN_TYPE_STRING, 1, lenstr+1, prog); | |
| 2983 bufpos = 0; | |
| 2984 for(i = 0; (i < len || len < 0) && value[i] != 0; ++i) | |
| 2985 { | |
| 2986 DEBUGPRINTF("bufpos: %d\n", bufpos); | |
| 2987 if(literal) | |
| 2988 { | |
| 2989 literal = FALSE; | |
| 2990 switch(value[i]) | |
| 2991 { | |
| 2992 case 'n': //newline | |
| 2993 literalchar = '\n'; | |
| 2994 break; | |
| 2995 case 'r': //carriage return | |
| 2996 literalchar = '\r'; | |
| 2997 break; | |
| 2998 case 't': // tab | |
| 2999 literalchar = '\t'; | |
| 3000 break; | |
| 3001 case '0': //NULL | |
| 3002 literalchar = '\0'; | |
| 3003 break; | |
| 3004 default: | |
| 3005 literalchar = value[i]; | |
| 3006 break; | |
| 3007 } | |
| 3008 ((char *)returnval->c.generic.data)[bufpos++] = literalchar; | |
| 3009 } | |
| 3010 else | |
| 3011 { | |
| 3012 if(value[i] == '\\') | |
| 3013 literal = TRUE; | |
| 3014 else | |
| 3015 { | |
| 3016 ((char *)returnval->c.generic.data)[bufpos++] = value[i]; | |
| 3017 } | |
| 3018 } | |
| 3019 } | |
| 3020 DEBUGPRINTF("bufpos: %d\n", bufpos); | |
| 3021 ((char *)returnval->c.generic.data)[bufpos] = '\0'; | |
| 3022 DEBUGPUTS("Constant Type: String\n"); */ | |
| 3023 returnval = literal_string(value, len, prog); | |
| 3024 } | |
| 3025 } | |
| 3026 return returnval; | |
| 3027 } | |
| 3028 | |
| 3029 int execute_def(worker_def * process_def, queue_entry worker_entry, datum ** params, instance_callback callback) | |
| 3030 { | |
| 3031 return execute_def_type(process_def, worker_entry, params, callback, NULL, WORKER); | |
| 3032 } | |
| 3033 int execute_def_data(worker_def * process_def, queue_entry worker_entry, datum ** params, instance_callback callback, void * data) | |
| 3034 { | |
| 3035 return execute_def_type(process_def, worker_entry, params, callback, data, WORKER); | |
| 3036 } | |
| 3037 | |
| 3038 int execute_def_type(worker_def * process_def, queue_entry worker_entry, datum ** params, instance_callback callback, void * data, int type) | |
| 3039 { | |
| 3040 int returnval, i; | |
| 3041 worker_instance * stack_instance; | |
| 3042 worker_def *temp_def, *converter; | |
| 3043 worker_def *parent_def = worker_entry.instance->def; | |
| 3044 unsigned short magic_cache_type; | |
| 3045 #ifdef USER_PROFILE | |
| 3046 LARGE_INTEGER start, end, duration; | |
| 3047 #endif | |
| 3048 VIS_PROFILE_START(PROF_PREP_MAGIC); | |
| 3049 if((process_def->type & TYPE_MASK) == MAGIC_TYPE) | |
| 3050 { | |
| 3051 DEBUGPRINTF( "Magic method: %s\n", process_def->name); | |
| 3052 if(!params || !params[0]) | |
| 3053 { | |
| 3054 ERRORPRINTF("Error: null first parmeter or null parameter array for worker %s\n", process_def->name); | |
| 3055 print_stack_trace(worker_entry.instance); | |
| 3056 execute_active = FALSE; | |
| 3057 return -1; | |
| 3058 } | |
| 3059 VIS_EnterCriticalSection(parent_def->implement_func->workerlist[worker_entry.worker_num].lock); | |
| 3060 temp_def = parent_def->implement_func->workerlist[worker_entry.worker_num].magic_cache_implement; | |
| 3061 magic_cache_type = parent_def->implement_func->workerlist[worker_entry.worker_num].magic_cache_type; | |
| 3062 VIS_LeaveCriticalSection(parent_def->implement_func->workerlist[worker_entry.worker_num].lock); | |
| 3063 if(!temp_def || magic_cache_type != params[0]->company->type_id) | |
| 3064 { | |
| 3065 DEBUGPRINTF("Finding method %s with %d inputs for type %s(%d)\n", process_def->name, process_def->num_inputs, params[0]->company->name, params[0]->company->type_id); | |
| 3066 temp_def = find_method(params[0]->company->type_id,process_def->name, process_def->num_inputs, process_def->program); | |
| 3067 if(!temp_def) | |
| 3068 { | |
| 3069 for(i = 1; i < process_def->program->num_companies; ++i) | |
| 3070 { | |
| 3071 temp_def = find_method(i,process_def->name, process_def->num_inputs, process_def->program); | |
| 3072 if(temp_def) | |
| 3073 { | |
| 3074 converter = find_converter_method(temp_def->input_types[0], params[0]->company->type_id, process_def->program); | |
| 3075 if(converter) | |
| 3076 { | |
| 3077 ((worker_impl)converter->implement_func)(params, &worker_entry); | |
| 3078 break; | |
| 3079 } | |
| 3080 else | |
| 3081 { | |
| 3082 //DEBUGPRINTF("Error: Needed conversion from %s to %s for input %d of %s\n", params[0]->company->name, process_def->program->companylist[temp_def->input_types[0]].name, 0, temp_def->name); | |
| 3083 //printf("Warning: Needed conversion from %s to %s for input %d of %s for loose method call\n", params[0]->company->name, process_def->program->companylist[temp_def->input_types[0]].name, 0, temp_def->name); | |
| 3084 temp_def = NULL; | |
| 3085 } | |
| 3086 } | |
| 3087 } | |
| 3088 } | |
| 3089 if(temp_def) | |
| 3090 { | |
| 3091 VIS_EnterCriticalSection(parent_def->implement_func->workerlist[worker_entry.worker_num].lock); | |
| 3092 parent_def->implement_func->workerlist[worker_entry.worker_num].magic_cache_implement = temp_def; | |
| 3093 parent_def->implement_func->workerlist[worker_entry.worker_num].magic_cache_type = temp_def->input_types[0]; | |
| 3094 VIS_LeaveCriticalSection(parent_def->implement_func->workerlist[worker_entry.worker_num].lock); | |
| 3095 } | |
| 3096 else | |
| 3097 { | |
| 3098 ERRORPRINTF("Error: Company %s doesn't implement worker %s. It implements the following:\n", params[0]->company->name, process_def->name); | |
| 3099 for(i = 0; i < params[0]->company->num_methods; ++i) | |
| 3100 { | |
| 3101 ERRORPRINTF("%s\n", params[0]->company->methodlist[i]->name); | |
| 3102 } | |
| 3103 print_stack_trace(worker_entry.instance); | |
| 3104 } | |
| 3105 } | |
| 3106 process_def = temp_def; | |
| 3107 } | |
| 3108 VIS_PROFILE_END(PROF_PREP_MAGIC); | |
| 3109 if(!process_def) | |
| 3110 { | |
| 3111 //DEBUGPUTS("Invalid def\n"); | |
| 3112 VIS_PROFILE_END(PROF_EXECUTE_WORKER); | |
| 3113 execute_active = FALSE; | |
| 3114 return -2; | |
| 3115 } | |
| 3116 | |
| 3117 VIS_PROFILE_START(PROF_CONVERT_INPUTS); | |
| 3118 for(i = 0; i < process_def->num_inputs; ++i) | |
| 3119 { | |
| 3120 DEBUGPRINTF("params[%d] = %X\n", i, params[i]); | |
| 3121 if(process_def->input_types[i] != ANY_TYPE && process_def->input_types[i] != params[i]->company->type_id) | |
| 3122 { | |
| 3123 DEBUGPRINTF("Input %d needs conversion from %d to %d\n", i, params[i]->company->type_id, process_def->input_types[i]); | |
| 3124 converter = find_converter_method(process_def->input_types[i], params[i]->company->type_id, process_def->program); | |
| 3125 if(!converter) | |
| 3126 { | |
| 3127 if(worker_entry.instance) { | |
| 3128 ERRORPRINTF("Error: Needed conversion from %s to %s for input %d of %s in worker %s\n", params[i]->company->name, process_def->program->companylist[process_def->input_types[i]].name, i, process_def->name, worker_entry.instance->def->name); | |
| 13 | 3129 print_stack_trace(worker_entry.instance); |
| 0 | 3130 } else { |
| 3131 DEBUGPRINTF("Error: Needed conversion from %s to %s for input %d of %s\n", params[i]->company->name, process_def->program->companylist[process_def->input_types[i]].name, i, process_def->name); | |
| 3132 printf("Error: Needed conversion from %s to %s for input %d of %s", params[i]->company->name, process_def->program->companylist[process_def->input_types[i]].name, i, process_def->name); | |
| 3133 } | |
| 3134 execute_active = FALSE; | |
| 3135 VIS_PROFILE_END(PROF_PROCESS_WORKER); | |
| 3136 return -3; | |
| 3137 } | |
| 3138 ((worker_impl)(converter->implement_func))(params+i, &worker_entry); | |
| 3139 } | |
| 3140 } | |
| 3141 VIS_PROFILE_END(PROF_CONVERT_INPUTS); | |
| 3142 | |
| 3143 if(process_def->type & USER_FLAG) | |
| 3144 { | |
| 3145 VIS_PROFILE_START(PROF_EXECUTE_CUSTOM); | |
| 3146 // | |
| 3147 init_custom_worker_type(worker_entry.worker_num, worker_entry.instance, process_def, callback, data, params, type); | |
| 3148 VIS_PROFILE_END(PROF_EXECUTE_CUSTOM); | |
| 3149 VIS_PROFILE_END(PROF_PROCESS_WORKER); | |
| 3150 VIS_PROFILE_END(PROF_EXECUTE_WORKER); | |
| 3151 return 1; | |
| 3152 } | |
| 3153 else | |
| 3154 { | |
| 3155 VIS_PROFILE_START(PROF_EXECUTE_BUILTIN); | |
| 3156 //DEBUGPRINTF("%s: before deflist[%d].implement_func: %X. vis_append: %X vis_print: %X\n",def->implement_func->workerlist[aworker].name, def->implement_func->workerlist[aworker].value_index, (int)deflist[def->implement_func->workerlist[aworker].value_index].implement_func, (int)vis_append, (int)vis_print); | |
| 3157 #ifdef USER_PROFILE | |
| 3158 QueryPerformanceCounter(&start); | |
| 3159 #endif | |
| 3160 returnval = ((worker_impl)(process_def->implement_func))(params, &worker_entry); | |
| 3161 #ifdef USER_PROFILE | |
| 3162 if(!returnval) | |
| 3163 { | |
| 3164 QueryPerformanceCounter(&end); | |
| 3165 duration.QuadPart = end.QuadPart - start.QuadPart; | |
| 3166 VIS_EnterCriticalSection(process_def->lock); | |
| 3167 process_def->total.QuadPart += duration.QuadPart; | |
| 3168 ++process_def->count; | |
| 3169 if(duration.QuadPart > process_def->worst.QuadPart) | |
| 3170 process_def->worst.QuadPart = duration.QuadPart; | |
| 3171 VIS_LeaveCriticalSection(process_def->lock); | |
| 3172 } | |
| 3173 #endif | |
| 3174 //DEBUGPUTS("Builtin worker returned\n"); | |
| 3175 VIS_PROFILE_END(PROF_EXECUTE_BUILTIN); | |
| 3176 return returnval; | |
| 3177 } | |
| 3178 } | |
| 3179 | |
| 3180 void wait_callback(worker_instance * caller_instance, int caller_workerenum, worker_instance * done_instance, void * data) | |
| 3181 { | |
| 3182 int i; | |
| 3183 def_done * done = (def_done *)data; | |
| 3184 //DEBUGPUTS("begin wait_callback\n"); | |
| 3185 for(i = 0; i < done_instance->def->num_outputs; ++i) | |
| 3186 done->params[i] = NULL; | |
| 3187 for(i = 0; i < done_instance->def->implement_func->num_workers; ++i) | |
| 3188 { | |
| 3189 if(done_instance->def->implement_func->workerlist[i].type == 4) | |
| 3190 { | |
| 3191 if(!(done->params[done_instance->def->implement_func->workerlist[i].io_num])) | |
| 3192 { | |
| 3193 done->params[done_instance->def->implement_func->workerlist[i].io_num] = done_instance->workerlist[i].value; | |
| 3194 done_instance->workerlist[i].value = NULL; | |
| 3195 } | |
| 3196 } | |
| 3197 } | |
| 3198 //DEBUGPUTS("Before EnterCritical\n"); | |
| 3199 VIS_EnterCriticalSection(done->lock); | |
| 3200 done->done_flag = TRUE; | |
| 3201 VIS_LeaveCriticalSection(done->lock); | |
| 3202 //DEBUGPUTS("After EnterCritical\n"); | |
| 3203 } | |
| 3204 | |
| 3205 | |
| 3206 BOOL execute_def_wait(worker_def * def, datum ** params) | |
| 3207 { | |
| 3208 int val; | |
| 3209 def_done done; | |
| 3210 queue_entry entry; | |
| 3211 entry.worker_num = 0; | |
| 3212 entry.instance = NULL; | |
| 3213 VIS_InitializeCriticalSection(done.lock); | |
| 3214 done.done_flag = FALSE; | |
| 3215 done.params = params; | |
| 3216 val = execute_def_data(def, entry, params, wait_callback, &done); | |
| 3217 if(val == 0) | |
| 3218 return TRUE; | |
| 3219 else if (val < 0) | |
| 3220 return FALSE; | |
| 3221 while(1) | |
| 3222 { | |
| 3223 VIS_EnterCriticalSection(done.lock); | |
| 3224 if(done.done_flag) | |
| 3225 { | |
| 3226 VIS_DeleteCriticalSection(done.lock); | |
| 3227 break; | |
| 3228 } | |
| 3229 VIS_LeaveCriticalSection(done.lock); | |
| 3230 #if COMPILE_THREADS > 1 | |
| 3231 #ifdef WIN32 | |
| 3232 Sleep(0); | |
| 3233 #else | |
| 3234 sleep(0); | |
| 3235 #endif | |
| 3236 #endif | |
| 3237 } | |
| 3238 return TRUE; | |
| 3239 } | |
| 3240 | |
| 3241 int process_worker(queue_entry worker_entry) | |
| 3242 { | |
| 3243 //datum * paramstore[32]; | |
| 3244 datum ** params;// = paramstore; | |
| 3245 int i, j, start=0; | |
| 3246 global_store * store; | |
| 3247 char * varname; | |
| 3248 datum * varname_dat; | |
| 3249 datum * tempvalindex, *todelete; | |
| 3250 int got_params=0; | |
| 3251 int aworker = worker_entry.worker_num; | |
| 3252 worker_instance * instance = worker_entry.instance; | |
| 3253 worker_def * def = instance->def; | |
| 3254 worker_def * process_def; | |
| 3255 worker_def * temp_def; | |
| 3256 worker_def * converter; | |
| 3257 int returnval = 0; | |
| 3258 short const_type; | |
| 3259 char * last; | |
| 3260 | |
| 3261 VIS_PROFILE_START(PROF_PROCESS_WORKER); | |
| 3262 | |
| 3263 DEBUGPRINTF( "Processing worker %d with %d inputs and %d outputs\n", aworker,def->implement_func->workerlist[aworker].num_inputs, def->implement_func->workerlist[aworker].num_outputs); | |
| 3264 /*VIS_EnterCriticalSection(instance->workerlist[aworker].worker_lock); | |
| 3265 for(i = 0; i < def->implement_func->workerlist[aworker].num_inputs; ++i) | |
| 3266 { | |
| 3267 params[i] = instance->workerlist[aworker].params[i+1]; | |
| 3268 DEBUGPRINTF("params[%d] = %X\n", i, params[i]); | |
| 3269 instance->workerlist[aworker].params[i+1] = NULL; | |
| 3270 }*/ | |
| 3271 if(def->implement_func->workerlist[aworker].null_input) | |
| 3272 { | |
| 3273 //DEBUGPUTS("About to call release_ref\n"); | |
| 3274 release_ref(instance->workerlist[aworker].params[0]); | |
| 3275 instance->workerlist[aworker].params[0] = NULL; | |
| 3276 } | |
| 3277 //VIS_LeaveCriticalSection(instance->workerlist[aworker].worker_lock); | |
| 3278 //DEBUGPRINTF("Param check complete. returnval: %d, start: %d\n", returnval, start); | |
| 3279 params = instance->workerlist[aworker].params+1; | |
| 3280 | |
| 3281 if(def->implement_func->workerlist[aworker].type == WORKER || def->implement_func->workerlist[aworker].type == TAIL_RECURSE || def->implement_func->workerlist[aworker].type == TAIL_CALL)//Worker | |
| 3282 { | |
| 3283 VIS_PROFILE_START(PROF_EXECUTE_WORKER); | |
| 3284 //DEBUGPUTS("Worker\n"); | |
| 3285 process_def = (worker_def *)(def->implement_func->workerlist[aworker].value_index); | |
| 3286 //DEBUGPUTS("Got process_def\n"); | |
| 3287 DEBUGPRINTF("process_def->type: %X, type & TYPE_MASK: %X\n", process_def->type, (process_def->type & TYPE_MASK)); | |
| 3288 | |
| 3289 returnval = execute_def_type(process_def, worker_entry, params, sub_callback, NULL, def->implement_func->workerlist[aworker].type); | |
| 3290 DEBUGPRINTF("execute_def returned %d\n", returnval); | |
| 3291 if(returnval != 0) | |
| 3292 { | |
| 3293 VIS_PROFILE_END(PROF_PROCESS_WORKER); | |
| 3294 VIS_PROFILE_END(PROF_EXECUTE_WORKER); | |
| 3295 return returnval; | |
| 3296 } | |
| 3297 //DEBUGPRINTF("params[0] after execute_def: %X\n", params[0]); | |
| 3298 | |
| 3299 //DEBUGPUTS("Before process_outputs\n"); | |
| 3300 | |
| 3301 process_outputs(params, aworker, instance); | |
| 3302 //DEBUGPUTS("After process_outputs\n"); | |
| 3303 | |
| 3304 VIS_PROFILE_END(PROF_EXECUTE_WORKER); | |
| 3305 | |
| 3306 } | |
| 3307 else if(def->implement_func->workerlist[aworker].type == GET_GLOBAL) | |
| 3308 { | |
| 3309 varname = def->implement_func->workerlist[aworker].name + def->implement_func->workerlist[aworker].io_num; | |
| 3310 varname_dat = make_string(varname, -1, def->program); | |
| 3311 if(def->implement_func->workerlist[aworker].value_index < 0) | |
| 3312 { | |
| 3313 for(i = 0; i < instance->trans->num_stores; ++i) | |
| 3314 { | |
| 3315 VIS_EnterCriticalSection(instance->trans->stores[i].lock); | |
| 3316 params[0] = add_ref(instance->trans->stores[i].instance_data); | |
| 3317 VIS_LeaveCriticalSection(instance->trans->stores[i].lock); | |
| 3318 params[1] = add_ref(varname_dat); | |
| 3319 vis_dict_index(params, NULL); | |
| 3320 | |
| 3321 if(params[0]) | |
| 3322 { | |
| 3323 def->implement_func->workerlist[aworker].value_index = i; | |
| 3324 break; | |
| 3325 } | |
| 3326 } | |
| 3327 if(def->implement_func->workerlist[aworker].value_index < 0) | |
| 3328 { | |
| 3329 printf("Error: Variable %s not found in any global stores used by worker %s\n", varname, def->name); | |
| 3330 DEBUGPRINTF("Error: Variable %s not found in any global stores used by worker %s\n", varname, def->name); | |
| 3331 execute_active = FALSE; | |
| 3332 return -1; | |
| 3333 } | |
| 3334 } | |
| 3335 else | |
| 3336 { | |
| 3337 VIS_EnterCriticalSection(instance->trans->stores[(int)def->implement_func->workerlist[aworker].value_index].lock); | |
| 3338 params[0] = add_ref(instance->trans->stores[(int)def->implement_func->workerlist[aworker].value_index].instance_data); | |
| 3339 VIS_LeaveCriticalSection(instance->trans->stores[(int)def->implement_func->workerlist[aworker].value_index].lock); | |
| 3340 params[1] = varname_dat; | |
| 3341 vis_dict_index(params, NULL); | |
| 3342 if(!params[0]) | |
| 3343 { | |
| 3344 printf("Error: Global variable %s not found in worker %s\n", def->implement_func->workerlist[aworker].name, def->name); | |
| 3345 DEBUGPRINTF("Error: Global variable %s not found in worker %s\n", def->implement_func->workerlist[aworker].name, def->name); | |
| 3346 execute_active = FALSE; | |
| 3347 return -1; | |
| 3348 } | |
| 3349 } | |
| 3350 process_outputs(params, aworker, instance); | |
| 3351 | |
| 3352 | |
| 3353 } | |
| 3354 else if(def->implement_func->workerlist[aworker].type == SET_GLOBAL) | |
| 3355 { | |
| 3356 varname = def->implement_func->workerlist[aworker].name + def->implement_func->workerlist[aworker].io_num; | |
| 3357 varname_dat = make_string(varname, -1, def->program); | |
| 3358 params[2] = params[0]; | |
| 3359 params[1] = varname_dat; | |
| 3360 VIS_EnterCriticalSection(instance->trans->stores[(int)def->implement_func->workerlist[aworker].value_index].lock); | |
| 3361 //no add_ref here because we'll be replacing instance_data with the result of vis_dict set | |
| 3362 params[0] = instance->trans->stores[(int)def->implement_func->workerlist[aworker].value_index].instance_data; | |
| 3363 vis_dict_set(params, NULL); | |
| 3364 instance->trans->stores[(int)def->implement_func->workerlist[aworker].value_index].instance_data = params[0]; | |
| 3365 VIS_LeaveCriticalSection(instance->trans->stores[(int)def->implement_func->workerlist[aworker].value_index].lock); | |
| 3366 //no outputs to process | |
| 3367 } | |
| 3368 else if(def->implement_func->workerlist[aworker].type == GET_COMP) | |
| 3369 { | |
| 3370 returnval = get_comp_room_by_name(params, def->implement_func->workerlist[aworker].name, NULL, &worker_entry, def->program); | |
| 3371 if(returnval) | |
| 3372 return returnval; | |
| 3373 process_outputs(params, aworker, instance); | |
| 3374 } | |
| 3375 else if(def->implement_func->workerlist[aworker].type == SET_COMP) | |
| 3376 { | |
| 3377 returnval = set_comp_room_by_name(params, def->implement_func->workerlist[aworker].name, NULL, &worker_entry, def->program); | |
| 3378 if(returnval) | |
| 3379 return returnval; | |
| 3380 process_outputs(params, aworker, instance); | |
| 3381 } | |
| 3382 else//Variable | |
| 3383 { | |
| 3384 VIS_PROFILE_START(PROF_EXECUTE_OTHER); | |
| 3385 if(def->implement_func->workerlist[aworker].num_inputs > 0 || def->implement_func->workerlist[aworker].type == INPUT) //Is this a Room or a constant? | |
| 3386 { | |
| 3387 todelete = NULL; | |
| 3388 VIS_EnterCriticalSection(instance->workerlist[aworker].worker_lock); | |
| 3389 if(def->implement_func->workerlist[aworker].type == OUTPUT) | |
| 3390 { | |
| 3391 todelete = instance->workerlist[aworker].value; | |
| 3392 instance->workerlist[aworker].value = params[0]; | |
| 3393 DEBUGPRINTF("Setting room/output at pos %d to %X in instance %X\n", aworker, params[0], instance); | |
| 3394 } | |
| 3395 //tempvalindex = instance->workerlist[aworker].value; | |
| 3396 VIS_LeaveCriticalSection(instance->workerlist[aworker].worker_lock); | |
| 3397 if(def->implement_func->workerlist[aworker].type == INPUT) | |
| 3398 { | |
| 3399 params[0] = instance->workerlist[aworker].value; | |
| 3400 instance->workerlist[aworker].value = NULL; | |
| 3401 } | |
| 3402 if(todelete) | |
| 3403 release_ref(todelete); | |
| 3404 if(def->implement_func->workerlist[aworker].num_outputs) | |
| 3405 { | |
| 3406 //add_ref(tempvalindex); | |
| 3407 process_outputs(params/*&tempvalindex*/, aworker, instance); | |
| 3408 } | |
| 3409 | |
| 3410 } | |
| 3411 else | |
| 3412 { | |
| 3413 //Hmm, do I potentially need another lock here? | |
| 3414 /*if(!(instance->def->implement_func->workerlist[aworker].value_index)) | |
| 3415 { | |
| 3416 instance->def->implement_func->workerlist[aworker].value_index = (int)(tempvalindex=get_constant(def->implement_func->workerlist[aworker].name,-1));//(int)tempvalindex; | |
| 3417 } | |
| 3418 else*/ | |
| 3419 tempvalindex = (datum *)instance->def->implement_func->workerlist[aworker].value_index; | |
| 3420 add_ref(tempvalindex); | |
| 3421 process_outputs(&tempvalindex, aworker, instance); | |
| 3422 } | |
| 3423 VIS_PROFILE_END(PROF_EXECUTE_OTHER); | |
| 3424 } | |
| 3425 VIS_PROFILE_END(PROF_PROCESS_WORKER); | |
| 3426 return returnval; | |
| 3427 } | |
| 3428 | |
| 3429 #define OPT_RESULT 0 | |
| 3430 #define OPT_CUST_RESULT 0x10000000 | |
| 3431 #define OPT_CONST 0x20000000 | |
| 3432 #define OPT_INPUT 0x30000000 | |
| 3433 | |
| 3434 int find_input_worker(custom_worker * cust, int aworker, int input, int *ret_output) | |
| 3435 { | |
| 3436 int o, p, wire_count; | |
| 3437 int out_worker; | |
| 3438 o = cust->workerlist[aworker].wire_up_lookup; | |
| 3439 wire_count = 0; | |
| 3440 while(cust->wirelist[p=cust->workers_to_wires_up[o]].end_worker == aworker && p >= 0) | |
| 3441 { | |
| 3442 if(cust->wirelist[p].input_num == input) | |
| 3443 { | |
| 3444 ++wire_count; | |
| 3445 out_worker = cust->wirelist[p].start_worker; | |
| 3446 DEBUGPRINTF("Input %d attached to %s(%d)\n", input, cust->workerlist[out_worker].name, out_worker); | |
| 3447 if(ret_output) | |
| 3448 *ret_output = cust->wirelist[p].output_num; | |
| 3449 } | |
| 3450 ++o; | |
| 3451 } | |
| 3452 DEBUGPRINTF("wire_count: %d\n", wire_count); | |
| 3453 if(wire_count == 1) | |
| 3454 return out_worker; | |
| 3455 return -1; | |
| 3456 } | |
| 3457 | |
| 3458 int make_input_code(custom_worker * cust, BOOL * in_opt, int * pos_in_opt, int source_worker, int output_num, int index, opt_entry * opts, int * branch_flags, opt_entry ** branch_refs, int input_num, program * prog) | |
| 3459 { | |
| 3460 /*if(in_opt[source_worker]) | |
| 3461 { | |
| 3462 if(prog->deflist[cust->workerlist[source_worker].value_index].type & USER_FLAG) | |
| 3463 { | |
| 3464 return OPT_CUST_RESULT | ((pos_in_opt[source_worker] & 0xFFFF) << 8) | (output_num & 0xFF); | |
| 3465 } | |
| 3466 else | |
| 3467 { | |
| 3468 if(strcmp(prog->deflist[cust->workerlist[source_worker].value_index].name, "If") == 0) | |
| 3469 { | |
| 3470 if(output_num == 0) | |
| 3471 { | |
| 3472 branch_flags[index] = 1; | |
| 3473 if(opts[pos_in_opt[source_worker]].branch1 <= index) | |
| 3474 opts[pos_in_opt[source_worker]].branch1 = index+1; | |
| 3475 } | |
| 3476 else | |
| 3477 { | |
| 3478 branch_flags[index] = 2; | |
| 3479 if(opts[pos_in_opt[source_worker]].branch2 <= index) | |
| 3480 opts[pos_in_opt[source_worker]].branch2 = index+1; | |
| 3481 } | |
| 3482 branch_refs[index] = opts + pos_in_opt[source_worker]; | |
| 3483 } | |
| 3484 else if(branch_flags[pos_in_opt[source_worker]]) | |
| 3485 { | |
| 3486 if(branch_flags[pos_in_opt[source_worker]] == 1) | |
| 3487 { | |
| 3488 branch_refs[pos_in_opt[source_worker]]->branch1 = index + 1; | |
| 3489 branch_flags[index] = 1; | |
| 3490 } | |
| 3491 else | |
| 3492 { | |
| 3493 branch_refs[pos_in_opt[source_worker]]->branch1 = index + 2; | |
| 3494 branch_flags[index] = 2; | |
| 3495 } | |
| 3496 branch_refs[index] = branch_refs[pos_in_opt[source_worker]]; | |
| 3497 } | |
| 3498 else | |
| 3499 branch_flags[index] = 0; | |
| 3500 if(input_num >= 0) | |
| 3501 ++opts[pos_in_opt[source_worker]].output_refs[output_num]; | |
| 3502 DEBUGPRINTF("OPT_RESULT: opt_num: %d, output_num: %d\n", pos_in_opt[source_worker], output_num); | |
| 3503 return OPT_RESULT | ((pos_in_opt[source_worker] & 0xFFFF) << 8) | (output_num & 0xFF); | |
| 3504 } | |
| 3505 } | |
| 3506 else if(cust->workerlist[source_worker].type == CONSTANT) | |
| 3507 { | |
| 3508 branch_flags[index] = 0; | |
| 3509 DEBUGPRINTF("OPT_CONST: %d\n", source_worker); | |
| 3510 return OPT_CONST | source_worker; | |
| 3511 } | |
| 3512 else if(cust->workerlist[source_worker].type == INPUT) | |
| 3513 { | |
| 3514 branch_flags[index] = 0; | |
| 3515 DEBUGPRINTF("OPT_INPUT: %d\n", cust->workerlist[source_worker].io_num); | |
| 3516 return OPT_INPUT | cust->workerlist[source_worker].io_num; | |
| 3517 }*/ | |
| 3518 return -1; | |
| 3519 } | |
| 3520 | |
| 3521 void optimize(worker_def * def) | |
| 3522 { | |
| 3523 /* | |
| 3524 int i,j,k,m,o,p; | |
| 3525 int * const_in; | |
| 3526 int num_entries = 0; | |
| 3527 int aworker; | |
| 3528 int adjust; | |
| 3529 int source_worker; | |
| 3530 int source_output; | |
| 3531 int source_null; | |
| 3532 int null_output; | |
| 3533 int wire_count; | |
| 3534 int * input_data; | |
| 3535 int current_null; | |
| 3536 int cust_result_count; | |
| 3537 int new_start; | |
| 3538 custom_worker * cust = def->implement_func; | |
| 3539 int start_current, end_current, new_current; | |
| 3540 worker_def * deflist = def->program->deflist; | |
| 3541 opt_entry * output = malloc(sizeof(opt_entry) * def->implement_func->num_workers); | |
| 3542 BOOL * in_opt = malloc(sizeof(BOOL) * cust->num_workers); | |
| 3543 int * branch_flags = malloc(sizeof(int) * cust->num_workers); | |
| 3544 opt_entry ** branch_refs = malloc(sizeof(int) * cust->num_workers); | |
| 3545 //BOOL * real_in_opt = malloc(sizeof(BOOL) * cust->num_workers); | |
| 3546 int * pos_in_opt = malloc(sizeof(int) * cust->num_workers); | |
| 3547 DEBUGPRINTF("deflist: %X\n", deflist); | |
| 3548 for(i = 0; i < cust->num_workers; ++i) | |
| 3549 { | |
| 3550 branch_flags[i] = 0; | |
| 3551 DEBUGPRINTF("%d: No input pass\n", i); | |
| 3552 DEBUGPRINTF("Examining: %s\n", cust->workerlist[i].name); | |
| 3553 if(cust->workerlist[i].num_inputs == 0 && !cust->workerlist[i].null_input && cust->workerlist[i].type == WORKER) | |
| 3554 { | |
| 3555 output[num_entries].def = deflist + cust->workerlist[i].value_index; | |
| 3556 DEBUGPRINTF("Set output[%d].def = %X\n", num_entries, output[num_entries].def); | |
| 3557 DEBUGPRINTF("opt: %d is %s\n\n", num_entries, cust->workerlist[i].name); | |
| 3558 output[num_entries].original_pos = i; | |
| 3559 output[num_entries].input_data = NULL; | |
| 3560 if(cust->workerlist[i].num_outputs) | |
| 3561 { | |
| 3562 output[num_entries].output_refs = malloc(sizeof(int)*cust->workerlist[i].num_outputs); | |
| 3563 for(j = 0; j < cust->workerlist[i].num_outputs; ++j) | |
| 3564 output[num_entries].output_refs[j] = 0; | |
| 3565 } | |
| 3566 else | |
| 3567 output[num_entries].output_refs = NULL; | |
| 3568 output[num_entries].branch1 = output[num_entries].branch2 = -1; | |
| 3569 //if(!(deflist[cust->workerlist[i].value_index].type & USER_FLAG)) | |
| 3570 //{ | |
| 3571 in_opt[i] = TRUE; | |
| 3572 pos_in_opt[i] = num_entries; | |
| 3573 //} | |
| 3574 //real_in_opt[i] = TRUE; | |
| 3575 ++num_entries; | |
| 3576 } | |
| 3577 else | |
| 3578 { | |
| 3579 //real_in_opt[i] = FALSE; | |
| 3580 in_opt[i] = FALSE; | |
| 3581 } | |
| 3582 } | |
| 3583 start_current = num_entries; | |
| 3584 for(i = 0; i < cust->num_workers; ++i) | |
| 3585 { | |
| 3586 DEBUGPRINTF("%d: Second pass\n", i); | |
| 3587 if(cust->workerlist[i].num_inputs == 0 && !cust->workerlist[i].null_input) | |
| 3588 { | |
| 3589 j = cust->workerlist[i].wire_down_lookup; | |
| 3590 while(cust->wirelist[k=cust->workers_to_wires_down[j]].start_worker == i && k >= 0) | |
| 3591 { | |
| 3592 aworker = cust->wirelist[k].end_worker; | |
| 3593 if(!in_opt[aworker]) | |
| 3594 { | |
| 3595 DEBUGPRINTF("Examining: %s(%d)\n", cust->workerlist[aworker].name, aworker); | |
| 3596 if(cust->workerlist[i].null_input) | |
| 3597 adjust = 1; | |
| 3598 else | |
| 3599 adjust = 0; | |
| 3600 input_data = malloc(sizeof(int)* (cust->workerlist[aworker].num_inputs+adjust)); | |
| 3601 for(m = (0-adjust); m < cust->workerlist[aworker].num_inputs; ++m) | |
| 3602 { | |
| 3603 DEBUGPRINTF("Input: %d\n", m); | |
| 3604 source_worker = find_input_worker(cust, aworker, m, &source_output); | |
| 3605 DEBUGPRINTF("source_worker: %d\n", source_worker); | |
| 3606 if(source_worker == -1) | |
| 3607 break; | |
| 3608 source_worker = make_input_code(cust, in_opt, pos_in_opt, source_worker, source_output, num_entries, output, branch_flags, branch_refs, m, def->program); | |
| 3609 DEBUGPRINTF("input code: %X\n", source_worker); | |
| 3610 if(source_worker == -1) | |
| 3611 break; | |
| 3612 input_data[m+adjust] = source_worker; | |
| 3613 if(source_worker == -1) | |
| 3614 break; | |
| 3615 } | |
| 3616 if(source_worker == -1) | |
| 3617 free(input_data); | |
| 3618 else | |
| 3619 { | |
| 3620 if(cust->workerlist[aworker].type == OUTPUT) | |
| 3621 output[num_entries].def = NULL; | |
| 3622 else | |
| 3623 output[num_entries].def = deflist + cust->workerlist[aworker].value_index; | |
| 3624 DEBUGPRINTF("Set output[%d].def = %X\n", num_entries, output[num_entries].def); | |
| 3625 DEBUGPRINTF("opt: %d is %s\n\n", num_entries, cust->workerlist[aworker].name); | |
| 3626 output[num_entries].original_pos = aworker; | |
| 3627 output[num_entries].input_data = input_data; | |
| 3628 output[num_entries].null_inputs = adjust; | |
| 3629 output[num_entries].branch1 = output[num_entries].branch2 = -1; | |
| 3630 if(cust->workerlist[aworker].num_outputs) | |
| 3631 { | |
| 3632 output[num_entries].output_refs = malloc(sizeof(int)*cust->workerlist[aworker].num_outputs); | |
| 3633 for(m = 0; m < cust->workerlist[aworker].num_outputs; ++m) | |
| 3634 output[num_entries].output_refs[m] = 0; | |
| 3635 } | |
| 3636 else | |
| 3637 output[num_entries].output_refs = NULL; | |
| 3638 //if(cust->workerlist[aworker].type != OUTPUT && !(deflist[cust->workerlist[aworker].value_index].type & USER_FLAG)) | |
| 3639 //{ | |
| 3640 in_opt[aworker] = TRUE; | |
| 3641 pos_in_opt[aworker] = num_entries; | |
| 3642 //} | |
| 3643 //real_in_opt[aworker] = TRUE; | |
| 3644 ++num_entries; | |
| 3645 | |
| 3646 } | |
| 3647 } | |
| 3648 ++j; | |
| 3649 } | |
| 3650 } | |
| 3651 } | |
| 3652 DEBUGPUTS("Before While\n"); | |
| 3653 end_current = num_entries; | |
| 3654 while(start_current != end_current) | |
| 3655 { | |
| 3656 DEBUGPRINTF("start_current: %d, end_current: %d\n", start_current, end_current); | |
| 3657 new_start = num_entries; | |
| 3658 for(i = start_current; i < end_current; ++i) | |
| 3659 { | |
| 3660 DEBUGPRINTF("opt: %d, def: %X, name: %s\n", i, output[i].def, cust->workerlist[output[i].original_pos].name); | |
| 3661 j = cust->workerlist[output[i].original_pos].wire_down_lookup; | |
| 3662 DEBUGPRINTF("wire_down_lookup: %d\n", j); | |
| 3663 while(cust->wirelist[k=cust->workers_to_wires_down[j]].start_worker == output[i].original_pos && k >= 0) | |
| 3664 { | |
| 3665 DEBUGPRINTF("Wire %d is attached to worker %d output %d and worker %d input %d\n", k, cust->wirelist[k].start_worker, cust->wirelist[k].output_num, cust->wirelist[k].end_worker, cust->wirelist[k].input_num); | |
| 3666 aworker = cust->wirelist[k].end_worker; | |
| 3667 //FIXME: Only works if constant/input attached to only one destination | |
| 3668 if(cust->workerlist[aworker].type == CONSTANT || cust->workerlist[aworker].type == INPUT) | |
| 3669 { | |
| 3670 DEBUGPRINTF("Worker is of type %d, ", cust->workerlist[aworker].type); | |
| 3671 aworker = cust->wirelist[cust->workers_to_wires_down[cust->workerlist[aworker].wire_down_lookup]].end_worker; | |
| 3672 DEBUGPRINTF("reruting to worker %d\n", aworker); | |
| 3673 } | |
| 3674 if(!in_opt[aworker]) | |
| 3675 { | |
| 3676 DEBUGPRINTF("Examining: %s(%d)\n", cust->workerlist[aworker].name, aworker); | |
| 3677 if(cust->workerlist[i].null_input) | |
| 3678 adjust = 1; | |
| 3679 else | |
| 3680 adjust = 0; | |
| 3681 for(m = (0-adjust); m < cust->workerlist[aworker].num_inputs; ++m) | |
| 3682 { | |
| 3683 source_worker = find_input_worker(cust, aworker, m, &source_output); | |
| 3684 if(source_worker == -1) | |
| 3685 break; | |
| 3686 if(cust->workerlist[source_worker].null_input && cust->workerlist[source_worker].type != WORKER) | |
| 3687 ++adjust; | |
| 3688 } | |
| 3689 if(source_worker != -1) | |
| 3690 { | |
| 3691 current_null = 0; | |
| 3692 input_data = malloc(sizeof(int)* (cust->workerlist[aworker].num_inputs+adjust)); | |
| 3693 cust_result_count = 0; | |
| 3694 for(m = (cust->workerlist[i].null_input ? -1 : 0); m < cust->workerlist[aworker].num_inputs; ++m) | |
| 3695 { | |
| 3696 DEBUGPRINTF("Input: %d\n", m); | |
| 3697 source_worker = find_input_worker(cust, aworker, m, &source_output); | |
| 3698 if(cust->workerlist[source_worker].null_input && cust->workerlist[source_worker].type != WORKER) | |
| 3699 { | |
| 3700 source_null = find_input_worker(cust, source_worker, -1, &null_output); | |
| 3701 if(source_null == -1) | |
| 3702 { | |
| 3703 source_worker = -1; | |
| 3704 break; | |
| 3705 } | |
| 3706 source_null = make_input_code(cust, in_opt, pos_in_opt, source_null, null_output, num_entries, output, branch_flags, branch_refs,-2, def->program); | |
| 3707 if((source_null & 0xF0000000) == OPT_CUST_RESULT) | |
| 3708 ++cust_result_count; | |
| 3709 if(source_null == -1) | |
| 3710 { | |
| 3711 source_worker = -1; | |
| 3712 break; | |
| 3713 } | |
| 3714 input_data[current_null++] = source_null; | |
| 3715 } | |
| 3716 DEBUGPRINTF("source_worker: %d\n", source_worker); | |
| 3717 source_worker = make_input_code(cust, in_opt, pos_in_opt, source_worker, source_output, num_entries, output, branch_flags, branch_refs, m, def->program); | |
| 3718 if((source_worker & 0xF0000000) == OPT_CUST_RESULT) | |
| 3719 ++cust_result_count; | |
| 3720 DEBUGPRINTF("input code: %d\n", source_worker); | |
| 3721 if(cust_result_count >= (cust->workerlist[aworker].num_inputs + adjust)) | |
| 3722 source_worker = -1; | |
| 3723 if(source_worker == -1) | |
| 3724 break; | |
| 3725 input_data[m+adjust] = source_worker; | |
| 3726 } | |
| 3727 if(source_worker == -1) | |
| 3728 free(input_data); | |
| 3729 else | |
| 3730 { | |
| 3731 if(cust->workerlist[aworker].type == OUTPUT) | |
| 3732 output[num_entries].def = NULL; | |
| 3733 else | |
| 3734 output[num_entries].def = deflist + cust->workerlist[aworker].value_index; | |
| 3735 DEBUGPRINTF("Set output[%d].def = %X\n", num_entries, output[num_entries].def); | |
| 3736 DEBUGPRINTF("opt: %d is %s\n\n", num_entries, cust->workerlist[aworker].name); | |
| 3737 output[num_entries].original_pos = aworker; | |
| 3738 output[num_entries].input_data = input_data; | |
| 3739 output[num_entries].null_inputs = adjust; | |
| 3740 output[num_entries].branch1 = output[num_entries].branch2 = -1; | |
| 3741 if(cust->workerlist[aworker].num_outputs) | |
| 3742 { | |
| 3743 output[num_entries].output_refs = malloc(sizeof(int)*cust->workerlist[aworker].num_outputs); | |
| 3744 for(m = 0; m < cust->workerlist[aworker].num_outputs; ++m) | |
| 3745 output[num_entries].output_refs[m] = 0; | |
| 3746 } | |
| 3747 else | |
| 3748 output[num_entries].output_refs = NULL; | |
| 3749 //if(cust->workerlist[aworker].type != OUTPUT && !(deflist[cust->workerlist[aworker].value_index].type & USER_FLAG)) | |
| 3750 //{ | |
| 3751 in_opt[aworker] = TRUE; | |
| 3752 pos_in_opt[aworker] = num_entries; | |
| 3753 //} | |
| 3754 //real_in_opt[aworker] = TRUE; | |
| 3755 ++num_entries; | |
| 3756 | |
| 3757 } | |
| 3758 } | |
| 3759 } | |
| 3760 ++j; | |
| 3761 } | |
| 3762 } | |
| 3763 start_current = new_start; | |
| 3764 end_current = num_entries; | |
| 3765 } | |
| 3766 def->optimized = output; | |
| 3767 def->opt_count = num_entries; | |
| 3768 DEBUGPUTS("optimize done\n\n\n"); | |
| 3769 */ | |
| 3770 } | |
| 3771 | |
| 3772 | |
| 3773 void run_optimized(worker_instance * instance, datum ** params) | |
| 3774 { | |
| 3775 int i = 0,j,k; | |
| 3776 unsigned short output, opt_num; | |
| 3777 datum * this_params[32]; | |
| 3778 queue_entry entry; | |
| 3779 datum * val; | |
| 3780 BOOL skip; | |
| 3781 BOOL partial_flag; | |
| 3782 BOOL continue_flag; | |
| 3783 int count; | |
| 3784 int ready; | |
| 3785 int jump_from = -1; | |
| 3786 int jump_to = -1; | |
| 3787 int tmp, addnum; | |
| 3788 opt_entry * exec_list = instance->def->optimized; | |
| 3789 datum ** results = instance->opt_results;//malloc(sizeof(datum *) * instance->def->opt_count * 32); | |
| 3790 VIS_PROFILE_START(PROF_RUN_OPT); | |
| 3791 entry.instance = instance; | |
| 3792 for(i = 0; i < instance->def->opt_count; ++i) | |
| 3793 { | |
| 3794 VIS_PROFILE_START(PROF_OPT_LOOP); | |
| 3795 skip = FALSE; | |
| 3796 partial_flag = FALSE; | |
| 3797 continue_flag = FALSE; | |
| 3798 DEBUGPRINTF("\nPeparing exec_list[%d]\n", i); | |
| 3799 if(exec_list[i].def) | |
| 3800 { | |
| 3801 DEBUGPRINTF("Name: %s\n", exec_list[i].def->name); | |
| 3802 count = exec_list[i].def->num_inputs; | |
| 3803 } | |
| 3804 else | |
| 3805 count = 1; | |
| 3806 count += exec_list[i].null_inputs; | |
| 3807 //DEBUGPRINTF("Input count: %d\n", count); | |
| 3808 if(count && !exec_list[i].input_data) | |
| 3809 puts("Runtime Error: input data is NULL\n"); | |
| 3810 //DEBUGPRINTF("input_data: %X\n", exec_list[i].input_data); | |
| 3811 VIS_PROFILE_START(PROF_OPT_PREP_INPUT); | |
| 3812 for(j = 0; j < count; ++j) | |
| 3813 { | |
| 3814 val = NULL; | |
| 3815 continue_flag = FALSE; | |
| 3816 switch(exec_list[i].input_data[j] & 0xF0000000) | |
| 3817 { | |
| 3818 case OPT_RESULT: | |
| 3819 output = exec_list[i].input_data[j] & 0xFF; | |
| 3820 opt_num = (exec_list[i].input_data[j] >> 8)& 0xFFFF; | |
| 3821 DEBUGPRINTF("OPT_RESULT for input %d, opt_num: %d, output: %d\n", j, opt_num, output); | |
| 3822 val = results[(opt_num * 32) | output]; | |
| 3823 break; | |
| 3824 case OPT_CUST_RESULT: | |
| 3825 val = NULL; | |
| 3826 partial_flag = TRUE; | |
| 3827 continue_flag = TRUE; | |
| 3828 break; | |
| 3829 case OPT_INPUT: | |
| 3830 DEBUGPRINTF("OPT_INPUT for input %d\n", j); | |
| 3831 val = add_ref(params[exec_list[i].input_data[j] & 0xFF]); | |
| 3832 break; | |
| 3833 case OPT_CONST: | |
| 3834 DEBUGPRINTF("OPT_CONST for input %d\n", j); | |
| 3835 val = add_ref((datum *)(instance->def->implement_func->workerlist[exec_list[i].input_data[j] & 0xFFFFFF].value_index)); | |
| 3836 break; | |
| 3837 default: | |
| 3838 puts("Runtime Error: Invalid bytecode\n"); | |
| 3839 val = NULL; | |
| 3840 break; | |
| 3841 } | |
| 3842 if(!val && !continue_flag) | |
| 3843 { | |
| 3844 for(k = exec_list[i].null_inputs; k < j; ++k) | |
| 3845 release_ref(this_params[k]); | |
| 3846 skip = TRUE; | |
| 3847 break; | |
| 3848 } | |
| 3849 DEBUGPRINTF("this_params[%d] = %X\n", j, val); | |
| 3850 if(j >= exec_list[i].null_inputs) | |
| 3851 if(val) | |
| 3852 this_params[j] = /*add_ref(*/val/*)*/; | |
| 3853 else | |
| 3854 this_params[j] = NULL; | |
| 3855 | |
| 3856 } | |
| 3857 VIS_PROFILE_END(PROF_OPT_PREP_INPUT); | |
| 3858 if(!skip) | |
| 3859 { | |
| 3860 if(partial_flag) | |
| 3861 { | |
| 3862 VIS_PROFILE_START(PROF_PARTIAL_EXEC); | |
| 3863 ready = 0; | |
| 3864 for(j = exec_list[i].null_inputs; j < count; ++j) | |
| 3865 if(this_params[j]) | |
| 3866 { | |
| 3867 instance->workerlist[exec_list[i].original_pos].params[j-exec_list[i].null_inputs+1] = this_params[j]; | |
| 3868 ++ready; | |
| 3869 } | |
| 3870 if(instance->def->implement_func->workerlist[exec_list[i].original_pos].null_input && this_params[exec_list[i].null_inputs-1]) | |
| 3871 ++ready; | |
| 3872 DEBUGPRINTF("ready: %d\n", ready); | |
| 3873 skip = TRUE; | |
| 3874 VIS_EnterCriticalSection(instance->workerlist[exec_list[i].original_pos].worker_lock); | |
| 3875 instance->workerlist[exec_list[i].original_pos].ready_count += ready; | |
| 3876 if(instance->workerlist[exec_list[i].original_pos].ready_count >= (exec_list[i].def->num_inputs + (instance->def->implement_func->workerlist[exec_list[i].original_pos].null_input ? 1 : 0))) | |
| 3877 { | |
| 3878 skip = FALSE; | |
| 3879 instance->workerlist[exec_list[i].original_pos].ready_count = 0; | |
| 3880 | |
| 3881 } | |
| 3882 DEBUGPRINTF("ready_count: %d\n", instance->workerlist[exec_list[i].original_pos].ready_count); | |
| 3883 VIS_LeaveCriticalSection(instance->workerlist[exec_list[i].original_pos].worker_lock); | |
| 3884 if(!skip) | |
| 3885 add_queue(exec_list[i].original_pos, instance); | |
| 3886 VIS_PROFILE_END(PROF_PARTIAL_EXEC); | |
| 3887 } | |
| 3888 else if(exec_list[i].def) | |
| 3889 { | |
| 3890 VIS_PROFILE_START(PROF_FULL_EXEC); | |
| 3891 DEBUGPRINTF("opt_exec: %s(%d)\n", exec_list[i].def->name, exec_list[i].original_pos); | |
| 3892 entry.worker_num = exec_list[i].original_pos; | |
| 3893 if(exec_list[i].def->type & USER_FLAG) | |
| 3894 { | |
| 3895 VIS_PROFILE_START(PROF_OPT_EXEC_USER); | |
| 3896 instance->workerlist[exec_list[i].original_pos].params[0] = NULL; | |
| 3897 memcpy(instance->workerlist[exec_list[i].original_pos].params+1, this_params + exec_list[i].null_inputs, sizeof(datum *) * exec_list[i].def->num_inputs); | |
| 3898 add_queue(exec_list[i].original_pos, instance); | |
| 3899 VIS_PROFILE_END(PROF_OPT_EXEC_USER); | |
| 3900 } | |
| 3901 else | |
| 3902 { | |
| 3903 VIS_PROFILE_START(PROF_OPT_EXEC_BUILT); | |
| 3904 if(execute_def(exec_list[i].def, entry, this_params + exec_list[i].null_inputs, sub_callback) == 0) | |
| 3905 { | |
| 3906 DEBUGPUTS("Exectuted with reslts\n"); | |
| 3907 if(exec_list[i].output_refs) | |
| 3908 { | |
| 3909 for(j = exec_list[i].null_inputs; j < (exec_list[i].def->num_outputs+exec_list[i].null_inputs); ++j) | |
| 3910 { | |
| 3911 DEBUGPRINTF("output_refs[%d] = %d\n", j-exec_list[i].null_inputs, exec_list[i].output_refs[j-exec_list[i].null_inputs]); | |
| 3912 if(!exec_list[i].output_refs[j-exec_list[i].null_inputs]) | |
| 3913 release_ref(this_params[j]); | |
| 3914 else if(exec_list[i].output_refs[j-exec_list[i].null_inputs] > 1) | |
| 3915 { | |
| 3916 /*DEBUGPRINTF("multi_add_ref(%X): %d\n", this_params[j], exec_list[i].output_refs[j-exec_list[i].null_inputs]-1); | |
| 3917 tmp = (int)(&(this_params[j]->ref_count)); | |
| 3918 addnum = exec_list[i].output_refs[j-exec_list[i].null_inputs]-1; | |
| 3919 __asm | |
| 3920 { | |
| 3921 mov ebx, tmp | |
| 3922 mov eax, addnum | |
| 3923 lock xadd dword ptr [ebx], eax | |
| 3924 }*/ | |
| 3925 VIS_EnterCriticalSection(this_params[j]->lock); | |
| 3926 this_params[j]->ref_count += exec_list[i].output_refs[j-exec_list[i].null_inputs]-1; | |
| 3927 | |
| 3928 VIS_LeaveCriticalSection(this_params[j]->lock); | |
| 3929 } | |
| 3930 } | |
| 3931 memcpy(results + i*32, this_params + exec_list[i].null_inputs, sizeof(datum *) * exec_list[i].def->num_outputs); | |
| 3932 if(exec_list[i].branch1 >= 0) | |
| 3933 { | |
| 3934 if(this_params[exec_list[i].null_inputs]) | |
| 3935 { | |
| 3936 jump_from = exec_list[i].branch1; | |
| 3937 jump_to = exec_list[i].branch2; | |
| 3938 } | |
| 3939 else | |
| 3940 { | |
| 3941 i = exec_list[i].branch1-1; | |
| 3942 } | |
| 3943 } | |
| 3944 } | |
| 3945 } | |
| 3946 /*else | |
| 3947 { | |
| 3948 for(j = exec_list[i].null_inputs; j < (exec_list[i].def->num_outputs + exec_list[i].null_inputs); ++j) | |
| 3949 results[(i*32)|j] = NULL; | |
| 3950 }*/ | |
| 3951 VIS_PROFILE_END(PROF_OPT_EXEC_BUILT); | |
| 3952 } | |
| 3953 VIS_PROFILE_END(PROF_FULL_EXEC); | |
| 3954 DEBUGPUTS("Executed\n"); | |
| 3955 } | |
| 3956 else | |
| 3957 instance->workerlist[exec_list[i].original_pos].value = this_params[exec_list[i].null_inputs]; | |
| 3958 } | |
| 3959 else | |
| 3960 { | |
| 3961 DEBUGPUTS("Skipped\n"); | |
| 3962 if(exec_list[i].def) | |
| 3963 { | |
| 3964 for(j = 0; j < exec_list[i].def->num_outputs; ++j) | |
| 3965 results[(i*32)|j] = NULL; | |
| 3966 } | |
| 3967 } | |
| 3968 if(jump_from >= 0 && (i+1) == jump_from) | |
| 3969 { | |
| 3970 i = jump_to-1; | |
| 3971 jump_from = -1; | |
| 3972 } | |
| 3973 VIS_PROFILE_END(PROF_OPT_LOOP); | |
| 3974 } | |
| 3975 DEBUGPUTS("run_optimized calling cleanup_check\n"); | |
| 3976 for(i = 0; i < instance->def->num_inputs; ++i) | |
| 3977 release_ref(params[i]); | |
| 3978 cleanup_check(entry); | |
| 3979 VIS_PROFILE_END(PROF_RUN_OPT); | |
| 3980 } | |
| 3981 | |
| 3982 int vis_print(datum ** inputlist, queue_entry * worker_entry) | |
| 3983 { | |
| 3984 int result; | |
| 3985 #ifdef CONSOLE | |
| 3986 puts((char *)inputlist[0]->c.generic.data); | |
| 3987 #else | |
| 3988 MessageBox(NULL, (char *)inputlist[0]->c.generic.data, "Visuality Output", MB_OK); | |
| 3989 #endif | |
| 3990 result = 1; | |
| 3991 | |
| 3992 release_ref(inputlist[0]); | |
| 3993 inputlist[0] = new_datum(BUILTIN_TYPE_YESNO, 2, 0, worker_entry->instance->def->program); | |
| 3994 //No one else knows about this new datum yet so we can skip getting a lock | |
| 3995 datum_set_yesno(inputlist[0], result); | |
| 3996 return 0; | |
| 3997 } | |
| 3998 | |
| 3999 int vis_end(datum ** inputlist, queue_entry * worker_entry) | |
| 4000 { | |
| 4001 // fprintf(outfile, "End worker reached.\n"); | |
| 4002 execute_active=FALSE; | |
| 4003 release_ref(inputlist[0]); | |
| 4004 //interp_stop(); | |
| 4005 return 0; | |
| 4006 } | |
| 4007 | |
| 4008 #ifdef NINTENDO_DS | |
| 4009 const char keyLetters[15] = "ABESRLUD><XYMC"; | |
| 4010 #define MAX_KEY_BITS 14 | |
| 4011 #endif | |
| 4012 | |
| 4013 int vis_getinput(datum ** inputlist, queue_entry * worker_entry) | |
| 4014 { | |
| 4015 #ifdef NINTENDO_DS | |
| 4016 int held,i,pos; | |
| 4017 char tempstring[14]; | |
| 4018 scanKeys(); | |
| 4019 held = keysHeld(); | |
| 4020 if(held) | |
| 4021 { | |
| 4022 pos = 0; | |
| 4023 for(i = 0; i < MAX_KEY_BITS; ++i) | |
| 4024 if(held & (1 << i)) | |
| 4025 tempstring[pos++] = keyLetters[i]; | |
| 4026 inputlist[0] = new_datum(BUILTIN_TYPE_STRING, 1, pos+1, worker_entry->instance->def->program); | |
| 4027 memcpy(inputlist[0]->c.generic.data, tempstring, pos); | |
| 4028 ((char *)inputlist[0]->c.generic.data)[pos]='\0'; | |
| 4029 return 0; | |
| 4030 } | |
| 4031 else | |
| 4032 { | |
| 4033 requeue(worker_entry->worker_num, worker_entry->instance); | |
| 4034 return 1; | |
| 4035 } | |
| 4036 #else | |
| 4037 #ifdef CONSOLE | |
| 4038 gets(text_buf); | |
| 4039 text_buf_size = strlen(text_buf); | |
| 4040 //Nasty hack for testing until I get around to supporting command line args propery | |
| 4041 //text_buf_size = strlen(global_argv[1]); | |
| 4042 #else | |
| 4043 | |
| 4044 while(text_buf_size <= 0) | |
| 4045 { | |
| 4046 Sleep(30); //TODO: replace with I/O queue mechanism | |
| 4047 } | |
| 4048 #endif | |
| 4049 // VIS_EnterCriticalSection(text_buf_lock); | |
| 4050 DEBUGPRINTF("Allocating %d bytes\n", text_buf_size+1); | |
| 4051 inputlist[0] = new_datum(BUILTIN_TYPE_STRING, 1, text_buf_size+1, worker_entry->instance->def->program); | |
| 4052 DEBUGPUTS("Allocated datum.\n"); | |
| 4053 memcpy(inputlist[0]->c.generic.data, text_buf, text_buf_size); | |
| 4054 DEBUGPUTS("Copied string.\n"); | |
| 4055 ((char *)inputlist[0]->c.generic.data)[text_buf_size]='\0'; | |
| 4056 DEBUGPRINTF("Input is %s\n", inputlist[0]->c.generic.data); | |
| 4057 text_buf_size = 0; | |
| 4058 // VIS_LeaveCriticalSection(text_buf_lock); | |
| 4059 return 0; | |
| 4060 #endif | |
| 4061 } | |
| 4062 | |
| 4063 int vis_if(datum ** inputlist, queue_entry * worker_entry) | |
| 4064 { | |
| 4065 if(!(inputlist[0]->c.integers.num_a)) | |
| 4066 { | |
| 4067 inputlist[1] = inputlist[0]; | |
| 4068 inputlist[0] = NULL; | |
| 4069 } | |
| 4070 else | |
| 4071 inputlist[1] = NULL; | |
| 4072 return 0; | |
| 4073 } | |
| 4074 | |
| 4075 int vis_build(datum ** inputlist, queue_entry * worker_entry) | |
| 4076 { | |
| 4077 int i,j; | |
| 4078 company * companylist = worker_entry->instance->def->program->companylist; | |
| 4079 int num_companies = worker_entry->instance->def->program->num_companies; | |
| 4080 DEBUGPRINTF("Looking for company named %s\n", inputlist[0]->c.generic.data); | |
| 4081 for(i = 0; i < num_companies; ++i) | |
| 4082 { | |
| 4083 DEBUGPRINTF("Checking company %d:%s\n", i, companylist[i].name); | |
| 4084 if(!strcmp(inputlist[0]->c.generic.data, companylist[i].name)) | |
| 4085 break; | |
| 4086 } | |
| 4087 release_ref(inputlist[0]); | |
| 4088 if(i < num_companies && companylist[i].build_size > 0) | |
| 4089 { | |
| 4090 DEBUGPRINTF("Building company with size %d\n", companylist[i].build_size); | |
| 4091 inputlist[0] = new_datum(i, 1, companylist[i].build_size, worker_entry->instance->def->program); | |
| 4092 for(j = 0; j < companylist[i].build_size; ++j) | |
| 4093 ((char*)(inputlist[0]->c.generic.data))[j] = 0; | |
| 4094 } | |
| 4095 else | |
| 4096 { | |
| 4097 DEBUGPUTS("Could not find company\n"); | |
| 4098 inputlist[0] = NULL; | |
| 4099 } | |
| 4100 return 0; | |
| 4101 } | |
| 4102 | |
| 4103 int vis_wait_forever(datum ** inputlist, queue_entry * worker_entry) | |
| 4104 { | |
| 4105 return 1; | |
| 4106 } | |
| 4107 | |
| 4108 int init_global_store(datum ** inputlist, queue_entry * worker_entry) | |
| 4109 { | |
| 4110 datum * params[3]; | |
| 4111 global_store * store; | |
| 4112 datum * store_dat = new_datum(BUILTIN_TYPE_GLOBAL_STORE, 1, sizeof(global_store), worker_entry->instance->def->program); | |
| 4113 store = store_dat->c.generic.data; | |
| 4114 store->name = add_ref(inputlist[0]); | |
| 4115 store->data = create_dict(worker_entry->instance->def->program); | |
| 4116 VIS_EnterCriticalSection(global_store_lock); | |
| 4117 params[0] = global_store_dict; | |
| 4118 params[1] = inputlist[0]; | |
| 4119 params[2] = store_dat; | |
| 4120 vis_dict_set(params, NULL); | |
| 4121 global_store_dict = params[0]; | |
| 4122 DEBUGPUTS("Global store init complete\n"); | |
| 4123 VIS_LeaveCriticalSection(global_store_lock); | |
| 4124 DEBUGPUTS("Released global_store_lock\n"); | |
| 4125 inputlist[0] = NULL; | |
| 4126 return 0; | |
| 4127 } | |
| 4128 | |
| 4129 int vis_type_of(datum ** inputlist, queue_entry * worker_entry) | |
| 4130 { | |
| 4131 datum * output = make_string(inputlist[0]->company->name, -1, worker_entry->instance->def->program); | |
| 4132 release_ref(inputlist[0]); | |
| 4133 inputlist[0] = output; | |
| 4134 return 0; | |
| 4135 } | |
| 4136 | |
| 4137 int vis_random(datum ** inputlist, queue_entry * worker_entry) | |
| 4138 { | |
| 4139 inputlist[0] = new_datum(BUILTIN_TYPE_WHOLE, 2, 0, worker_entry->instance->def->program); | |
| 4140 VIS_EnterCriticalSection(randlock); | |
| 4141 inputlist[0]->c.integers.num_a = genrand_int32(); | |
| 4142 VIS_LeaveCriticalSection(randlock); | |
| 4143 return 0; | |
| 4144 } |