server/src/attributes/key.c

336 lines
8 KiB
C
Raw Normal View History

2010-08-08 10:06:34 +02:00
#include <platform.h>
#include <kernel/config.h>
#include "key.h"
#include <kernel/attrib.h>
2018-09-29 13:21:46 +02:00
#include <kernel/gamedata.h>
2017-08-20 12:58:05 +02:00
#include <util/log.h>
#include <storage.h>
#include <errno.h>
#include <stdlib.h>
2016-02-09 13:56:57 +01:00
#include <string.h>
#include <assert.h>
static void a_writekeys(const variant *var, const void *o, storage *store) {
int i, *keys = (int *)var->v;
2017-08-20 12:58:05 +02:00
int n = 0;
if (keys) {
assert(keys[0] < 4096 && keys[0]>0);
n = keys[0];
}
WRITE_INT(store, n);
for (i = 0; i < n; ++i) {
WRITE_INT(store, keys[i * 2 + 1]);
WRITE_INT(store, keys[i * 2 + 2]);
}
}
2017-08-20 12:58:05 +02:00
static int keys_lower_bound(int *base, int k, int l, int r) {
int km = k;
int *p = base + 1;
while (l != r) {
int m = (l + r) / 2;
km = p[m * 2];
if (km < k) {
if (l == m) l = r;
else l = m;
}
else {
if (r == m) r = l;
else r = m;
}
}
return l;
}
static int keys_size(int n) {
/* TODO maybe use log2 from https://graphics.stanford.edu/~seander/bithacks.html#IntegerLog */
assert(n > 0 && n <= 4096);
if (n <= 1) return 1;
if (n <= 4) return 4;
if (n <= 8) return 8;
if (n <= 16) return 16;
if (n <= 256) return 256;
if (n <= 512) return 512;
if (n <= 1024) return 1024;
if (n <= 2048) return 2048;
return 4096;
}
static int read_flags(gamedata *data, int *keys, int n) {
int i;
for (i = 0; i != n; ++i) {
int key;
READ_INT(data->store, &key);
keys[i * 2] = key;
keys[i * 2 + 1] = 1;
}
return n;
}
#ifdef KEYVAL_VERSION
static int read_keyval(gamedata *data, int *keys, int n) {
int i;
for (i = 0; i != n; ++i) {
int key, val;
READ_INT(data->store, &key);
READ_INT(data->store, &val);
keys[i * 2] = key;
keys[i * 2 + 1] = val;
}
return n;
}
#endif
#ifdef FIXATKEYS_VERSION
static int read_keyval_orig(gamedata *data, int *keys, int n) {
int i, j = 0, dk = -1;
for (i = 0; i != n; ++i) {
int key, val;
READ_INT(data->store, &key);
READ_INT(data->store, &val);
if (key > dk) {
keys[j * 2] = key;
keys[j * 2 + 1] = val;
dk = key;
++j;
}
}
return j;
}
#endif
static int a_readkeys(variant *var, void *owner, gamedata *data) {
2018-12-02 11:13:58 +01:00
int n, ksn, *keys;
2017-08-20 12:58:05 +02:00
READ_INT(data->store, &n);
assert(n < 4096 && n >= 0);
if (n == 0) {
return AT_READ_FAIL;
}
ksn = keys_size(n);
keys = malloc((ksn * 2 + 1) * sizeof(int));
if (data->version >= FIXATKEYS_VERSION) {
n = read_keyval(data, keys + 1, n);
}
else if (data->version >= KEYVAL_VERSION) {
int m = read_keyval_orig(data, keys + 1, n);
if (n != m) {
int ksm = keys_size(m);
if (ksm != ksn) {
int *nkeys = (int *)realloc(keys, (ksm * 2 + 1) * sizeof(int));
if (nkeys != NULL) {
keys = nkeys;
}
else {
log_error("a_readkeys allocation failed: %s", strerror(errno));
return AT_READ_FAIL;
}
}
n = m;
}
}
else {
n = read_flags(data, keys + 1, n);
}
keys[0] = n;
2017-08-20 12:58:05 +02:00
if (data->version < SORTKEYS_VERSION) {
2018-12-02 11:13:58 +01:00
int i, e = 1;
2017-08-20 12:58:05 +02:00
for (i = 1; i != n; ++i) {
int k = keys[i * 2 + 1];
int v = keys[i * 2 + 2];
int l = keys_lower_bound(keys, k, 0, e);
if (l != e) {
int km = keys[l * 2 + 1];
if (km == k) {
int vm = keys[l * 2 + 2];
if (v != vm) {
log_error("key %d has values %d and %d", k, v, vm);
}
--e;
}
else {
if (e > l) {
memmove(keys + 2 * l + 3, keys + 2 * l + 1, (e - l) * 2 * sizeof(int));
}
keys[2 * l + 1] = k;
keys[2 * l + 2] = v;
}
}
++e;
}
if (e != n) {
int sz = keys_size(n);
if (e > sz) {
2017-11-20 14:44:02 +01:00
int *k;
sz = keys_size(e);
2017-11-20 14:44:02 +01:00
k = realloc(keys, sizeof(int)*(2 * sz + 1));
if (!k) {
free(keys);
abort();
}
keys = k;
keys[0] = e;
}
2017-08-20 12:58:05 +02:00
}
}
var->v = keys;
return AT_READ_OK;
}
static int a_readkey(variant *var, void *owner, struct gamedata *data) {
int res = a_readint(var, owner, data);
2017-08-20 12:58:05 +02:00
if (data->version >= KEYVAL_VERSION) {
return AT_READ_FAIL;
}
return (res != AT_READ_FAIL) ? AT_READ_DEPR : res;
}
attrib_type at_keys = {
"keys",
NULL,
a_free_voidptr,
NULL,
a_writekeys,
a_readkeys,
NULL
};
static void a_upgradekeys(attrib **alist, attrib *abegin) {
attrib *a, *ak;
ak = a_find(*alist, &at_keys);
if (ak) alist = &ak;
for (a = abegin; a && a->type == abegin->type; a = a->next) {
key_set(alist, a->data.i, 1);
2017-02-14 12:15:36 +01:00
}
}
2010-08-08 10:06:34 +02:00
attrib_type at_key = {
"key",
NULL,
NULL,
NULL,
NULL,
a_readkey,
a_upgradekeys
2010-08-08 10:06:34 +02:00
};
2017-08-20 12:58:05 +02:00
static int* keys_get(int *base, int i)
{
int n = base[0];
assert(i >= 0 && i < n);
return base + 1 + i * 2;
}
static int *keys_update(int *base, int key, int val)
{
int *kv;
int n = base[0];
int l = keys_lower_bound(base, key, 0, n);
if (l < n) {
kv = keys_get(base, l);
if (kv[0] == key) {
kv[1] = val;
}
else {
int sz = keys_size(n);
2017-08-20 12:58:05 +02:00
assert(kv[0] > key);
if (n + 1 > sz) {
2018-12-15 20:01:51 +01:00
int *tmp;
ptrdiff_t diff = kv - base;
sz = keys_size(n + 1);
2018-12-15 20:01:51 +01:00
tmp = realloc(base, (sz * 2 + 1) * sizeof(int));
if (!tmp) abort();
base = tmp;
kv = base + diff;
}
2017-08-20 12:58:05 +02:00
base[0] = n + 1;
memmove(kv + 2, kv, 2 * sizeof(int) * (n - l));
kv[0] = key;
kv[1] = val;
}
}
else {
int sz = keys_size(n);
if (n + 1 > sz) {
2018-11-26 22:07:55 +01:00
void * tmp;
sz = keys_size(n + 1);
2018-11-26 22:07:55 +01:00
tmp = realloc(base, (sz * 2 + 1) * sizeof(int));
if (!tmp) abort();
base = (int *)tmp;
}
2017-08-20 12:58:05 +02:00
base[0] = n + 1;
kv = keys_get(base, l);
kv[0] = key;
kv[1] = val;
}
return base;
}
void key_set(attrib ** alist, int key, int val)
{
2017-08-20 12:58:05 +02:00
int *keys;
attrib *a;
assert(key != 0);
a = a_find(*alist, &at_keys);
if (!a) {
a = a_add(alist, a_new(&at_keys));
}
keys = (int *)a->data.v;
2017-08-20 12:58:05 +02:00
if (!keys) {
int sz = keys_size(1);
a->data.v = keys = malloc((2 * sz + 1) * sizeof(int));
2018-12-15 20:01:51 +01:00
if (!keys) abort();
2017-08-20 12:58:05 +02:00
keys[0] = 1;
keys[1] = key;
keys[2] = val;
}
else {
a->data.v = keys = keys_update(keys, key, val);
assert(keys[0] < 4096 && keys[0] >= 0);
}
}
void key_unset(attrib ** alist, int key)
{
attrib *a;
assert(key != 0);
a = a_find(*alist, &at_keys);
if (a) {
2017-08-20 12:58:05 +02:00
int *keys = (int *)a->data.v;
if (keys) {
int n = keys[0];
2017-08-20 12:58:05 +02:00
int l = keys_lower_bound(keys, key, 0, n);
if (l < n) {
int *kv = keys_get(keys, l);
if (kv[0] == key) {
kv[1] = 0; /* do not delete, just set to 0 */
}
}
}
}
}
int key_get(attrib *alist, int key) {
attrib *a;
assert(key != 0);
a = a_find(alist, &at_keys);
if (a) {
2017-08-20 12:58:05 +02:00
int *keys = (int *)a->data.v;
if (keys) {
2017-08-20 12:58:05 +02:00
int n = keys[0];
int l = keys_lower_bound(keys, key, 0, n);
if (l < n) {
int * kv = keys_get(keys, l);
if (kv[0] == key) {
return kv[1];
}
}
}
}
return 0;
}