void pymatecorba_register_stub(CORBA_TypeCode tc, PyObject *stub) { init_hash_tables(); if (tc->repo_id) { CORBA_Object_duplicate((CORBA_Object)tc, NULL); g_hash_table_replace(type_codes, tc->repo_id, tc); } if (stub) { PyObject *stub_dict = NULL; Py_INCREF(stub); g_hash_table_insert(stubs, tc->repo_id, stub); if (!strncmp(tc->repo_id, "IDL:omg.org/CORBA", 17)) { gchar *other_repo_id = g_strconcat("IDL:", &tc->repo_id[12], NULL); g_hash_table_insert(stubs, other_repo_id, stub); } if (PyType_Check(stub)) stub_dict = ((PyTypeObject *)stub)->tp_dict; else if (PyClass_Check(stub)) stub_dict = ((PyClassObject *)stub)->cl_dict; if (stub_dict && !PyDict_GetItemString(stub_dict, "__typecode__")) { PyObject *py_tc = pycorba_typecode_new(tc); PyDict_SetItemString(stub_dict, "__typecode__", py_tc); Py_DECREF(py_tc); } } }
PyObject * pymatecorba_get_stub_from_repo_id(const gchar *repo_id) { init_hash_tables(); if (repo_id == NULL) return NULL; return g_hash_table_lookup(stubs, repo_id); }
void ThreadsManager::init() { int threadID[MAX_THREADS]; // This flag is needed to properly end the threads when program exits allThreadsShouldExit = false; // Threads will sent to sleep as soon as created, only main thread is kept alive activeThreads = 1; threads[0].state = Thread::SEARCHING; // Allocate pawn and material hash tables for main thread init_hash_tables(); lock_init(&mpLock); // Initialize thread and split point locks for (int i = 0; i < MAX_THREADS; i++) { lock_init(&threads[i].sleepLock); cond_init(&threads[i].sleepCond); for (int j = 0; j < MAX_ACTIVE_SPLIT_POINTS; j++) lock_init(&(threads[i].splitPoints[j].lock)); } // Create and startup all the threads but the main that is already running for (int i = 1; i < MAX_THREADS; i++) { threads[i].state = Thread::INITIALIZING; threadID[i] = i; #if defined(_MSC_VER) bool ok = (CreateThread(NULL, 0, start_routine, (LPVOID)&threadID[i], 0, NULL) != NULL); #else pthread_t pthreadID; bool ok = (pthread_create(&pthreadID, NULL, start_routine, (void*)&threadID[i]) == 0); pthread_detach(pthreadID); #endif if (!ok) { std::cout << "Failed to create thread number " << i << std::endl; ::exit(EXIT_FAILURE); } // Wait until the thread has finished launching and is gone to sleep while (threads[i].state == Thread::INITIALIZING) {} } }
PyObject * pymatecorba_get_stub(CORBA_TypeCode tc) { PyObject *stub; init_hash_tables(); if (!tc->repo_id) return NULL; stub = g_hash_table_lookup(stubs, tc->repo_id); /* if we didn't get a typecode, and the repoid is in the type_codes * hash, try generating a stub. */ if (!stub && tc->repo_id && g_hash_table_lookup(type_codes, tc->repo_id) == NULL) { pymatecorba_generate_typecode_stubs(tc); stub = g_hash_table_lookup(stubs, tc->repo_id); } return stub; }
int main (int argc, char *argv[]) { char input[STR_BUFF], *p, output[STR_BUFF]; move_s move, comp_move; int depth = 4, comp_color; bool force_mode, show_board; double nps, elapsed; clock_t cpu_start = 0, cpu_end = 0; parse_cmdline (argc, argv); start_up (); init_hash_values (); init_hash_tables (); init_game (); init_book (); xb_mode = FALSE; force_mode = FALSE; comp_color = 0; show_board = TRUE; setbuf (stdout, NULL); setbuf (stdin, NULL); /* keep looping for input, and responding to it: */ while (TRUE) { /* case where it's the computer's turn to move: */ if (comp_color == white_to_move && !force_mode) { nodes = 0; qnodes = 0; ply = 0; start_time = rtime (); cpu_start = clock (); comp_move = think (); cpu_end = clock (); /* check for a game end: */ if (((comp_color == 1 && result != white_is_mated) || (comp_color == 0 && result != black_is_mated)) && result != stalemate && result != draw_by_fifty && result != draw_by_rep) { comp_to_coord (comp_move, output); make (&comp_move, 0); /* check to see if we draw by rep/fifty after our move: */ if (is_draw ()) { result = draw_by_rep; } else if (fifty > 100) { result = draw_by_fifty; } reset_piece_square (); /* check to see if we mate our opponent with our current move: */ if (!result) { if (xb_mode) { printf ("move %s\n", output); } else { printf ("\n%s\n", output); } } else { if (xb_mode) { printf ("move %s\n", output); } else { printf ("\n%s\n", output); } if (result == white_is_mated) { printf ("0-1 {Black Mates}\n"); } else if (result == black_is_mated) { printf ("1-0 {White Mates}\n"); } else if (result == draw_by_fifty) { printf ("1/2-1/2 {Fifty move rule}\n"); } else if (result == draw_by_rep) { printf ("1/2-1/2 {3 fold repetition}\n"); } else { printf ("1/2-1/2 {Draw}\n"); } } } /* we have been mated or there is a draw: */ else { if (result == white_is_mated) { printf ("0-1 {Black Mates}\n"); } else if (result == black_is_mated) { printf ("1-0 {White Mates}\n"); } else if (result == stalemate) { printf ("1/2-1/2 {Stalemate}\n"); } else if (result == draw_by_fifty) { printf ("1/2-1/2 {Fifty move rule}\n"); } else if (result == draw_by_rep) { printf ("1/2-1/2 {3 fold repetition}\n"); } else { printf ("1/2-1/2 {Draw}\n"); } } } /* get our input: */ if (!xb_mode) { if (show_board && strcmp (input, "help")) { printf ("\n"); display_board (stdout, 1-comp_color); } printf ("Faile> "); rinput (input, STR_BUFF, stdin); } else { rinput (input, STR_BUFF, stdin); } /* check to see if we have a move. If it's legal, play it. */ if (is_valid_comp (pgn_to_comp (input))) { /* good SAN input style move */ move = pgn_to_comp (input); make (&move, 0); reset_piece_square (); if (show_board) { printf ("\n"); display_board (stdout, 1-comp_color); } } else if (is_move (&input[0])) { /* good coordinate style input move */ if (verify_coord (input, &move)) { make (&move, 0); reset_piece_square (); if (show_board) { printf ("\n"); display_board (stdout, 1-comp_color); } } else { printf ("Illegal move: %s\n", input); } } else { /* make everything lower case for convenience: */ for (p = input; *p; p++) *p = tolower (*p); /* command parsing: */ if (!strcmp (input, "quit") || !strcmp (input, "exit")) { shut_down (EXIT_SUCCESS); } else if (!strcmp (input, "diagram") || !strcmp (input, "d")) { toggle_bool (&show_board); } else if (!strncmp (input, "perft", 5)) { sscanf (input+6, "%d", &depth); raw_nodes = 0; perft (depth); printf ("Raw nodes for depth %d: %ld\n", depth, raw_nodes); } else if (!strcmp (input, "new")) { init_game (); /* refresh our hash tables: */ refresh_hash (); force_mode = FALSE; comp_color = 0; } else if (!strcmp (input, "xboard")) { xb_mode = TRUE; toggle_bool (&show_board); signal (SIGINT, SIG_IGN); printf ("\n"); } else if (!strcmp (input, "nodes")) { printf ("Number of nodes: %li (%0.2f%% qnodes)\n", nodes, (float) ((float) qnodes / (float) nodes * 100.0)); } else if (!strcmp (input, "nps")) { elapsed = (cpu_end-cpu_start)/(double) CLOCKS_PER_SEC; nps = (float) nodes/(float) elapsed; if (!elapsed) printf ("NPS: N/A\n"); else printf ("NPS: %ld\n", (long int) nps); } else if (!strcmp (input, "post")) { toggle_bool (&post); if (xb_mode) post = TRUE; } else if (!strcmp (input, "nopost")) { post = FALSE; } else if (!strcmp (input, "random")) { continue; } else if (!strcmp (input, "hard")) { continue; } else if (!strcmp (input, "easy")) { continue; } else if (!strcmp (input, "?")) { continue; } else if (!strcmp (input, "white")) { white_to_move = 1; comp_color = 0; } else if (!strcmp (input, "black")) { white_to_move = 0; comp_color = 1; } else if (!strcmp (input, "force")) { force_mode = TRUE; } else if (!strcmp (input, "go")) { comp_color = white_to_move; force_mode = FALSE; } else if (!strncmp (input, "time", 4)) { sscanf (input+5, "%ld", &time_left); } else if (!strncmp (input, "otim", 4)) { sscanf (input+5, "%ld", &opp_time); } else if (!strncmp (input, "level", 5)) { /* extract the time controls: */ sscanf (input+6, "%ld %ld %ld", &moves_to_tc, &min_per_game, &inc); time_left = min_per_game*6000; opp_time = time_left; inc *= 100; } else if (!strncmp (input, "result", 6)) { ics_game_end (); init_game (); force_mode = FALSE; comp_color = 0; } else if (!strcmp (input, "help")) { printf ("\n%s\n\n", divider); printf ("diagram/d: toggle diagram display\n"); printf ("exit/quit: terminate Faile\n"); printf ("go: make Faile play the side to move\n"); printf ("new: start a new game\n"); printf ("level <x>: the xboard style command to set time\n"); printf (" <x> should be in the form: <a> <b> <c> where:\n"); printf (" a -> moves to TC (0 if using an ICS style TC)\n"); printf (" b -> minutes per game\n"); printf (" c -> increment in seconds\n"); printf ("nodes: outputs the number of nodes searched\n"); printf ("nps: outputs Faile's NPS in search\n"); printf ("perft <x>: compute raw nodes to depth x\n"); printf ("post: toggles thinking output\n"); printf ("xboard: put Faile into xboard mode\n"); printf ("\n%s\n\n", divider); } else if (!xb_mode) { printf ("Illegal move: %s\n", input); } } } return 0; }
void pymatecorba_generate_iinterface_stubs(MateCORBA_IInterface *iface) { CORBA_TypeCode tc; PyObject *stub, *bases, *class_dict, *slots; PyObject **base_list; gint i, j, n_bases; init_hash_tables(); tc = iface->tc; /* has wrapper already been generated? */ if (g_hash_table_lookup(stubs, tc->repo_id)) return; /* create bases tuple */ base_list = g_new(PyObject *, iface->base_interfaces._length); for (i = 0; i < iface->base_interfaces._length; i++) { const gchar *base_repo_id = iface->base_interfaces._buffer[i]; PyObject *base = pymatecorba_get_stub_from_repo_id(base_repo_id); /* if we haven't wrapped the base, try and look it up */ if (!base) { MateCORBA_IInterface *base_iface; CORBA_Environment ev; CORBA_exception_init(&ev); base_iface = MateCORBA_small_get_iinterface(CORBA_OBJECT_NIL, base_repo_id, &ev); if (ev._major != CORBA_NO_EXCEPTION) { g_warning("repo id for base %s has not been registered", base_repo_id); CORBA_exception_free(&ev); for (j = 0; j < i; j++) Py_DECREF(base_list[j]); g_free(base_list); return; } CORBA_exception_free(&ev); /* generate interface, then get it */ pymatecorba_generate_iinterface_stubs(base_iface); base = pymatecorba_get_stub_from_repo_id(base_repo_id); if (!base) { g_warning("could not generate stub for base %s", base_repo_id); for (j = 0; j < i; j++) Py_DECREF(base_list[j]); g_free(base_list); return; } } Py_INCREF(base); base_list[i] = base; } /* get rid of unneeded bases */ n_bases = iface->base_interfaces._length; for (i = 0; i < iface->base_interfaces._length; i++) { for (j = 0; j < iface->base_interfaces._length; j++) { if (i == j) continue; /* if base[j] is a subclass of base[i], we can ignore [i] */ if (base_list[j] && PyType_IsSubtype((PyTypeObject *)base_list[j], (PyTypeObject *)base_list[i])) { Py_DECREF(base_list[i]); base_list[i] = NULL; n_bases--; break; } } } bases = PyTuple_New(n_bases); n_bases = 0; for (i = 0; i < iface->base_interfaces._length; i++) { if (base_list[i]) PyTuple_SetItem(bases, n_bases++, base_list[i]); } g_free(base_list); class_dict = PyDict_New(); slots = PyTuple_New(0); PyDict_SetItemString(class_dict, "__slots__", slots); Py_DECREF(slots); stub = PyObject_CallFunction((PyObject *)&PyType_Type, "sOO", tc->name, bases, class_dict); Py_DECREF(bases); Py_DECREF(class_dict); if (!stub) { g_message("couldn't build stub %s:", tc->name); PyErr_Print(); PyErr_Clear(); return; } pymatecorba_add_imethods_to_stub(stub, &iface->methods); add_stub_to_container(tc, tc->name, stub); pymatecorba_register_stub(tc, stub); }
void pymatecorba_generate_typecode_stubs(CORBA_TypeCode tc) { PyObject *stub = NULL; init_hash_tables(); switch (tc->kind) { case CORBA_tk_null: case CORBA_tk_void: case CORBA_tk_short: case CORBA_tk_long: case CORBA_tk_ushort: case CORBA_tk_ulong: case CORBA_tk_float: case CORBA_tk_double: case CORBA_tk_boolean: case CORBA_tk_char: case CORBA_tk_octet: case CORBA_tk_any: case CORBA_tk_TypeCode: case CORBA_tk_Principal: break; case CORBA_tk_objref: break; case CORBA_tk_struct: stub = generate_struct_stub(tc); break; case CORBA_tk_union: stub = generate_union_stub(tc); break; case CORBA_tk_enum: stub = generate_enum_stub(tc); break; case CORBA_tk_string: case CORBA_tk_sequence: case CORBA_tk_array: break; case CORBA_tk_alias: stub = pymatecorba_get_stub(tc->subtypes[0]); break; case CORBA_tk_except: stub = generate_exception_stub(tc); break; case CORBA_tk_longlong: case CORBA_tk_ulonglong: case CORBA_tk_longdouble: case CORBA_tk_wchar: case CORBA_tk_wstring: case CORBA_tk_fixed: case CORBA_tk_value: case CORBA_tk_value_box: case CORBA_tk_native: case CORBA_tk_abstract_interface: break; } if (stub) add_stub_to_container(tc, tc->name, stub); pymatecorba_register_stub(tc, stub); }