static void build_table(BiTreeNode *node, unsigned short code, unsigned char size, HuffCode *table) { if (!bitree_is_eob(node)) { if (!bitree_is_eob(bitree_left(node))) { /*********************************************************************** * * * Move to the left and append 0 to the current code. * * * ***********************************************************************/ build_table(bitree_left(node), code << 1, size + 1, table); } if (!bitree_is_eob(bitree_right(node))) { /*********************************************************************** * * * Move to the right and append 1 to the current code. * * * ***********************************************************************/ build_table(bitree_right(node), (code << 1) | 0x0001, size + 1, table); } if (bitree_is_eob(bitree_left(node))&&bitree_is_eob(bitree_right(node))) { /*********************************************************************** * * * Ensure that the current code is in big-endian format. * * * ***********************************************************************/ code = htons(code); /*********************************************************************** * * * Assign the current code to the symbol in the leaf node. * * * ***********************************************************************/ table[((HuffNode *)bitree_data(node))->symbol].used = 1; table[((HuffNode *)bitree_data(node))->symbol].code = code; table[((HuffNode *)bitree_data(node))->symbol].size = size; } } return; }
static void initialize(void) { int attr; attr = doublebuffer ? RGBA_DB_attributes : RGBA_SB_attributes; glutInitDisplayMode(attr); glutInitWindowSize(300, 240); glutCreateWindow("Ideas"); if (multisample) glEnable(GL_POLYGON_SMOOTH); init_lights(); init_materials(); build_table(); view_from_spline = calc_spline_params(view_from_ctl, TIME); view_to_spline = calc_spline_params(view_to_ctl, TIME); light_pos_spline = calc_spline_params(light_pos_ctl, TIME); logo_pos_spline = calc_spline_params(logo_pos_ctl, TIME); logo_rot_spline = calc_spline_params(logo_rot_ctl, TIME); glutReshapeFunc(resize_window); glutDisplayFunc(display); glutMouseFunc(mouse); glutKeyboardFunc(keyboard); glutVisibilityFunc(vis); glMatrixMode(GL_MODELVIEW); }
/// Generates the truth table. void MainWindow::generate() { delete_columns(); get_variables(); FunctionParser p; switch(m_mode) { case Function: char func[128]; Edit_GetText(m_hWndFunction, func, 128); try { p = FunctionParser(m_variables, func); } catch(FunctionParser::FunctionParserException& e) { MessageBox(e.what(), "Function Parser Error", MB_OK | MB_ICONERROR); return; } build_table(&p); break; case Minterm: break; case Maxterm: break; } }
/* * TODO: output the table (possibly merged), in the input format */ int main (int argc, char* argv []) { init_table (); if (argc == 2) { /* useful to get a new file when some opcodes are added: looses the comments, though */ load_file (argv [1]); dump (); } else if (argc < 4) { g_print ("Usage: genmdesc arguments\n"); g_print ("\tgenmdesc desc Output to stdout the description file.\n"); g_print ("\tgenmdesc [--nacl] output name desc [desc1...]\n" " Write to output the description in a table named 'name',\n" " use --nacl to generate Google NativeClient code\n"); return 1; } else { int i = 3; if (strcmp (argv [1], "--nacl") == 0) { nacl = 1; i++; } for (; i < argc; ++i) load_file (argv [i]); build_table (argv [1 + nacl], argv [2 + nacl]); } return 0; }
int main() { char str[max]={'\0'}; //printf("Enter the string :"); strcat(str,"(a|b|c|d|e|f|g|h|i|j|k|l|m|n|o|p|q|r|s|t|u|v|w|x|y|z)"); strcat(str,"(A|B|C|D|E|F|G|H|I|J|K|L|M|N|O|P|Q|R|S|T|U|V|W|X|Y|Z)"); strcat(str,"(1|2|3|4|5|6|7|8|9)"); //strcat(str,"(!|@|#|$|%|^|&|&|*)"); //strcat(str,"(A|B|C|D|E|F|G|H|I|J|K|L|M|N|O|P|Q|R|S|T|U|V|W|X|Y|Z)"); //gets(str); //printf("You entered :%s\n",input_str); int len=0,i=0; //compute length while(str[i]!='\0'){ if(str[i]==')') len++; i++; } //printf("Number of sequences :%d\n",len); struct str_table table[len],*ptr; ptr=table; build_table(str,ptr); ptr=table; //print_str(ptr,len); ptr=table; build_combinations(ptr,len); return 0; }
int main(int argc, char *argv[]) { int i; prog=argv[0]; argv++; /* * Load user set keyvals */ while(argv[0] && strcmp(argv[0],"-p")==0) { int o,n; argv++; if(argv[0]==NULL || sscanf(argv[0], "%d=%d", &o, &n)!=2) usage(); if(o < TABLE_SIZE) table[o]=n; argv++; } if(argv[0]==NULL) usage(); load_map(&def,argv[1] ? argv[0] : NULL); load_map(&kbd,argv[1] ? argv[1] : argv[0]); build_table(map_names); for (i = 0; i < 256; i++) { printf("%c",table[i] ? table[i] : i); } return 0; }
void populate_menu (charpick_data *curr_data) { GList *list = curr_data->chartable; GSList *group = NULL; GtkMenu *menu; GtkWidget *menuitem; if (curr_data->menu) gtk_widget_destroy (curr_data->menu); curr_data->menu = gtk_menu_new (); menu = GTK_MENU (curr_data->menu); while (list) { gchar *string = list->data; menuitem = gtk_radio_menu_item_new_with_label (group, string); group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (menuitem)); gtk_widget_show (menuitem); g_object_set_data (G_OBJECT (menuitem), "string", string); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK (menuitem_activated), curr_data); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); if (g_ascii_strcasecmp (curr_data->charlist, string) == 0) gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menuitem), TRUE); list = g_list_next (list); } build_table(curr_data); }
static int cleanup_table_and_chains(void) { struct nftnl_table *table; struct mnl_socket *nl; int err; DBG(""); err = socket_open_and_bind(&nl); if (err < 0) return -ENOMEM; /* * Cleanup everythying in one go. There is little point in * step-by-step removal of rules and chains if you can get it * as simple as this. */ /* * # nft delete table connman */ table = build_table(CONNMAN_TABLE, NFPROTO_IPV4); err = table_cmd(nl, table, NFT_MSG_DELTABLE, NFPROTO_IPV4, NLM_F_ACK); mnl_socket_close(nl); return err; }
bool SQLite3DB::check_and_build_table(char *table_name, char *table_def) { int rci; bool rcb; rci=check_table_structure(table_name,table_def); if (rci) return true; rcb=build_table(table_name,table_def,true); return rcb; }
void set_goal(char* goal) { int i; build_table(); for (i=0; i<20; ++i) sscanf(goal+(2*i), "%02x", (unsigned int *) &GOAL[i]); }
void config_parser_t::initialize() { if(initialized) return; init(); set_defaults(); build_table(); initialized = 1; }
int main(int argc, char* argv[]){ int n; float **table; while(scanf("%d", &n) != -1){ table = build_table(n); solve(table, n); } return 0; }
static void applet_change_orient(MatePanelApplet *applet, MatePanelAppletOrient o, gpointer data) { charpick_data *curr_data = data; if (o == MATE_PANEL_APPLET_ORIENT_UP || o == MATE_PANEL_APPLET_ORIENT_DOWN) curr_data->panel_vertical = FALSE; else curr_data->panel_vertical = TRUE; build_table (curr_data); return; }
void tree_item_selected( GtkWidget* item ) { gchar* current_path = context.current_path; memset( current_path, 0, PAKFile::MAX_FILENAMESIZE ); if( GTK_TREE( item->parent )->level != 0 ) { walk_up_tree( item ); } build_table( ); }
/* Name: * Description: * Inputs: * Outputs: */ void Stepper::NewAccelTable() { my_accel_tbl = new unsigned short [table_size]; build_table(GetStartPeriod(), GetSlewPeriod()); fs_etpu_sm_table(master_channel, my_accel_tbl); if(my_output_mode != ECE315_ETPU_SM_FULL_STEP_MODE) fs_etpu_sm_table(master_channel+2, my_accel_tbl); delete my_accel_tbl; }
void SPHSystem::animation() { if(sys_running == 0) { return; } build_table(); comp_dens_pres(); comp_force_adv(); advection(); }
static void create_page (GnomeDesktopItem *item, GtkWidget *box) { GtkWidget *table; GList *entries; GnomeDesktopItemType item_type; GtkLabel *label; entries = NULL; label = g_object_get_data (G_OBJECT (box), "label"); item_type = gnome_desktop_item_get_entry_type (item); if (item_type == GNOME_DESKTOP_ITEM_TYPE_LINK) { entries = g_list_prepend (entries, item_entry_new (GNOME_DESKTOP_ITEM_COMMENT, _("Comment"), TRUE, FALSE)); entries = g_list_prepend (entries, item_entry_new (GNOME_DESKTOP_ITEM_URL, _("URL"), FALSE, TRUE)); entries = g_list_prepend (entries, item_entry_new (GNOME_DESKTOP_ITEM_GENERIC_NAME, _("Description"), TRUE, FALSE)); gtk_label_set_text (label, _("Link")); } else if (item_type == GNOME_DESKTOP_ITEM_TYPE_APPLICATION) { entries = g_list_prepend (entries, item_entry_new (GNOME_DESKTOP_ITEM_COMMENT, _("Comment"), TRUE, FALSE)); entries = g_list_prepend (entries, item_entry_new (GNOME_DESKTOP_ITEM_EXEC, _("Command"), FALSE, FALSE)); entries = g_list_prepend (entries, item_entry_new (GNOME_DESKTOP_ITEM_GENERIC_NAME, _("Description"), TRUE, FALSE)); gtk_label_set_text (label, _("Launcher")); } else { /* we only handle launchers and links */ return; } gnome_desktop_item_ref (item); g_object_weak_ref (G_OBJECT (box), box_weak_cb, item); table = build_table (item, entries, 2); g_list_free (entries); gtk_box_pack_start (GTK_BOX (box), table, FALSE, TRUE, 0); gtk_widget_show_all (GTK_WIDGET (box)); }
std::string Director::create_html(Entries entries, const std::string& path) { std::ostringstream ss; ss << HTML_HEADER; ss << "<div class=\"container\">"; ss << "<h1 class=\"page-header\">" << path << "</h1>"; ss << "<div class=\"panel panel-default\">"; build_table(ss, entries, path); ss << "</div>"; // panel ss << "<hr/><h6 class=\"small\">Powered by <strong>IncludeOS</strong></h6>"; ss << "</div>"; // container ss << HTML_FOOTER; return ss.str(); }
static void create_page (GKeyFile *key_file, GtkWidget *box) { GtkWidget *table; GList *entries; GtkSizeGroup *label_size_group; char *type; entries = NULL; type = g_key_file_get_string (key_file, MAIN_GROUP, "Type", NULL); if (g_strcmp0 (type, "Link") == 0) { entries = g_list_prepend (entries, item_entry_new ("Comment", _("Comment"), TRUE, FALSE)); entries = g_list_prepend (entries, item_entry_new ("URL", _("URL"), FALSE, TRUE)); entries = g_list_prepend (entries, item_entry_new ("GenericName", _("Description"), TRUE, FALSE)); } else if (g_strcmp0 (type, "Application") == 0) { entries = g_list_prepend (entries, item_entry_new ("Comment", _("Comment"), TRUE, FALSE)); entries = g_list_prepend (entries, item_entry_new ("Exec", _("Command"), FALSE, FALSE)); entries = g_list_prepend (entries, item_entry_new ("GenericName", _("Description"), TRUE, FALSE)); } else { /* we only handle launchers and links */ /* ensure that we build an empty table with a dummy row at the end */ goto build_table; } g_free (type); build_table: label_size_group = g_object_get_data (G_OBJECT (box), "label-size-group"); table = build_table (box, key_file, label_size_group, entries); g_list_free (entries); gtk_box_pack_start (GTK_BOX (box), table, FALSE, TRUE, 0); gtk_widget_show_all (GTK_WIDGET (box)); }
static void menuitem_activated (GtkMenuItem *menuitem, charpick_data *curr_data) { gchar *string; MatePanelApplet *applet = MATE_PANEL_APPLET (curr_data->applet); string = g_object_get_data (G_OBJECT (menuitem), "string"); if (g_ascii_strcasecmp (curr_data->charlist, string) == 0) return; curr_data->charlist = string; build_table (curr_data); if (g_settings_is_writable (curr_data->settings, "current-list")) g_settings_set_string (curr_data->settings, "current-list", curr_data->charlist); }
int get_median_partition(t_list *lst, int size_partition) { int min; int max; int *t; int size; int median; size = build_table(lst, &t); //penser au pattern singleton hidden_quicksort(t, 0, size - 1); get_max_partition(lst, size_partition, &max); get_min_partition(lst, size_partition, &min); median = get_median(t, get_index_array(t, min, size), get_index_array(t, max, size)); return (median); }
static void applet_size_allocate(MatePanelApplet *applet, GtkAllocation *allocation, gpointer data) { charpick_data *curr_data = data; if (curr_data->panel_vertical) { if (curr_data->panel_size == allocation->width) return; curr_data->panel_size = allocation->width; } else { if (curr_data->panel_size == allocation->height) return; curr_data->panel_size = allocation->height; } build_table (curr_data); return; }
void populate_menu (charpick_data *curr_data) { GList *list = curr_data->chartable; GSList *group = NULL; GtkMenu *menu; GtkWidget *menuitem; if (curr_data->menu) gtk_widget_destroy (curr_data->menu); curr_data->menu = gtk_menu_new (); menu = GTK_MENU (curr_data->menu); while (list) { gchar *string = list->data; menuitem = gtk_radio_menu_item_new_with_label (group, string); group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (menuitem)); gtk_widget_show (menuitem); g_object_set_data (G_OBJECT (menuitem), "string", string); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK (menuitem_activated), curr_data); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); if (g_ascii_strcasecmp (curr_data->charlist, string) == 0) gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menuitem), TRUE); list = g_list_next (list); } build_table(curr_data); /*Set up custom theme and transparency support*/ GtkWidget *toplevel = gtk_widget_get_toplevel (GTK_WIDGET (menu)); /* Fix any failures of compiz/other wm's to communicate with gtk for transparency */ GdkScreen *screen = gtk_widget_get_screen(GTK_WIDGET(toplevel)); GdkVisual *visual = gdk_screen_get_rgba_visual(screen); gtk_widget_set_visual(GTK_WIDGET(toplevel), visual); /* Set menu and it's toplevel window to follow panel theme */ GtkStyleContext *context; context = gtk_widget_get_style_context (GTK_WIDGET(toplevel)); gtk_style_context_add_class(context,"gnome-panel-menu-bar"); gtk_style_context_add_class(context,"mate-panel-menu-bar"); }
/* * TODO: output the table (possibly merged), in the input format */ int main (int argc, char* argv []) { init_table (); if (argc == 2) { /* useful to get a new file when some opcodes are added: looses the comments, though */ load_file (argv [1]); dump (); } else if (argc < 4) { g_print ("Usage: genmdesc arguments\n"); g_print ("\tgenmdesc desc Output to stdout the description file.\n"); g_print ("\tgenmdesc output name desc [desc1...] Write to output the description in a table named 'name'.\n"); return 1; } else { int i; for (i = 3; i < argc; ++i) load_file (argv [i]); build_table (argv [1], argv [2]); } return 0; }
void SPHSystem::animation() { if(sys_running == 0) { return; } build_table(); if(sys_render == 1) { interp_scalar(); } if(enable_split == 1 && tick == 0 || enable_merge == 1 && tick == 1) { comp_scalar(); find_surface(); comp_dist(); //comp_energy(); } comp_dens_pres(); comp_force_adv(); if(enable_split == 1 && tick == 0) { comp_split(); } if(enable_merge == 1 && tick == 1) { comp_merge(); } advection(); tick=1-tick; }
int main() { build_table(); std::string input; while ( std::cin >> input ) { int n = std::stoi( input ); if ( table[ n ] > 0 ) { auto rev = input; std::reverse( rev.begin(), rev.end() ); n = std::stoi( rev ); if( rev != input && table[ n ] > 0 ) std::cout << input << " is emirp." << std::endl; else std::cout << input << " is prime." << std::endl; } else { std::cout << input << " is not prime." << std::endl; } } return 0; }
/* hash some C/C++ code after unifying */ static void unify(unsigned char *p, size_t size) { size_t ofs; unsigned char q; int i; build_table(); for (ofs=0; ofs<size;) { if (p[ofs] == '#') { if ((size-ofs) > 2 && p[ofs+1] == ' ' && isdigit(p[ofs+2])) { do { ofs++; } while (ofs < size && p[ofs] != '\n'); ofs++; } else { do { pushchar(p[ofs]); ofs++; } while (ofs < size && p[ofs] != '\n'); pushchar('\n'); ofs++; } continue; } if (tokens[p[ofs]].type & C_ALPHA) { do { pushchar(p[ofs]); ofs++; } while (ofs < size && (tokens[p[ofs]].type & (C_ALPHA|C_DIGIT))); pushchar('\n'); continue; } if (tokens[p[ofs]].type & C_DIGIT) { do { pushchar(p[ofs]); ofs++; } while (ofs < size && ((tokens[p[ofs]].type & C_DIGIT) || p[ofs] == '.')); if (ofs < size && (p[ofs] == 'x' || p[ofs] == 'X')) { do { pushchar(p[ofs]); ofs++; } while (ofs < size && (tokens[p[ofs]].type & C_HEX)); } if (ofs < size && (p[ofs] == 'E' || p[ofs] == 'e')) { pushchar(p[ofs]); ofs++; while (ofs < size && (tokens[p[ofs]].type & (C_DIGIT|C_SIGN))) { pushchar(p[ofs]); ofs++; } } while (ofs < size && (tokens[p[ofs]].type & C_FLOAT)) { pushchar(p[ofs]); ofs++; } pushchar('\n'); continue; } if (tokens[p[ofs]].type & C_SPACE) { do { ofs++; } while (ofs < size && (tokens[p[ofs]].type & C_SPACE)); continue; } if (tokens[p[ofs]].type & C_QUOTE) { q = p[ofs]; pushchar(p[ofs]); do { ofs++; while (ofs < size-1 && p[ofs] == '\\') { pushchar(p[ofs]); pushchar(p[ofs+1]); ofs+=2; } pushchar(p[ofs]); } while (ofs < size && p[ofs] != q); pushchar('\n'); ofs++; continue; } if (tokens[p[ofs]].type & C_TOKEN) { q = p[ofs]; for (i=0;i<tokens[q].num_toks;i++) { unsigned char *s = (unsigned char *)tokens[q].toks[i]; int len = strlen((char *)s); if (size >= ofs+len && memcmp(&p[ofs], s, len) == 0) { int j; for (j=0;s[j];j++) { pushchar(s[j]); ofs++; } pushchar('\n'); break; } } if (i < tokens[q].num_toks) { continue; } } pushchar(p[ofs]); pushchar('\n'); ofs++; } pushchar(0); }
constexpr constexpr_hashtable(const std::initializer_list<std::pair<Key,Value>> ls) : constexpr_hashtable(build_table(std::forward<decltype(ls)>(ls))) {}
void _initialize_mi_cmds (void) { build_table (mi_cmds); memset (&stats, 0, sizeof (stats)); }
void init(int cut, int alpha_) { alpha = alpha_; build_table(next[0], next[1], 4096, alpha_, 4096-cut); }