forked from github/server
fix a bug in the escape_string function.
remove static return variable from escape_string. add test coverage.
This commit is contained in:
parent
920902f8eb
commit
a3037950ff
|
@ -490,11 +490,12 @@ static void report_crtypes(FILE * F, const struct locale *lang)
|
|||
for (kmt = mtypehash[i]; kmt; kmt = kmt->nexthash) {
|
||||
const struct nrmessage_type *nrt = nrt_find(lang, kmt->mtype);
|
||||
if (nrt) {
|
||||
char buffer[DISPLAYSIZE];
|
||||
unsigned int hash = kmt->mtype->key;
|
||||
assert(hash > 0);
|
||||
fprintf(F, "MESSAGETYPE %u\n", hash);
|
||||
fputc('\"', F);
|
||||
fputs(escape_string(nrt_string(nrt), NULL, 0), F);
|
||||
fputs(escape_string(nrt_string(nrt), buffer, sizeof(buffer)), F);
|
||||
fputs("\";text\n", F);
|
||||
fprintf(F, "\"%s\";section\n", nrt_section(nrt));
|
||||
}
|
||||
|
|
|
@ -314,7 +314,7 @@ helpmode helpmodes[] = {
|
|||
*/
|
||||
const char *dbrace(const struct race *rc)
|
||||
{
|
||||
static char zText[32];
|
||||
static char zText[32]; // FIXME: static return value
|
||||
char *zPtr = zText;
|
||||
|
||||
/* the english names are all in ASCII, so we don't need to worry about UTF8 */
|
||||
|
@ -974,7 +974,7 @@ int modifier)
|
|||
#ifndef NDEBUG
|
||||
const char *strcheck(const char *s, size_t maxlen)
|
||||
{
|
||||
static char buffer[16 * 1024];
|
||||
static char buffer[16 * 1024]; // FIXME: static return value
|
||||
if (strlen(s) > maxlen) {
|
||||
assert(maxlen < 16 * 1024);
|
||||
log_warning("[strcheck] String wurde auf %d Zeichen verkürzt:\n%s\n", (int)maxlen, s);
|
||||
|
@ -1911,7 +1911,7 @@ int check_param(const struct param *p, const char *key, const char *searchvalue)
|
|||
static const char *g_datadir;
|
||||
const char *datapath(void)
|
||||
{
|
||||
static char zText[MAX_PATH];
|
||||
static char zText[MAX_PATH]; // FIXME: static return value
|
||||
if (g_datadir)
|
||||
return g_datadir;
|
||||
return strcat(strcpy(zText, basepath()), "/data");
|
||||
|
@ -1925,7 +1925,7 @@ void set_datapath(const char *path)
|
|||
static const char *g_reportdir;
|
||||
const char *reportpath(void)
|
||||
{
|
||||
static char zText[MAX_PATH];
|
||||
static char zText[MAX_PATH]; // FIXME: static return value
|
||||
if (g_reportdir)
|
||||
return g_reportdir;
|
||||
return strcat(strcpy(zText, basepath()), "/reports");
|
||||
|
|
|
@ -54,7 +54,7 @@ static const char *make_names(const char *monster, int *num_postfix,
|
|||
int pprefix, int *num_name, int *num_prefix, int ppostfix)
|
||||
{
|
||||
int uv, uu, un;
|
||||
static char name[NAMESIZE + 1];
|
||||
static char name[NAMESIZE + 1]; // FIXME: static return value
|
||||
char zText[32];
|
||||
const char *str;
|
||||
|
||||
|
@ -222,7 +222,7 @@ static const char *generic_name(const unit * u)
|
|||
|
||||
static const char *dragon_name(const unit * u)
|
||||
{
|
||||
static char name[NAMESIZE + 1];
|
||||
static char name[NAMESIZE + 1]; // FIXME: static return value
|
||||
int rnd, ter = 0;
|
||||
int anzahl = 1;
|
||||
static int num_postfix;
|
||||
|
@ -355,7 +355,7 @@ static const char *drac_suf[DRAC_SUF] = {
|
|||
|
||||
static const char *dracoid_name(const unit * u)
|
||||
{
|
||||
static char name[NAMESIZE + 1];
|
||||
static char name[NAMESIZE + 1]; // FIXME: static return value
|
||||
int mid_syllabels;
|
||||
|
||||
u = u;
|
||||
|
|
|
@ -1,7 +1,7 @@
|
|||
/*
|
||||
Copyright (c) 1998-2010, Enno Rehling <enno@eressea.de>
|
||||
Katja Zedel <katze@felidae.kn-bremen.de
|
||||
Christian Schlittchen <corwin@amber.kn-bremen.de>
|
||||
Katja Zedel <katze@felidae.kn-bremen.de
|
||||
Christian Schlittchen <corwin@amber.kn-bremen.de>
|
||||
|
||||
Permission to use, copy, modify, and/or distribute this software for any
|
||||
purpose with or without fee is hereby granted, provided that the above
|
||||
|
@ -93,7 +93,8 @@ struct race *get_race(race_t rt) {
|
|||
cache = cache_breaker;
|
||||
memset(race_cache, 0, sizeof(race_cache));
|
||||
return race_cache[rt] = rc_get_or_create(name);
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
result = race_cache[rt];
|
||||
if (!result) {
|
||||
result = race_cache[rt] = rc_get_or_create(name);
|
||||
|
@ -104,57 +105,57 @@ struct race *get_race(race_t rt) {
|
|||
|
||||
race_list *get_familiarraces(void)
|
||||
{
|
||||
static int init = 0;
|
||||
static race_list *familiarraces;
|
||||
static int init = 0;
|
||||
static race_list *familiarraces;
|
||||
|
||||
if (!init) {
|
||||
race *rc = races;
|
||||
for (; rc != NULL; rc = rc->next) {
|
||||
if (rc->init_familiar != NULL) {
|
||||
racelist_insert(&familiarraces, rc);
|
||||
}
|
||||
if (!init) {
|
||||
race *rc = races;
|
||||
for (; rc != NULL; rc = rc->next) {
|
||||
if (rc->init_familiar != NULL) {
|
||||
racelist_insert(&familiarraces, rc);
|
||||
}
|
||||
}
|
||||
init = false;
|
||||
}
|
||||
init = false;
|
||||
}
|
||||
return familiarraces;
|
||||
return familiarraces;
|
||||
}
|
||||
|
||||
void racelist_clear(struct race_list **rl)
|
||||
{
|
||||
while (*rl) {
|
||||
race_list *rl2 = (*rl)->next;
|
||||
free(*rl);
|
||||
*rl = rl2;
|
||||
}
|
||||
while (*rl) {
|
||||
race_list *rl2 = (*rl)->next;
|
||||
free(*rl);
|
||||
*rl = rl2;
|
||||
}
|
||||
}
|
||||
|
||||
void racelist_insert(struct race_list **rl, const struct race *r)
|
||||
{
|
||||
race_list *rl2 = (race_list *) malloc(sizeof(race_list));
|
||||
race_list *rl2 = (race_list *)malloc(sizeof(race_list));
|
||||
|
||||
rl2->data = r;
|
||||
rl2->next = *rl;
|
||||
rl2->data = r;
|
||||
rl2->next = *rl;
|
||||
|
||||
*rl = rl2;
|
||||
*rl = rl2;
|
||||
}
|
||||
|
||||
void free_races(void) {
|
||||
while (races) {
|
||||
race * rc = races->next;
|
||||
free(races);
|
||||
races =rc;
|
||||
races = rc;
|
||||
}
|
||||
}
|
||||
|
||||
static race *rc_find_i(const char *name)
|
||||
{
|
||||
const char *rname = name;
|
||||
race *rc = races;
|
||||
const char *rname = name;
|
||||
race *rc = races;
|
||||
|
||||
while (rc && !strcmp(rname, rc->_name) == 0) {
|
||||
rc = rc->next;
|
||||
}
|
||||
return rc;
|
||||
while (rc && !strcmp(rname, rc->_name) == 0) {
|
||||
rc = rc->next;
|
||||
}
|
||||
return rc;
|
||||
}
|
||||
|
||||
const race * rc_find(const char *name) {
|
||||
|
@ -168,7 +169,7 @@ race *rc_get_or_create(const char *zName)
|
|||
assert(zName);
|
||||
rc = rc_find_i(zName);
|
||||
if (!rc) {
|
||||
char zBuffer[80];
|
||||
char zBuffer[80];
|
||||
|
||||
rc = (race *)calloc(sizeof(race), 1);
|
||||
rc->hitpoints = 1;
|
||||
|
@ -193,30 +194,30 @@ race *rc_get_or_create(const char *zName)
|
|||
/** dragon movement **/
|
||||
bool allowed_dragon(const region * src, const region * target)
|
||||
{
|
||||
if (fval(src->terrain, ARCTIC_REGION) && fval(target->terrain, SEA_REGION))
|
||||
return false;
|
||||
return allowed_fly(src, target);
|
||||
if (fval(src->terrain, ARCTIC_REGION) && fval(target->terrain, SEA_REGION))
|
||||
return false;
|
||||
return allowed_fly(src, target);
|
||||
}
|
||||
|
||||
char **race_prefixes = NULL;
|
||||
|
||||
extern void add_raceprefix(const char *prefix)
|
||||
{
|
||||
static size_t size = 4;
|
||||
static unsigned int next = 0;
|
||||
if (race_prefixes == NULL)
|
||||
race_prefixes = malloc(size * sizeof(char *));
|
||||
if (next + 1 == size) {
|
||||
size *= 2;
|
||||
race_prefixes = realloc(race_prefixes, size * sizeof(char *));
|
||||
}
|
||||
race_prefixes[next++] = _strdup(prefix);
|
||||
race_prefixes[next] = NULL;
|
||||
static size_t size = 4;
|
||||
static unsigned int next = 0;
|
||||
if (race_prefixes == NULL)
|
||||
race_prefixes = malloc(size * sizeof(char *));
|
||||
if (next + 1 == size) {
|
||||
size *= 2;
|
||||
race_prefixes = realloc(race_prefixes, size * sizeof(char *));
|
||||
}
|
||||
race_prefixes[next++] = _strdup(prefix);
|
||||
race_prefixes[next] = NULL;
|
||||
}
|
||||
|
||||
bool r_insectstalled(const region * r)
|
||||
{
|
||||
return fval(r->terrain, ARCTIC_REGION);
|
||||
return fval(r->terrain, ARCTIC_REGION);
|
||||
}
|
||||
|
||||
const char *rc_name(const race * rc, name_t n)
|
||||
|
@ -233,7 +234,7 @@ const char *rc_name(const race * rc, name_t n)
|
|||
default: assert(!"invalid name_t enum in rc_name");
|
||||
}
|
||||
if (postfix) {
|
||||
static char name[64]; // FIXME: static variable return
|
||||
static char name[64]; // FIXME: static return value
|
||||
sprintf(name, "race::%s%s", rc->_name, postfix);
|
||||
return name;
|
||||
}
|
||||
|
@ -242,97 +243,98 @@ const char *rc_name(const race * rc, name_t n)
|
|||
|
||||
const char *raceprefix(const unit * u)
|
||||
{
|
||||
const attrib *asource = u->faction->attribs;
|
||||
const attrib *asource = u->faction->attribs;
|
||||
|
||||
if (fval(u, UFL_GROUP)) {
|
||||
const attrib *agroup = agroup = a_findc(u->attribs, &at_group);
|
||||
if (agroup != NULL)
|
||||
asource = ((const group *)(agroup->data.v))->attribs;
|
||||
}
|
||||
return get_prefix(asource);
|
||||
if (fval(u, UFL_GROUP)) {
|
||||
const attrib *agroup = agroup = a_findc(u->attribs, &at_group);
|
||||
if (agroup != NULL)
|
||||
asource = ((const group *)(agroup->data.v))->attribs;
|
||||
}
|
||||
return get_prefix(asource);
|
||||
}
|
||||
|
||||
const char *racename(const struct locale *loc, const unit * u, const race * rc)
|
||||
{
|
||||
const char *str, *prefix = raceprefix(u);
|
||||
const char *str, *prefix = raceprefix(u);
|
||||
|
||||
if (prefix != NULL) {
|
||||
static char lbuf[80];
|
||||
char *bufp = lbuf;
|
||||
size_t size = sizeof(lbuf) - 1;
|
||||
int ch, bytes;
|
||||
if (prefix != NULL) {
|
||||
static char lbuf[80]; // FIXME: static return value
|
||||
char *bufp = lbuf;
|
||||
size_t size = sizeof(lbuf) - 1;
|
||||
int ch, bytes;
|
||||
|
||||
bytes = (int)strlcpy(bufp, LOC(loc, mkname("prefix", prefix)), size);
|
||||
if (wrptr(&bufp, &size, bytes) != 0)
|
||||
WARN_STATIC_BUFFER();
|
||||
bytes = (int)strlcpy(bufp, LOC(loc, mkname("prefix", prefix)), size);
|
||||
if (wrptr(&bufp, &size, bytes) != 0)
|
||||
WARN_STATIC_BUFFER();
|
||||
|
||||
bytes = (int)strlcpy(bufp, LOC(loc, rc_name(rc, u->number != 1)), size);
|
||||
assert(~bufp[0] & 0x80 || !"unicode/not implemented");
|
||||
ch = tolower(*(unsigned char *)bufp);
|
||||
bufp[0] = (char)ch;
|
||||
if (wrptr(&bufp, &size, bytes) != 0)
|
||||
WARN_STATIC_BUFFER();
|
||||
*bufp = 0;
|
||||
bytes = (int)strlcpy(bufp, LOC(loc, rc_name(rc, u->number != 1)), size);
|
||||
assert(~bufp[0] & 0x80 || !"unicode/not implemented");
|
||||
ch = tolower(*(unsigned char *)bufp);
|
||||
bufp[0] = (char)ch;
|
||||
if (wrptr(&bufp, &size, bytes) != 0)
|
||||
WARN_STATIC_BUFFER();
|
||||
*bufp = 0;
|
||||
|
||||
return lbuf;
|
||||
}
|
||||
str = LOC(loc, rc_name(rc, (u->number == 1) ? NAME_SINGULAR : NAME_PLURAL));
|
||||
return str ? str : rc->_name;
|
||||
return lbuf;
|
||||
}
|
||||
str = LOC(loc, rc_name(rc, (u->number == 1) ? NAME_SINGULAR : NAME_PLURAL));
|
||||
return str ? str : rc->_name;
|
||||
}
|
||||
|
||||
int
|
||||
rc_specialdamage(const race * ar, const race * dr,
|
||||
const struct weapon_type *wtype)
|
||||
const struct weapon_type *wtype)
|
||||
{
|
||||
race_t art = old_race(ar);
|
||||
int m, modifier = 0;
|
||||
race_t art = old_race(ar);
|
||||
int m, modifier = 0;
|
||||
|
||||
if (wtype != NULL && wtype->modifiers != NULL)
|
||||
for (m = 0; wtype->modifiers[m].value; ++m) {
|
||||
/* weapon damage for this weapon, possibly by race */
|
||||
if (wtype->modifiers[m].flags & WMF_DAMAGE) {
|
||||
race_list *rlist = wtype->modifiers[m].races;
|
||||
if (rlist != NULL) {
|
||||
while (rlist) {
|
||||
if (rlist->data == ar)
|
||||
break;
|
||||
rlist = rlist->next;
|
||||
}
|
||||
if (rlist == NULL)
|
||||
continue;
|
||||
if (wtype != NULL && wtype->modifiers != NULL)
|
||||
for (m = 0; wtype->modifiers[m].value; ++m) {
|
||||
/* weapon damage for this weapon, possibly by race */
|
||||
if (wtype->modifiers[m].flags & WMF_DAMAGE) {
|
||||
race_list *rlist = wtype->modifiers[m].races;
|
||||
if (rlist != NULL) {
|
||||
while (rlist) {
|
||||
if (rlist->data == ar)
|
||||
break;
|
||||
rlist = rlist->next;
|
||||
}
|
||||
if (rlist == NULL)
|
||||
continue;
|
||||
}
|
||||
modifier += wtype->modifiers[m].value;
|
||||
}
|
||||
modifier += wtype->modifiers[m].value;
|
||||
}
|
||||
}
|
||||
switch (art) {
|
||||
}
|
||||
switch (art) {
|
||||
case RC_HALFLING:
|
||||
if (wtype != NULL && dragonrace(dr)) {
|
||||
modifier += 5;
|
||||
}
|
||||
break;
|
||||
if (wtype != NULL && dragonrace(dr)) {
|
||||
modifier += 5;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
return modifier;
|
||||
break;
|
||||
}
|
||||
return modifier;
|
||||
}
|
||||
|
||||
void write_race_reference(const race * rc, struct storage *store)
|
||||
{
|
||||
WRITE_TOK(store, rc ? rc->_name : "none");
|
||||
WRITE_TOK(store, rc ? rc->_name : "none");
|
||||
}
|
||||
|
||||
variant read_race_reference(struct storage *store)
|
||||
{
|
||||
variant result;
|
||||
char zName[20];
|
||||
READ_TOK(store, zName, sizeof(zName));
|
||||
variant result;
|
||||
char zName[20];
|
||||
READ_TOK(store, zName, sizeof(zName));
|
||||
|
||||
if (strcmp(zName, "none") == 0) {
|
||||
result.v = NULL;
|
||||
if (strcmp(zName, "none") == 0) {
|
||||
result.v = NULL;
|
||||
return result;
|
||||
}
|
||||
else {
|
||||
result.v = rc_find_i(zName);
|
||||
}
|
||||
assert(result.v != NULL);
|
||||
return result;
|
||||
} else {
|
||||
result.v = rc_find_i(zName);
|
||||
}
|
||||
assert(result.v != NULL);
|
||||
return result;
|
||||
}
|
||||
|
|
|
@ -107,7 +107,7 @@ const char *combatstatus[] = {
|
|||
|
||||
const char *report_kampfstatus(const unit * u, const struct locale *lang)
|
||||
{
|
||||
static char fsbuf[64];
|
||||
static char fsbuf[64]; // FIXME: static return value
|
||||
|
||||
strlcpy(fsbuf, LOC(lang, combatstatus[u->status]), sizeof(fsbuf));
|
||||
if (fval(u, UFL_NOAID)) {
|
||||
|
@ -1928,7 +1928,7 @@ f_regionid(const region * r, const faction * f, char *buffer, size_t size)
|
|||
static char *f_regionid_s(const region * r, const faction * f)
|
||||
{
|
||||
static int i = 0;
|
||||
static char bufs[4][NAMESIZE + 20];
|
||||
static char bufs[4][NAMESIZE + 20]; // FIXME: static return value
|
||||
char *buf = bufs[(++i) % 4];
|
||||
|
||||
f_regionid(r, f, buf, NAMESIZE + 20);
|
||||
|
@ -2177,7 +2177,7 @@ static void eval_race(struct opstack **stack, const void *userdata)
|
|||
static void eval_order(struct opstack **stack, const void *userdata)
|
||||
{ /* order -> string */
|
||||
const struct order *ord = (const struct order *)opop(stack).v;
|
||||
static char buf[512];
|
||||
char buf[512];
|
||||
size_t len;
|
||||
variant var;
|
||||
|
||||
|
@ -2193,7 +2193,7 @@ static void eval_resources(struct opstack **stack, const void *userdata)
|
|||
const faction *report = (const faction *)userdata;
|
||||
const struct locale *lang = report ? report->locale : default_locale;
|
||||
const struct resource *res = (const struct resource *)opop(stack).v;
|
||||
static char buf[1024]; /* but we only use about half of this */
|
||||
char buf[1024]; /* but we only use about half of this */
|
||||
size_t size = sizeof(buf) - 1;
|
||||
variant var;
|
||||
|
||||
|
@ -2225,7 +2225,7 @@ static void eval_regions(struct opstack **stack, const void *userdata)
|
|||
int i = opop(stack).i;
|
||||
int end, begin = opop(stack).i;
|
||||
const arg_regions *regions = (const arg_regions *)opop(stack).v;
|
||||
static char buf[256];
|
||||
char buf[256];
|
||||
size_t size = sizeof(buf) - 1;
|
||||
variant var;
|
||||
char *bufp = buf;
|
||||
|
@ -2262,7 +2262,7 @@ static void eval_trail(struct opstack **stack, const void *userdata)
|
|||
const struct locale *lang = report ? report->locale : default_locale;
|
||||
int i, end = 0, begin = 0;
|
||||
const arg_regions *regions = (const arg_regions *)opop(stack).v;
|
||||
static char buf[512];
|
||||
char buf[512];
|
||||
size_t size = sizeof(buf) - 1;
|
||||
variant var;
|
||||
char *bufp = buf;
|
||||
|
|
|
@ -241,7 +241,7 @@ static faction *factionorders(void)
|
|||
|
||||
}
|
||||
else {
|
||||
log_warning("orders for invalid faction %s\n", itoa36(fid));
|
||||
log_debug("orders for invalid faction %s\n", itoa36(fid));
|
||||
}
|
||||
return f;
|
||||
}
|
||||
|
|
|
@ -12,7 +12,7 @@
|
|||
|
||||
const char * keyword(keyword_t kwd)
|
||||
{
|
||||
static char result[KEYWORDSIZE];
|
||||
static char result[KEYWORDSIZE]; // FIXME: static return value
|
||||
if (!result[0]) {
|
||||
strcpy(result, "keyword::");
|
||||
}
|
||||
|
|
|
@ -100,7 +100,7 @@ extern int months_per_year;
|
|||
|
||||
static char *gamedate_season(const struct locale *lang)
|
||||
{
|
||||
static char buf[256];
|
||||
static char buf[256]; // FIXME: static return value
|
||||
gamedate gd;
|
||||
|
||||
get_gamedate(turn, &gd);
|
||||
|
@ -517,7 +517,7 @@ void sparagraph(strlist ** SP, const char *s, int indent, char mark)
|
|||
|
||||
int i, j, width;
|
||||
int firstline;
|
||||
static char buf[REPORTWIDTH + 1];
|
||||
static char buf[REPORTWIDTH + 1]; // FIXME: static return value
|
||||
|
||||
width = REPORTWIDTH - indent;
|
||||
firstline = 1;
|
||||
|
|
|
@ -34,6 +34,7 @@ int RunAllTests(void)
|
|||
ADD_TESTS(suite, bsdstring);
|
||||
ADD_TESTS(suite, functions);
|
||||
ADD_TESTS(suite, umlaut);
|
||||
ADD_TESTS(suite, strings);
|
||||
/* kernel */
|
||||
ADD_TESTS(suite, faction);
|
||||
ADD_TESTS(suite, build);
|
||||
|
|
|
@ -2,6 +2,7 @@ project(util C)
|
|||
|
||||
SET(_TEST_FILES
|
||||
base36.test.c
|
||||
strings.test.c
|
||||
bsdstring.test.c
|
||||
functions.test.c
|
||||
umlaut.test.c
|
||||
|
|
|
@ -56,7 +56,7 @@ int atoi36(const char *str)
|
|||
|
||||
const char *itoab(int i, int base)
|
||||
{
|
||||
static char **as = NULL; /* STATIC_RETURN: used for return, not across calls */
|
||||
static char **as = NULL; // FIXME: static return value
|
||||
char *s, *dst;
|
||||
static int index = 0; /* STATIC_XCALL: used across calls */
|
||||
int neg = 0;
|
||||
|
|
|
@ -1,7 +1,7 @@
|
|||
/*
|
||||
Copyright (c) 1998-2010, Enno Rehling <enno@eressea.de>
|
||||
Katja Zedel <katze@felidae.kn-bremen.de
|
||||
Christian Schlittchen <corwin@amber.kn-bremen.de>
|
||||
Katja Zedel <katze@felidae.kn-bremen.de
|
||||
Christian Schlittchen <corwin@amber.kn-bremen.de>
|
||||
|
||||
Permission to use, copy, modify, and/or distribute this software for any
|
||||
purpose with or without fee is hereby granted, provided that the above
|
||||
|
@ -36,17 +36,17 @@ locale *locales;
|
|||
|
||||
unsigned int locale_index(const locale * lang)
|
||||
{
|
||||
assert(lang);
|
||||
return lang->index;
|
||||
assert(lang);
|
||||
return lang->index;
|
||||
}
|
||||
|
||||
locale *get_locale(const char *name)
|
||||
{
|
||||
unsigned int hkey = hashstring(name);
|
||||
locale *l = locales;
|
||||
while (l && l->hashkey != hkey)
|
||||
l = l->next;
|
||||
return l;
|
||||
unsigned int hkey = hashstring(name);
|
||||
locale *l = locales;
|
||||
while (l && l->hashkey != hkey)
|
||||
l = l->next;
|
||||
return l;
|
||||
}
|
||||
|
||||
static unsigned int nextlocaleindex = 0;
|
||||
|
@ -59,7 +59,8 @@ locale *get_or_create_locale(const char *name)
|
|||
|
||||
if (!locales) {
|
||||
nextlocaleindex = 0;
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
while (*lp && (*lp)->hashkey != hkey) lp = &(*lp)->next;
|
||||
if (*lp) {
|
||||
return *lp;
|
||||
|
@ -81,172 +82,174 @@ locale *get_or_create_locale(const char *name)
|
|||
*/
|
||||
void make_locales(const char *str)
|
||||
{
|
||||
const char *tok = str;
|
||||
while (*tok) {
|
||||
char zText[32];
|
||||
while (*tok && *tok != ',')
|
||||
++tok;
|
||||
strncpy(zText, str, tok - str);
|
||||
zText[tok - str] = 0;
|
||||
get_or_create_locale(zText);
|
||||
if (*tok) {
|
||||
str = ++tok;
|
||||
const char *tok = str;
|
||||
while (*tok) {
|
||||
char zText[32];
|
||||
while (*tok && *tok != ',')
|
||||
++tok;
|
||||
strncpy(zText, str, tok - str);
|
||||
zText[tok - str] = 0;
|
||||
get_or_create_locale(zText);
|
||||
if (*tok) {
|
||||
str = ++tok;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const char *locale_getstring(const locale * lang, const char *key)
|
||||
{
|
||||
unsigned int hkey = hashstring(key);
|
||||
unsigned int id = hkey & (SMAXHASH - 1);
|
||||
const struct locale_str *find;
|
||||
unsigned int hkey = hashstring(key);
|
||||
unsigned int id = hkey & (SMAXHASH - 1);
|
||||
const struct locale_str *find;
|
||||
|
||||
assert(lang);
|
||||
if (key == NULL || *key == 0)
|
||||
return NULL;
|
||||
find = lang->strings[id];
|
||||
while (find) {
|
||||
if (find->hashkey == hkey) {
|
||||
if (find->nexthash == NULL) {
|
||||
/* if this is the only entry with this hash, fine. */
|
||||
assert(strcmp(key, find->key) == 0);
|
||||
return find->str;
|
||||
}
|
||||
if (strcmp(key, find->key) == 0) {
|
||||
return find->str;
|
||||
}
|
||||
assert(lang);
|
||||
if (key == NULL || *key == 0)
|
||||
return NULL;
|
||||
find = lang->strings[id];
|
||||
while (find) {
|
||||
if (find->hashkey == hkey) {
|
||||
if (find->nexthash == NULL) {
|
||||
/* if this is the only entry with this hash, fine. */
|
||||
assert(strcmp(key, find->key) == 0);
|
||||
return find->str;
|
||||
}
|
||||
if (strcmp(key, find->key) == 0) {
|
||||
return find->str;
|
||||
}
|
||||
}
|
||||
find = find->nexthash;
|
||||
}
|
||||
find = find->nexthash;
|
||||
}
|
||||
return NULL;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char *locale_string(const locale * lang, const char *key)
|
||||
{
|
||||
assert(lang);
|
||||
assert(key);
|
||||
assert(lang);
|
||||
assert(key);
|
||||
|
||||
if (key != NULL) {
|
||||
unsigned int hkey = hashstring(key);
|
||||
unsigned int id = hkey & (SMAXHASH - 1);
|
||||
struct locale_str *find;
|
||||
if (key != NULL) {
|
||||
unsigned int hkey = hashstring(key);
|
||||
unsigned int id = hkey & (SMAXHASH - 1);
|
||||
struct locale_str *find;
|
||||
|
||||
if (*key == 0) return 0;
|
||||
find = lang->strings[id];
|
||||
while (find) {
|
||||
if (find->hashkey == hkey) {
|
||||
if (!find->nexthash) {
|
||||
/* if this is the only entry with this hash, fine. */
|
||||
assert(strcmp(key, find->key) == 0);
|
||||
break;
|
||||
if (*key == 0) return 0;
|
||||
find = lang->strings[id];
|
||||
while (find) {
|
||||
if (find->hashkey == hkey) {
|
||||
if (!find->nexthash) {
|
||||
/* if this is the only entry with this hash, fine. */
|
||||
assert(strcmp(key, find->key) == 0);
|
||||
break;
|
||||
}
|
||||
if (strcmp(key, find->key) == 0)
|
||||
break;
|
||||
}
|
||||
find = find->nexthash;
|
||||
}
|
||||
if (strcmp(key, find->key) == 0)
|
||||
break;
|
||||
}
|
||||
find = find->nexthash;
|
||||
if (!find) {
|
||||
log_warning("missing translation for \"%s\" in locale %s\n", key, lang->name);
|
||||
if (lang->fallback) {
|
||||
return locale_string(lang->fallback, key);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
return find->str;
|
||||
}
|
||||
if (!find) {
|
||||
log_warning("missing translation for \"%s\" in locale %s\n", key, lang->name);
|
||||
if (lang->fallback) {
|
||||
return locale_string(lang->fallback, key);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
return find->str;
|
||||
}
|
||||
return 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
void locale_setstring(locale * lang, const char *key, const char *value)
|
||||
{
|
||||
unsigned int hkey = hashstring(key);
|
||||
unsigned int id = hkey & (SMAXHASH - 1);
|
||||
struct locale_str *find;
|
||||
if (!lang) {
|
||||
lang = default_locale;
|
||||
}
|
||||
assert(lang);
|
||||
find = lang->strings[id];
|
||||
while (find) {
|
||||
if (find->hashkey == hkey && strcmp(key, find->key) == 0)
|
||||
break;
|
||||
find = find->nexthash;
|
||||
}
|
||||
if (!find) {
|
||||
find = calloc(1, sizeof(struct locale_str));
|
||||
find->nexthash = lang->strings[id];
|
||||
lang->strings[id] = find;
|
||||
find->hashkey = hkey;
|
||||
find->key = _strdup(key);
|
||||
find->str = _strdup(value);
|
||||
} else {
|
||||
if (strcmp(find->str, value) != 0) {
|
||||
log_warning("multiple translations for key %s\n", key);
|
||||
unsigned int hkey = hashstring(key);
|
||||
unsigned int id = hkey & (SMAXHASH - 1);
|
||||
struct locale_str *find;
|
||||
if (!lang) {
|
||||
lang = default_locale;
|
||||
}
|
||||
assert(lang);
|
||||
find = lang->strings[id];
|
||||
while (find) {
|
||||
if (find->hashkey == hkey && strcmp(key, find->key) == 0)
|
||||
break;
|
||||
find = find->nexthash;
|
||||
}
|
||||
if (!find) {
|
||||
find = calloc(1, sizeof(struct locale_str));
|
||||
find->nexthash = lang->strings[id];
|
||||
lang->strings[id] = find;
|
||||
find->hashkey = hkey;
|
||||
find->key = _strdup(key);
|
||||
find->str = _strdup(value);
|
||||
}
|
||||
else {
|
||||
if (strcmp(find->str, value) != 0) {
|
||||
log_warning("multiple translations for key %s\n", key);
|
||||
}
|
||||
free(find->str);
|
||||
find->str = _strdup(value);
|
||||
}
|
||||
free(find->str);
|
||||
find->str = _strdup(value);
|
||||
}
|
||||
}
|
||||
|
||||
const char *locale_name(const locale * lang)
|
||||
{
|
||||
return lang ? lang->name : "(null)";
|
||||
return lang ? lang->name : "(null)";
|
||||
}
|
||||
|
||||
char *mkname_buf(const char *space, const char *name, char *buffer)
|
||||
{
|
||||
if (space && *space) {
|
||||
sprintf(buffer, "%s::%s", space, name);
|
||||
} else {
|
||||
strcpy(buffer, name);
|
||||
}
|
||||
return buffer;
|
||||
if (space && *space) {
|
||||
sprintf(buffer, "%s::%s", space, name);
|
||||
}
|
||||
else {
|
||||
strcpy(buffer, name);
|
||||
}
|
||||
return buffer;
|
||||
}
|
||||
|
||||
const char *mkname(const char *space, const char *name)
|
||||
{
|
||||
static char zBuffer[128]; /* STATIC_RESULT: used for return, not across calls */
|
||||
return mkname_buf(space, name, zBuffer);
|
||||
static char zBuffer[128]; // FIXME: static return value
|
||||
return mkname_buf(space, name, zBuffer);
|
||||
}
|
||||
|
||||
locale *nextlocale(const struct locale * lang)
|
||||
{
|
||||
return lang->next;
|
||||
return lang->next;
|
||||
}
|
||||
|
||||
typedef struct lstr {
|
||||
void * tokens[UT_MAX];
|
||||
void * tokens[UT_MAX];
|
||||
} lstr;
|
||||
|
||||
static lstr lstrs[MAXLOCALES];
|
||||
|
||||
void ** get_translations(const struct locale *lang, int index)
|
||||
{
|
||||
assert(lang);
|
||||
assert(lang->index < MAXLOCALES
|
||||
|| "you have to increase MAXLOCALES and recompile");
|
||||
if (lang->index < MAXLOCALES) {
|
||||
return lstrs[lang->index].tokens + index;
|
||||
}
|
||||
return lstrs[0].tokens + index;
|
||||
assert(lang);
|
||||
assert(lang->index < MAXLOCALES
|
||||
|| "you have to increase MAXLOCALES and recompile");
|
||||
if (lang->index < MAXLOCALES) {
|
||||
return lstrs[lang->index].tokens + index;
|
||||
}
|
||||
return lstrs[0].tokens + index;
|
||||
}
|
||||
|
||||
void free_locales(void)
|
||||
{
|
||||
while (locales) {
|
||||
int i;
|
||||
locale * next = locales->next;
|
||||
while (locales) {
|
||||
int i;
|
||||
locale * next = locales->next;
|
||||
|
||||
for (i=0; i!=SMAXHASH; ++i) {
|
||||
while (locales->strings[i]) {
|
||||
struct locale_str * strings = locales->strings[i];
|
||||
free(strings->key);
|
||||
free(strings->str);
|
||||
locales->strings[i] = strings->nexthash;
|
||||
free(strings);
|
||||
}
|
||||
for (i = 0; i != SMAXHASH; ++i) {
|
||||
while (locales->strings[i]) {
|
||||
struct locale_str * strings = locales->strings[i];
|
||||
free(strings->key);
|
||||
free(strings->str);
|
||||
locales->strings[i] = strings->nexthash;
|
||||
free(strings);
|
||||
}
|
||||
}
|
||||
free(locales);
|
||||
locales = next;
|
||||
}
|
||||
free(locales);
|
||||
locales = next;
|
||||
}
|
||||
}
|
|
@ -1,7 +1,7 @@
|
|||
/*
|
||||
Copyright (c) 1998-2010, Enno Rehling <enno@eressea.de>
|
||||
Katja Zedel <katze@felidae.kn-bremen.de
|
||||
Christian Schlittchen <corwin@amber.kn-bremen.de>
|
||||
Katja Zedel <katze@felidae.kn-bremen.de
|
||||
Christian Schlittchen <corwin@amber.kn-bremen.de>
|
||||
|
||||
Permission to use, copy, modify, and/or distribute this software for any
|
||||
purpose with or without fee is hereby granted, provided that the above
|
||||
|
@ -20,73 +20,72 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|||
|
||||
/* libc includes */
|
||||
#include <string.h>
|
||||
#include <assert.h>
|
||||
|
||||
unsigned int hashstring(const char *s)
|
||||
{
|
||||
unsigned int key = 0;
|
||||
while (*s) {
|
||||
key = key * 37 + *s++;
|
||||
}
|
||||
return key & 0x7FFFFFFF;
|
||||
unsigned int key = 0;
|
||||
while (*s) {
|
||||
key = key * 37 + *s++;
|
||||
}
|
||||
return key & 0x7FFFFFFF;
|
||||
}
|
||||
|
||||
const char *escape_string(const char *str, char *buffer,
|
||||
unsigned int len)
|
||||
unsigned int len)
|
||||
{
|
||||
const char *start = strchr(str, '\"');
|
||||
if (start) {
|
||||
static char s_buffer[4096]; /* STATIC_RESULT: used for return, not across calls */
|
||||
const char *p;
|
||||
char *o;
|
||||
size_t skip = start - str;
|
||||
const char *start = strchr(str, '\"');
|
||||
if (!start) start = strchr(str, '\\');
|
||||
assert(buffer);
|
||||
if (start) {
|
||||
const char *p;
|
||||
char *o;
|
||||
size_t skip = start - str;
|
||||
|
||||
if (buffer == NULL) {
|
||||
buffer = s_buffer;
|
||||
len = sizeof(s_buffer);
|
||||
memcpy(buffer, str, skip);
|
||||
o = buffer + skip;
|
||||
p = str + skip;
|
||||
do {
|
||||
if (*p == '\"' || *p == '\\') {
|
||||
if (len < 2) {
|
||||
*o = '\0';
|
||||
break;
|
||||
}
|
||||
(*o++) = '\\';
|
||||
len -= 2;
|
||||
}
|
||||
else {
|
||||
if (len < 1) {
|
||||
*o = '\0';
|
||||
break;
|
||||
}
|
||||
--len;
|
||||
}
|
||||
(*o++) = (*p);
|
||||
} while (*p++);
|
||||
return buffer;
|
||||
}
|
||||
memcpy(buffer, str, skip);
|
||||
o = buffer + skip;
|
||||
p = str + skip;
|
||||
do {
|
||||
if (*p == '\"' || *p == '\\') {
|
||||
if (len < 2) {
|
||||
*o = '\0';
|
||||
break;
|
||||
}
|
||||
(*o++) = '\\';
|
||||
len -= 2;
|
||||
} else {
|
||||
if (len < 1) {
|
||||
*o = '\0';
|
||||
break;
|
||||
}
|
||||
--len;
|
||||
}
|
||||
(*o++) = (*p);
|
||||
} while (*p++);
|
||||
return buffer;
|
||||
}
|
||||
return str;
|
||||
return str;
|
||||
}
|
||||
|
||||
unsigned int jenkins_hash(unsigned int a)
|
||||
{
|
||||
a = (a + 0x7ed55d16) + (a << 12);
|
||||
a = (a ^ 0xc761c23c) ^ (a >> 19);
|
||||
a = (a + 0x165667b1) + (a << 5);
|
||||
a = (a + 0xd3a2646c) ^ (a << 9);
|
||||
a = (a + 0xfd7046c5) + (a << 3);
|
||||
a = (a ^ 0xb55a4f09) ^ (a >> 16);
|
||||
return a;
|
||||
a = (a + 0x7ed55d16) + (a << 12);
|
||||
a = (a ^ 0xc761c23c) ^ (a >> 19);
|
||||
a = (a + 0x165667b1) + (a << 5);
|
||||
a = (a + 0xd3a2646c) ^ (a << 9);
|
||||
a = (a + 0xfd7046c5) + (a << 3);
|
||||
a = (a ^ 0xb55a4f09) ^ (a >> 16);
|
||||
return a;
|
||||
}
|
||||
|
||||
unsigned int wang_hash(unsigned int a)
|
||||
{
|
||||
a = ~a + (a << 15); /* a = (a << 15) - a - 1; */
|
||||
a = a ^ (a >> 12);
|
||||
a = a + (a << 2);
|
||||
a = a ^ (a >> 4);
|
||||
a = a * 2057; /* a = (a + (a << 3)) + (a << 11); */
|
||||
a = a ^ (a >> 16);
|
||||
return a;
|
||||
a = ~a + (a << 15); /* a = (a << 15) - a - 1; */
|
||||
a = a ^ (a >> 12);
|
||||
a = a + (a << 2);
|
||||
a = a ^ (a >> 4);
|
||||
a = a * 2057; /* a = (a + (a << 3)) + (a << 11); */
|
||||
a = a ^ (a >> 16);
|
||||
return a;
|
||||
}
|
||||
|
|
|
@ -0,0 +1,21 @@
|
|||
#include <CuTest.h>
|
||||
#include <ctype.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include "goodies.h"
|
||||
|
||||
static void test_escape_string(CuTest * tc)
|
||||
{
|
||||
char scratch[64];
|
||||
CuAssertStrEquals(tc, "hello world", escape_string("hello world", scratch, sizeof(scratch)));
|
||||
CuAssertStrEquals(tc, "hello \\\"world\\\"", escape_string("hello \"world\"", scratch, sizeof(scratch)));
|
||||
CuAssertStrEquals(tc, "\\\"\\\\", escape_string("\"\\", scratch, sizeof(scratch)));
|
||||
CuAssertStrEquals(tc, "\\\\", escape_string("\\", scratch, sizeof(scratch)));
|
||||
}
|
||||
|
||||
CuSuite *get_strings_suite(void)
|
||||
{
|
||||
CuSuite *suite = CuSuiteNew();
|
||||
SUITE_ADD_TEST(suite, test_escape_string);
|
||||
return suite;
|
||||
}
|
|
@ -30,7 +30,7 @@
|
|||
#ifdef USE_LIBXML2
|
||||
const xmlChar *xml_i(double number)
|
||||
{
|
||||
static char buffer[128];
|
||||
static char buffer[128]; // FIXME: static return value
|
||||
_snprintf(buffer, sizeof(buffer), "%.0f", number);
|
||||
return (const xmlChar *)buffer;
|
||||
}
|
||||
|
|
Loading…
Reference in New Issue