int map_set(map_t map, void *key, void *data, void **olddata)
{
bucket_t *b;
if (!map || !key)
return RETERROR(EINVAL, -1);
b = map_bucket_find(map, key);
if (b)
{
mem_init(olddata, b->data);
b->data = data;
}
else
{
int hash;
if (!map_resize(map, map->count + 1, 0))
return -1;
if (!(b = map_bucket_alloc(map, key, data)))
return -1;
hash = map->hashf(map->size, key);
b->next = map->buckets[hash];
map->buckets[hash] = b;
++ map->count;
}
return map->count;
}
t_status interface_map_resize(o_syscall* message)
{
t_status error;
t_vaddr result1;
error = map_resize(message->u.request.u.map_resize.arg1,
message->u.request.u.map_resize.arg2,
message->u.request.u.map_resize.arg3,
&result1);
message->u.reply.error = error;
message->u.reply.u.map_resize.result1 = result1;
return (STATUS_OK);
}
st_map_t *
map_put (st_map_t *map, void *key, void *object)
{
int n = 0;
while (n < map->size && map->data[n].key != MAP_FREE_KEY &&
map->cmp_key (map->data[n].key, key))
n++;
if (n == map->size) // current map is full
map = map_resize (map, map->size + 20);
map->data[n].key = key;
map->data[n].object = object;
return map;
}
int map_clear(map_t map, int newsize)
{
int i;
bucket_t *b;
if (!map || !newsize)
return RETERROR(EINVAL, -1);
for (i = 0; i < map->size; ++i)
{
b = map->buckets[i];
while (b)
b = map_bucket_free(map, b);
map->buckets[i] = 0;
}
DPRINT(("clear buckets table at %p\n", map->buckets));
map->count = 0;
return (map_resize(map, newsize, 1) > 0 ? 0 : -1);
}
int map_set_(map_base_t *m, const char *key, void *value, int vsize) {
int n, err;
map_node_t **next, *node;
/* Find & replace existing node */
next = map_getref(m, key);
if (next) {
memcpy((*next)->value, value, vsize);
return 0;
}
/* Add new node */
node = map_newnode(key, value, vsize);
if (node == NULL) goto fail;
if (m->nnodes >= m->nbuckets) {
n = (m->nbuckets > 0) ? (m->nbuckets << 1) : 1;
err = map_resize(m, n);
if (err) goto fail;
}
map_addnode(m, node);
m->nnodes++;
return 0;
fail:
if (node) free(node);
return -1;
}
static int
resize(gpt_t gpt, u_int entry, off_t alignment, off_t sectors, off_t size)
{
map_t map;
struct gpt_hdr *hdr;
struct gpt_ent *ent;
unsigned int i;
off_t alignsecs, newsize;
uint64_t end;
if ((hdr = gpt_hdr(gpt)) == NULL)
return -1;
i = entry - 1;
ent = gpt_ent_primary(gpt, i);
if (gpt_uuid_is_nil(ent->ent_type)) {
gpt_warnx(gpt, "Entry at index %u is unused", entry);
return -1;
}
alignsecs = alignment / gpt->secsz;
for (map = map_first(gpt); map != NULL; map = map->map_next) {
if (entry == map->map_index)
break;
}
if (map == NULL) {
gpt_warnx(gpt, "Could not find map entry corresponding "
"to index");
return -1;
}
if (sectors > 0 && sectors == map->map_size)
if (alignment == 0 ||
(alignment > 0 && sectors % alignsecs == 0)) {
/* nothing to do */
gpt_warnx(gpt, "partition does not need resizing");
return 0;
}
newsize = map_resize(gpt, map, sectors, alignsecs);
if (newsize == -1)
return -1;
end = htole64((uint64_t)(map->map_start + newsize - 1LL));
ent->ent_lba_end = end;
if (gpt_write_primary(gpt) == -1)
return -1;
ent = gpt_ent(gpt->gpt, gpt->lbt, i);
ent->ent_lba_end = end;
if (gpt_write_backup(gpt) == -1)
return -1;
gpt_msg(gpt, "Partition %d resized: %" PRIu64 " %" PRIu64, entry,
map->map_start, newsize);
return 0;
}
int main(int argc, char* args[]) {
if (init() == FALSE) {
return 1;
}
if (load_files() == FALSE) {
return 1;
}
message = TTF_RenderText_Solid(font, window_footer_str, font_color);
if (message == NULL) {
return 1;
}
Uint32 frameStart = 0;
int rightMouseButtonDown = FALSE;
int quit = FALSE;
while (quit == FALSE) {
frameStart = SDL_GetTicks();
while (SDL_PollEvent(&event)) {
if (event.type == SDL_MOUSEBUTTONDOWN) {
if (event.button.button == SDL_BUTTON_RIGHT)
rightMouseButtonDown = TRUE;
else if (event.button.button == SDL_BUTTON_LEFT)
map_select_tile(event.button.x, event.button.y);
}
if (event.type == SDL_MOUSEBUTTONUP) {
if (event.button.button == SDL_BUTTON_RIGHT) {
rightMouseButtonDown = FALSE;
map_move_reset();
}
}
if (event.type == SDL_MOUSEMOTION) {
if (rightMouseButtonDown == TRUE) {
map_move(event.button.x, event.button.y);
}
}
if (event.type == SDL_KEYDOWN) {
switch (event.key.keysym.sym) {
case SDLK_g: map_toggle_grid(); break;
case SDLK_PLUS: map_resize(1); break;
case SDLK_MINUS: map_resize(-1); break;
case SDLK_l: map_load(); break;
default: ;
}
}
if (event.type == SDL_QUIT) {
quit = TRUE;
}
}
SDL_FillRect(screen, &screen->clip_rect, SDL_MapRGB(screen->format, 0, 0, 0));
map_show();
apply_surface(
screen_width - message->w, screen_height - message->h, message, screen
);
if (SDL_Flip(screen) == -1) {
return 1;
}
if ((SDL_GetTicks() - frameStart) < (1000 / FPS)) {
SDL_Delay((1000 / FPS) - (SDL_GetTicks() - frameStart));
}
}
clean_up();
return 0;
}
