X-Git-Url: http://git.indexdata.com/?a=blobdiff_plain;f=util%2Fres.c;h=0b2cc7591bde6cfda25bdcfad153d609c9acbd8f;hb=b879b04a092d5b00cc866cf16f755e55053d2e89;hp=56f01c96acd56fe6a2d26adb239a3a64096fe8f0;hpb=146a66bc15816555b4e233e5b9d224ce91ab94ee;p=idzebra-moved-to-github.git diff --git a/util/res.c b/util/res.c index 56f01c9..0b2cc75 100644 --- a/util/res.c +++ b/util/res.c @@ -4,63 +4,90 @@ * Sebastian Hammer, Adam Dickmeiss * * $Log: res.c,v $ - * Revision 1.1 1994-08-17 15:34:23 adam + * Revision 1.13 1995-09-04 12:34:05 adam + * Various cleanup. YAZ util used instead. + * + * Revision 1.12 1995/01/24 16:40:32 adam + * Bug fix. + * + * Revision 1.11 1994/10/05 16:54:52 adam + * Minor changes. + * + * Revision 1.10 1994/10/05 10:47:31 adam + * Small bug fix. + * + * Revision 1.9 1994/09/16 14:41:12 quinn + * Added log warning to res_get_def + * + * Revision 1.8 1994/09/16 14:37:12 quinn + * added res_get_def + * + * Revision 1.7 1994/09/06 13:01:03 quinn + * Removed const from declaration of res_get + * + * Revision 1.6 1994/09/01 17:45:14 adam + * Work on resource manager. + * + * Revision 1.5 1994/08/18 11:02:28 adam + * Implementation of res_write. + * + * Revision 1.4 1994/08/18 10:02:01 adam + * Module alexpath moved from res.c to alexpath.c. Minor changes in res-test.c + * + * Revision 1.3 1994/08/18 09:43:51 adam + * Development of resource manager. Only missing is res_write. + * + * Revision 1.2 1994/08/18 08:23:26 adam + * Res.c now use handles. xmalloc defines xstrdup. + * + * Revision 1.1 1994/08/17 15:34:23 adam * Initial version of resource manager. * */ #include #include -#include - -struct res { - char *name; - char *value; - struct res *next; -}; - -static struct res *first = NULL, *last = NULL; -static int res_init = 0; - -static FILE *fr; +#include +#include +#include +#include -const char *alex_path (const char *name) +static struct res_entry *add_entry (Res r) { - static char path[256]; - char *alex_prefix; - - if (!(alex_prefix = getenv ("ALEXPREFIX"))) - alex_prefix = "./"; - - if (*alex_prefix && alex_prefix[strlen(alex_prefix)-1] == '/') - sprintf (path, "%s%s", alex_prefix, name); + struct res_entry *resp; + + if (!r->first) + resp = r->last = r->first = xmalloc (sizeof(*resp)); else - sprintf (path, "%s/%s", alex_prefix, name); - return path; + { + resp = xmalloc (sizeof(*resp)); + r->last->next = resp; + r->last = resp; + } + resp->next = NULL; + return resp; } -static void reread (void) +static void reread (Res r) { - struct res *resp; + struct res_entry *resp; char *line; - char *alex_base; char *val_buf; - int val_size, val_max = 1024; + int val_size, val_max = 256; char path[256]; char fr_buf[1024]; + FILE *fr; - res_init = 1; + assert (r); + r->init = 1; val_buf = xmalloc (val_max); - if (!(alex_base = getenv ("ALEXBASE"))) - alex_base = "base"; - - strcpy (path, alex_path(alex_base)); + strcpy (path, alex_path(r->name)); fr = fopen (path, "r"); if (!fr) { - log (LOG_FATAL, "cannot open %s", path); + logf (LOG_FATAL|LOG_ERRNO, "Cannot open %s", path); exit (1); } while (1) @@ -76,15 +103,7 @@ static void reread (void) no++; fr_buf[no] = '\0'; - if (!first) - resp = last = first = xmalloc (sizeof(*resp)); - else - { - resp = xmalloc (sizeof(*resp)); - last->next = resp; - last = resp; - } - resp->next = NULL; + resp = add_entry (r); resp->name = xmalloc (no+1); resp->value = NULL; strcpy (resp->name, fr_buf); @@ -106,15 +125,7 @@ static void reread (void) if (no < 0) continue; fr_buf[no++] = '\0'; - if (!first) - resp = last = first = xmalloc (sizeof(*resp)); - else - { - resp = xmalloc (sizeof(*resp)); - last->next = resp; - last = resp; - } - resp->next = NULL; + resp = add_entry (r); resp->name = xmalloc (no); strcpy (resp->name, fr_buf); @@ -128,6 +139,8 @@ static void reread (void) val_buf[val_size++] = '\0'; resp->value = xmalloc (val_size); strcpy (resp->value, val_buf); + logf (LOG_DEBUG, "(name=%s,value=%s)", + resp->name, resp->value); break; } else if (fr_buf[no] == '\\' && fr_buf[no+1] == '\n') @@ -142,7 +155,18 @@ static void reread (void) no = 0; } else - val_buf[val_size] = fr_buf[no++]; + { + val_buf[val_size++] = fr_buf[no++]; + if (val_size+1 >= val_max) + { + char *nb; + + nb = xmalloc (val_max+=1024); + memcpy (nb, val_buf, val_size); + xfree (val_buf); + val_buf = nb; + } + } } } } @@ -150,25 +174,150 @@ static void reread (void) fclose (fr); } +Res res_open (const char *name) +{ + Res r; + if (access (name, R_OK)) + logf (LOG_LOG|LOG_ERRNO, "Cannot access `%s'", name); + r = xmalloc (sizeof(*r)); + r->init = 0; + r->first = r->last = NULL; + r->name = xstrdup (name); + return r; +} -const char *res_get (const char *name) +void res_close (Res r) { - if (!res_init) - reread (); - return NULL; + assert (r); + if (r->init) + { + struct res_entry *re, *re1; + for (re = r->first; re; re=re1) + { + if (re->name) + xfree (re->name); + if (re->value) + xfree (re->value); + re1 = re->next; + xfree (re); + } + } + xfree (r); } -const char *res_put (const char *name, const char *value) +char *res_get (Res r, const char *name) { - if (!res_init) - reread (); + struct res_entry *re; + + assert (r); + if (!r->init) + reread (r); + for (re = r->first; re; re=re->next) + if (re->value && !strcmp (re->name, name)) + return re->value; return NULL; } - -int res_write (void) + +char *res_get_def (Res r, const char *name, char *def) { - if (!res_init) - reread (); + char *t; + + if (!(t = res_get (r, name))) + { + logf (LOG_DEBUG, "CAUTION: Using default resource %s:%s", name, def); + return def; + } + else + return t; +} + +void res_put (Res r, const char *name, const char *value) +{ + struct res_entry *re; + assert (r); + if (!r->init) + reread (r); + + for (re = r->first; re; re=re->next) + if (re->value && !strcmp (re->name, name)) + { + xfree (re->value); + re->value = xstrdup (value); + return; + } + re = add_entry (r); + re->name = xstrdup (name); + re->value = xstrdup (value); +} + +void res_trav (Res r, const char *prefix, + void (*f)(const char *name, const char *value)) +{ + struct res_entry *re; + int l = 0; + + assert (r); + if (prefix) + l = strlen(prefix); + if (!r->init) + reread (r); + for (re = r->first; re; re=re->next) + if (re->value) + if (l==0 || !memcmp (re->name, prefix, l)) + (*f)(re->name, re->value); +} + + +int res_write (Res r) +{ + struct res_entry *re; + char path[256]; + FILE *fr; + + assert (r); + if (!r->init) + reread (r); + strcpy (path, alex_path(r->name)); + + fr = fopen (path, "w"); + if (!fr) + { + logf (LOG_FATAL|LOG_ERRNO, "Cannot create %s", path); + exit (1); + } + + for (re = r->first; re; re=re->next) + { + int no = 0; + int lefts = strlen(re->name)+2; + + if (!re->value) + fprintf (fr, "%s\n", re->name); + else + { + fprintf (fr, "%s: ", re->name); + while (lefts + strlen(re->value+no) > 78) + { + int i = 20; + int ind = no+ 78-lefts; + while (--i >= 0) + { + if (re->value[ind] == ' ') + break; + --ind; + } + if (i<0) + ind = no + 78 - lefts; + for (i = no; i != ind; i++) + putc (re->value[i], fr); + fprintf (fr, "\\\n"); + no=ind; + lefts = 0; + } + fprintf (fr, "%s\n", re->value+no); + } + } + fclose (fr); return 0; }