/************************************************** * * FUNCTION: * unload_tables - "Unload Tables" * * DESCRIPTION: * Unloads (frees) the symbol table * **************************************************/ void unload_tables ( void ) { free_map( __keyword_table ); free_map( __id_table ); } /*unload_tables() */
struct bitmap * and_bitmap(struct bitmap *left, struct bitmap *right) { struct bitmap **rightmp, *lmap, *rmap, **leftmp; int i; int sig; for (leftmp = &left; (lmap = *leftmp);) { sig = 0; for (rightmp = &right; (rmap = *rightmp); rightmp = &rmap->m_next) if (rmap->m_page == lmap->m_page) { for (i = 0; i < MDATA; ++i) sig |= (lmap->m_data[i] &= rmap->m_data[i]); *rightmp = rmap->m_next; free((char *)rmap); break; } if (rmap && sig) { leftmp = &lmap->m_next; } else { *leftmp = lmap->m_next; free((char *)lmap); } } free_map((struct map *)right); return simplify_bitmap(left); }
int key_hook(int keycode, t_mapinfo *map) { t_mapinfo mapcpy; mapcpy = *map; mapcpy.points = ft_mapcopy(map); if (keycode == 53) exit(0); else if (keycode == 15) key_reset(map); else if (keycode >= 0 && keycode <= 14) key_rot(keycode, map); else if (keycode >= 123 && keycode <= 126) key_scale(keycode, map); mlx_clear_window(0, map->win); scale_points(&mapcpy, mapcpy.scale_x, mapcpy.scale_y); rotate_x(map->rot_x, &mapcpy); rotate_y(map->rot_y, &mapcpy); rotate_z(map->rot_z, &mapcpy); ft_centremap(&mapcpy); ft_draw_map(mapcpy); free_map(mapcpy); if (keycode == 15 || keycode == 34) ft_draw_instruct(*map); //ft_putnbr(keycode); //ft_putchar('\n'); return (0); }
int main(int ac, char **av) { t_fileinfo finfo; char **patern; int **map; int fd; int max_diag; if (ac != 2) { my_printf("Usage : \"Program\" \"Map\"\n"); return (1); } if ((fd = open(av[1], O_RDONLY)) == -1) return (1); patern = get_patern(fd, &finfo); map = create_map(&finfo, patern); max_diag = max_square(map, &finfo); change_sqrmap(map, &finfo, max_diag); draw_final_map(map, &finfo); close(finfo.fd); free_patern(patern, &finfo); free_map(map, &finfo); return (0); }
void select_level(void) { t_uint i; t_lmap *map; int x; x = 0; i = 0; if (g_arka.map_count == 0) return ; map = g_arka.map_list; while (i != g_arka.menu.selection) { i++; map = map->next; } g_arka.current_map = map; if (g_arka.map) x = 1; free_map(g_arka.map); g_arka.map = parse_map(map->path); recreate(); g_arka.players[0]->life = 3; g_arka.players[0]->score = 0; resume_game(); }
void reset_game(void) { t_link *l; t_users *u; int seed; printf("Team %s won!\n", g_info.winner->name); lookup(g_info.users, graphics_seg(g_info.winner->name), ¬ify_graphic); while ((l = lookup_and_pop(g_info.users, NULL, &find_player)) != NULL) { u = (t_users*)l->ptr; u->team->free_slots = g_info.world.clients_per_team; u->team->nb_max_lvl = 0; lookup(g_info.users, graphics_pdi(u), ¬ify_graphic); delete_link(l, &free_users); } free_map(g_info.map); if (g_info.world.seed_spec == true) seed = g_info.world.seed; else seed = time(NULL); if ((g_info.map = generate_map(g_info.world.x, g_info.world.y, seed)) == NULL) leave("Failed to generate map"); g_info.winner = NULL; g_info.end_game = false; log_msg(stdout, "Game restarted!\n"); }
struct map * copy_map(struct map *parm) { struct bitmap *result, **mpp, *map; #ifdef MAP_DEBUG if (Mflag) { printf("copymap:"); print_map(parm); printf("\n"); } #endif map = MAP(parm); for (mpp = &result; (*mpp = 0), map; map = map->m_next) { *mpp = (struct bitmap *)malloc(sizeof **mpp); if (!*mpp) { #ifdef MAP_DEBUG if (Mflag) printf("copy_map: out of memory\n"); #endif free_map((struct map *)result); result = 0; break; } **mpp = *map; mpp = &(*mpp)->m_next; } if (NEGMAP(parm)) return NOT_MAP(result); else return (struct map *)result; }
int clean_map(Map *map, int map_max) { int map_ctr; for (map_ctr = 0; map_ctr < map_max; map_ctr++) { if (free_map(map + map_ctr)) return 1; } free(map); return 0; }
struct map * add_map(struct map *parm, int node) { struct bitmap *map; int bit; int x, page; #ifdef MAP_DEBUG if (Aflag) { printf("add_map: adding %d to [", node); print_map(parm); printf(" ] "); } #endif bit = NUMBERTOBIT(node); x = NUMBERTOINDEX(node); page = NUMBERTOPAGE(node); bit = 1L << bit;; for (map = MAP(parm); map; map = map->m_next) if (map->m_page == page) break; if (!map) { map = (struct bitmap *)malloc(sizeof *map); if (!map) { #ifdef PRINT_MAP_ERROR printf("No memory!\n"); #endif free_map((struct map *)map); return 0; } map->m_page = page; memset( map->m_data, 0, sizeof map->m_data); if (NEGMAP(parm)) { int i; for (i = 0; i < MDATA; ++i) map->m_data[i] = ~0; } map->m_next = MAP(parm); if (POSMAP(parm)) parm = (struct map *)map; else parm = NOT_MAP(map); } if (POSMAP(parm)) map->m_data[x] |= bit; else map->m_data[x] &= ~bit; #ifdef MAP_DEBUG if (Aflag) { printf(" ->"); print_map(parm); printf("\n"); } #endif return (struct map *)parm; }
/* Frees memory. The amount of memory returned to OS depends on compiler trip settings. */ VALUE bm_reset(VALUE self) { Bitmapper* map; VALUE len; Data_Get_Struct(self, Bitmapper, map); free_map(map); len = rb_iv_get(self, "@index_len"); allocate_map(map, FIX2INT(len)); return self; }
void close_ekf() { free(vectR); free_map(); mFree(mQ,U_SIZE); mFree(mV,X_SIZE); mFree(mPpred,X_SIZE); mFree(mPcorr,X_SIZE); }
void destroy_opengl(t_gl *gl) { glfwDestroyWindow(gl->window); glfwTerminate(); free_map(gl); free(gl->titre); gl->titre = NULL; get_glide(1); }
int main() { int exit = 0; int snum; LINE_LOOP *map = load_map("map.txt", &snum, 0.2); init(); float cam_x = 0.0, cam_y = 2.0, cam_z = 30.0, cam_ax = 0.0, cam_ay = 0.0; printf("%d %d", sizeof(float), sizeof(float *)); while(!exit) { VECTOR cam_dir = vector(SPEED * cos(M_PI * 0.5 - cam_ay * M_PI / 180.0), SPEED * sin(cam_ay * M_PI / 180.0 - M_PI * 0.5)); int mx, my; get_mouse_mickeys(&mx, &my); //position_mouse(240, 320); cam_ay += mx * 0.03; cam_ax -= my * 0.03; if(cam_ax > 60) cam_ax = 60; if(cam_ax < -40) cam_ax = -40; if(keypressed()) { if(key[KEY_ESC]) { exit = 1; } if(key[KEY_W]) { cam_x += cam_dir.x*10.0; cam_z += cam_dir.y*10.0; } if(key[KEY_S]) { cam_x -= cam_dir.x*10.0; cam_z -= cam_dir.y*10.0; } if(key[KEY_A]) { cam_x += cam_dir.y*10.0; cam_z += -cam_dir.x*10.0; } if(key[KEY_D]) { cam_x -= cam_dir.y*10.0; cam_z -= -cam_dir.x*10.0; } if(key[KEY_LEFT]) { cam_ay -= 0.09; } if(key[KEY_RIGHT]) { cam_ay += 0.09; } if(key[KEY_PGDN]) { cam_ax -= 0.09; } if(key[KEY_PGUP]) { cam_ax += 0.09; } } glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); transform(-cam_x, -cam_y, -cam_z, -cam_ax, cam_ay, 0.0); glBegin(GL_QUADS); glColor3ub(128, 128, 128); glVertex3f(-300.0, 0.0, 300.0); glVertex3f(300.0, 0.0, 300.0); glVertex3f(300.0, 0.0, -300.0); glVertex3f(-300.0, 0.0, -300.0); draw_map_3d(map, snum); glEnd(); allegro_gl_flip(); } free_map(map, snum); readkey(); return 0; }
void destroy(t_server *server) { free_teams(server->teams); free_clients(server->clients); free_map(server->map); free(server); printf("Bye.\n"); }
int ntk_free_maps(void) { bmap_levels_free(me.bnode_map, me.bmap_nodes); bmap_counter_free(me.bmap_nodes_closed, me.bmap_nodes_opened); free_extmap(me.ext_map, FAMILY_LVLS, 0); free_map(me.int_map, 0); return 0; }
struct map * read_map(int (*f) (void *), char *arg) { struct bitmap *map, *result, **mp; int page; int bitno, lastno; int data; /* count, then startbitno, then bits. */ lastno = ((*f) (arg)); if (lastno == -1) return 0; if (lastno & ((1 << LSHIFT) - 1)) { #ifdef PRINT_MAP_ERROR printf("read_map: bad count\n"); #endif return 0; } bitno = ((*f) (arg)); if (bitno & ((1 << LSHIFT) - 1)) { #ifdef PRINT_MAP_ERROR printf("read_map: bad start\n"); #endif return 0; } lastno += bitno; map = result = 0; for (; bitno < lastno; bitno += (1 << LSHIFT)) { data = (*f) (arg); if (!data) continue; page = NUMBERTOPAGE(bitno); if (!map || map->m_page != page) for (mp = &result; (map = *mp); mp = &map->m_next) if (map->m_page == page) break; if (!map) { map = (struct bitmap *)malloc(sizeof *map); if (!map) { #ifdef PRINT_MAP_ERROR printf("No memory!\n"); #endif if (result) free_map((struct map *)result); return 0; } memset( map->m_data, 0, sizeof map->m_data); map->m_page = page; map->m_next = 0; *mp = map; } map->m_data[NUMBERTOINDEX(bitno)] = data; } return (struct map *)result; }
int main( int argc, char **argv){ int c_height,c_width; map_t *map; map = NULL; c_height = 0; c_width = 0; if(argc < 4){ printf("Usage: mars <map> <court width> <court height> \n"); }else{ c_height = atoi(argv[3]); c_width = atoi(argv[2]); map = ld_map_img(argv[1]); } map->c_width = c_width; map->c_height = c_height; map->min = map_min(map); map->max = map_max(map); map->count = count(map); /*if(chk_slope_map(map)){ printf("Yay, it's right!\n"); }*/ int k; map_t *best; map_t *current; best = new_map(map->side); best->cost = 1000000; //find_best(map); for(k=1; k<256; k++){ current = test_pos(map,k,13,509); current->cost = cost(map,current); printf("%ld\t%d\n",current->cost,k); if(current->cost < best->cost){ free_map(best); best = current; best->cost = cost(map,best); best->h = k; } } printf("%ld (%d,%d,%d)\n",best->cost,best->x,best->y,best->h); exit(1); }
static void clean_main(struct sb *sb, struct inode *inode) { log_finish(sb); log_finish_cycle(sb, 1); free_map(inode->map); destroy_defer_bfree(&sb->derollup); destroy_defer_bfree(&sb->defree); tux3_clear_dirty_inode(sb->logmap); invalidate_buffers(sb->volmap->map); tux3_clear_dirty_inode(sb->volmap); put_super(sb); tux3_exit_mem(); }
int main(int argc, const char *const argv[]) { int err, ret = EXIT_FAILURE; FILE *f, *infile = stdin; double start, end; unsigned int nnodes; struct node *nodes; if (argc != 3) usage(); f = fopen(argv[1], "r"); if (!f) { perror("Error opening data file"); return EXIT_FAILURE; } if (strcmp(argv[2], "-") != 0) { infile = fopen(argv[2], "r"); if (!infile) { perror("Error opening data file"); fclose(f); return EXIT_FAILURE; } } start = get_current_seconds(); err = load_map(f, &nodes, &nnodes); if (err) goto out_map; end = get_current_seconds(); fclose(f); if (err) return EXIT_FAILURE; printf("Loaded %d nodes in %f seconds\n", nnodes, end - start); printf("Using %d MB\n", peak_memory_usage()); err = input_and_search(infile, nodes, nnodes); if (err) goto out; printf("Peak memory usage %d MB\n", peak_memory_usage()); ret = EXIT_SUCCESS; out: free_map(nodes, nnodes); out_map: if (infile != stderr) fclose(infile); return ret; }
t_map *solve(t_list *list) { t_map *map; int size; size = high_sqrt(ft_lstcount(list) * 4); map = map_new(size); while (!solve_map(map, list)) { size++; free_map(map); map = map_new(size); } return (map); }
int free_all(t_server *server, int const ret_value) { if (!server) return (ret_value); free_list(server->data.eggs, ret_value); free_teams(server->data.teams, ret_value); free_clients(server->queue_clients, 0, ret_value); free_clients(server->graphic_clients, 0, ret_value); free_clients(server->all_players, 1, ret_value); free_int_tab(server->data.required_players, ret_value); free_int_tab(server->data.ports, ret_value); free_int_tab(server->socks, ret_value); free_double_int_tab(server->data.resources, ret_value); free(server->data.timers); return (free_map(server->data.map, ret_value)); }
/* * Automount interface to RPC lookup routine * Find the corresponding entry and return * the file handle for it. */ am_node * amfs_generic_lookup_child(am_node *mp, char *fname, int *error_return, int op) { am_node *new_mp; am_loc **al_array; dlog("in amfs_generic_lookup_child"); *error_return = 0; new_mp = amfs_lookup_node(mp, fname, error_return); /* return if we got an error */ if (!new_mp || *error_return > 0) return new_mp; /* also return if it's already mounted and known to be up */ if (*error_return == 0 && FSRV_ISUP(new_mp->am_al->al_mnt->mf_server)) return new_mp; switch (op) { case VLOOK_DELETE: /* * If doing a delete then don't create again! */ ereturn(ENOENT); case VLOOK_LOOKUP: return new_mp; } al_array = amfs_lookup_loc(new_mp, error_return); if (!al_array) { new_mp->am_error = new_mp->am_al->al_mnt->mf_error = *error_return; free_map(new_mp); return NULL; } /* store the array inside the am_node */ new_mp->am_alarray = al_array; /* * Note: while it might seem like a good idea to prioritize * the list of mntfs's we got here, it probably isn't. * It would ignore the ordering of entries specified by the user, * which is counterintuitive and confusing. */ return new_mp; }
int load_map(t_engine *e) { t_coord pos; if (e->scales) free_map(e); e->scales = (t_scale**)xmalloc(sizeof(*e->scales) * e->map_data.h); e->entity = 0; for (pos.y = 0; pos.y < e->map_data.h; pos.y++) { e->scales[pos.y] = (t_scale*)xmalloc(sizeof(**e->scales) * e->map_data.w); for (pos.x = 0; pos.x < e->map_data.w; pos.x++) { if (!(e->scales[pos.y][pos.x].land = get_land(e, e->map_data.data[pos.y][pos.x].land))) { fprintf(fd_log, "Land unknown x:%d, y:%d, land:%d\n", pos.x, pos.y, e->map_data.data[pos.y][pos.x].land); exit(1); } e->scales[pos.y][pos.x].idgfxentity = create_gfx_entity(e->scales[pos.y][pos.x].land->idsprite); memset(e->scales[pos.y][pos.x].tab, 0, MAX_ENTITY_ON_SCALE * sizeof(t_entity*)); memset(e->scales[pos.y][pos.x].coord, 0, MAX_ENTITY_ON_SCALE * sizeof(t_coord)); if (e->map_data.data[pos.y][pos.x].item) if (!get_entity(e, e->map_data.data[pos.y][pos.x].item, pos)) fprintf(fd_log, "error on map (unknown entity %d)\n", e->map_data.data[pos.y][pos.x].item); e->scales[pos.y][pos.x].fog = (unsigned char*)xmalloc(sizeof(*e->scales[pos.y][pos.x].fog) * e->map_data.nb_players); memset(e->scales[pos.y][pos.x].fog, FOG_BLACK, e->map_data.nb_players * sizeof(*e->scales[pos.y][pos.x].fog)); memset(e->scales[pos.y][pos.x].tab_ephemere, 0, MAX_EPHEM * sizeof(t_instant*)); memset(e->scales[pos.y][pos.x].coord_ephemere, 0, MAX_EPHEM * sizeof(t_coord)); } } return (0); }
void free_world( WORLD *world ) { FIELD *field; while ((field = (FIELD *) LIST_HEAD(&world->fieldList)) != NULL) { listRemove(&world->fieldList, (LIST_NODE *) field); free(field); } free(world->world_map); free_map(world->map); free_sprite(world->tiles); free(world); }
int main(int ac, char **av) { t_win win; if ((win.win = bunny_start(W_X, W_Y, false, "wolfd3d")) == NULL) return (1); if ((win.array = bunny_new_pixelarray(W_X, W_Y)) == NULL) return (1); if (ac == 2 && set_data(av[1], "level1", &win) == -1) return (1); else if (ac != 2 && set_def_map(&win) == 1) return (1); set_cols(&win); bunny_set_key_response(&press_key); bunny_set_loop_main_function(mainloop); bunny_loop(win.win, 60, &win); free_map(&win.map); bunny_delete_clipable(&win.array->clipable); bunny_stop(win.win); return (0); }
int list_shutdown (List_of_maps * list, int fake) { if ( !list || !list->map ) return 0; int map_ctr; if ( fake ) { for ( map_ctr= 0; map_ctr< list->no_maps_used; map_ctr++) { Map *current_map = list->map + map_ctr; if (current_map->x2y_residue_level ) free (current_map->x2y_residue_level); if (current_map->y2x_residue_level ) free (current_map->y2x_residue_level); } } else { for ( map_ctr= 0; map_ctr< list->no_maps_allocated; map_ctr++) { if ( free_map(list->map+map_ctr) ) return 1; } } free (list->map_best); free (list->map); list->map = NULL; return 0; }
/** * Remove a mapping from the gateway * * All channel pointers in gw->pm[] higher than this one are shifted down by * one position and the array is shrunk appropriately. The map is freed, which * closes all channels that may still be associated with it. * * @map The map to delete * @return Nothing, anything that goes wrong exits the program */ void remove_map_from_gw(struct static_port_map *map) { struct gw_host *gw = map->parent; int i; for(i = 0; i < gw->n_maps; i++) if(map == gw->pm[i]) break; if(i == gw->n_maps) log_exit(FATAL_ERROR, "Error: map %p not found in gw->pm (%p)", map, gw->pm); if(gw->n_maps >= 1) { while(i < gw->n_maps - 1) { gw->pm[i] = gw->pm[i + 1]; i++; } gw->n_maps--; free_map(map); } }
void am_unmounted(am_node *mp) { mntfs *mf = mp->am_mnt; if (!foreground) /* firewall - should never happen */ return; /* * Do unmounted callback */ if (mf->mf_ops->umounted) (*mf->mf_ops->umounted) (mp); /* * Update mtime of parent node */ if (mp->am_parent && mp->am_parent->am_mnt) mp->am_parent->am_fattr.na_mtime.nt_seconds = clocktime(); free_map(mp); }
/* bit set in left, but not in right */ struct bitmap * bic_bitmap(struct bitmap *left, struct bitmap *right) { struct bitmap **rightmp, *lmap, *rmap, **leftmp; int i; int sig; #ifdef MAP_DEBUG if (Mflag) { printf("bic_bitmap: left=%#lx right=%#lx\n", (long)left, (long)right); } #endif for (leftmp = &left; (lmap = *leftmp);) { sig = 0; for (rightmp = &right; (rmap = *rightmp); rightmp = &rmap->m_next) if (rmap->m_page == lmap->m_page) { for (i = 0; i < MDATA; ++i) sig |= (lmap->m_data[i] &= ~rmap->m_data[i]); *rightmp = rmap->m_next; free((char *)rmap); break; } if (!rmap || sig) { leftmp = &lmap->m_next; } else { *leftmp = lmap->m_next; free((char *)lmap); } } free_map((struct map *)right); left = simplify_bitmap(left); #ifdef MAP_DEBUG if (Mflag) { printf("bic_bitmap: result=%#lx\n", (long) left); } #endif return left; }
void launch2(t_info *info, int n_path) { int compteur; int i; int tot; int tmp; tmp = info->nb_ants; i = 0; compteur = 0; tot = 0; while (i < n_path) tot += info->tab[i++]; i = 0; tmp -= tot; while (compteur < tmp) { i = -1; while (info->tab[++i] && compteur++ < tmp) info->tab[i]++; } free_map(info->list_line, info->list, info); cross_path(info, n_path); }