X-Git-Url: http://git.indexdata.com/?p=yaz-moved-to-github.git;a=blobdiff_plain;f=ccl%2Fcclqual.c;h=b0ec3f2b13ff41ea42eb0aefbc11f22cded8f370;hp=55cf77359e238b608a290b9b04ff82746886e2b4;hb=5381b2f81bb793e364cd5b2a910e026ce84d9d05;hpb=88e45d920d4fedb9557e896cf9448f9ab9cfb422 diff --git a/ccl/cclqual.c b/ccl/cclqual.c index 55cf773..b0ec3f2 100644 --- a/ccl/cclqual.c +++ b/ccl/cclqual.c @@ -44,21 +44,9 @@ /* CCL qualifiers * Europagate, 1995 * - * $Log: cclqual.c,v $ - * Revision 1.8 1997-09-29 08:56:38 adam - * Changed CCL parser to be thread safe. New type, CCL_parser, declared - * and a create/destructers ccl_parser_create/ccl_parser/destory has - * been added. + * $Id: cclqual.c,v 1.19 2003-06-23 10:22:21 adam Exp $ * - * Revision 1.7 1997/09/01 08:48:12 adam - * New windows NT/95 port using MSV5.0. Only a few changes made - * to avoid warnings. - * - * Revision 1.6 1997/04/30 08:52:07 quinn - * Null - * - * Revision 1.5 1996/10/11 15:00:25 adam - * CCL parser from Europagate Email gateway 1.0. + * Old Europagate Log: * * Revision 1.9 1995/05/16 09:39:27 adam * LICENSE. @@ -92,16 +80,110 @@ #include #include -#include #include -#include +#include /* Definition of CCL_bibset pointer */ struct ccl_qualifiers { struct ccl_qualifier *list; + struct ccl_qualifier_special *special; +}; + + +/* CCL Qualifier special */ +struct ccl_qualifier_special { + char *name; + char *value; + struct ccl_qualifier_special *next; }; + +static struct ccl_qualifier *ccl_qual_lookup (CCL_bibset b, + const char *n, size_t len) +{ + struct ccl_qualifier *q; + for (q = b->list; q; q = q->next) + if (len == strlen(q->name) && !memcmp (q->name, n, len)) + break; + return q; +} + + +void ccl_qual_add_special (CCL_bibset bibset, const char *n, const char *v) +{ + struct ccl_qualifier_special *p; + const char *pe; + + for (p = bibset->special; p && strcmp(p->name, n); p = p->next) + ; + if (p) + xfree (p->value); + else + { + p = (struct ccl_qualifier_special *) xmalloc (sizeof(*p)); + p->name = ccl_strdup (n); + p->value = 0; + p->next = bibset->special; + bibset->special = p; + } + while (strchr(" \t", *v)) + ++v; + for (pe = v + strlen(v); pe != v; --pe) + if (!strchr(" \n\r\t", pe[-1])) + break; + p->value = (char*) xmalloc (pe - v + 1); + if (pe - v) + memcpy (p->value, v, pe - v); + p->value[pe - v] = '\0'; +} + +static int next_token(const char **cpp, const char **dst) +{ + int len = 0; + const char *cp = *cpp; + while (*cp && strchr(" \r\n\t\f", *cp)) + cp++; + if (dst) + *dst = cp; + len = 0; + while (*cp && !strchr(" \r\n\t\f", *cp)) + { + cp++; + len++; + } + *cpp = cp; + return len; +} + +void ccl_qual_add_combi (CCL_bibset b, const char *n, const char *names) +{ + const char *cp, *cp1; + int i, len; + struct ccl_qualifier *q; + for (q = b->list; q && strcmp(q->name, n); q = q->next) + ; + if (q) + return ; + q = (struct ccl_qualifier *) xmalloc (sizeof(*q)); + q->name = ccl_strdup (n); + q->attr_list = 0; + q->next = b->list; + b->list = q; + + cp = names; + for (i = 0; next_token(&cp, 0); i++) + ; + q->no_sub = i; + q->sub = (struct ccl_qualifier **) xmalloc (sizeof(*q->sub) * + (1+q->no_sub)); + cp = names; + for (i = 0; (len = next_token(&cp, &cp1)); i++) + { + q->sub[i] = ccl_qual_lookup (b, cp1, len); + } +} + /* * ccl_qual_add: Add qualifier to Bibset. If qualifier already * exists, then attributes are appendend to old @@ -111,30 +193,37 @@ struct ccl_qualifiers { * pairs: Attributes. pairs[0] first type, pair[1] first value, * ... pair[2*no-2] last type, pair[2*no-1] last value. */ -void ccl_qual_add (CCL_bibset b, const char *name, int no, int *pairs) + +void ccl_qual_add_set (CCL_bibset b, const char *name, int no, + int *type_ar, int *value_ar, char **svalue_ar, + char **attsets) { struct ccl_qualifier *q; struct ccl_rpn_attr **attrp; - assert (b); + ccl_assert (b); for (q = b->list; q; q = q->next) if (!strcmp (name, q->name)) break; if (!q) { - struct ccl_qualifier *new_qual = malloc (sizeof(*new_qual)); - assert (new_qual); + struct ccl_qualifier *new_qual = + (struct ccl_qualifier *)xmalloc (sizeof(*new_qual)); + ccl_assert (new_qual); new_qual->next = b->list; b->list = new_qual; - new_qual->name = malloc (strlen(name)+1); - assert (new_qual->name); - strcpy (new_qual->name, name); + new_qual->name = ccl_strdup (name); attrp = &new_qual->attr_list; + + new_qual->no_sub = 0; + new_qual->sub = 0; } else { + if (q->sub) /* suspect.. */ + xfree (q->sub); attrp = &q->attr_list; while (*attrp) attrp = &(*attrp)->next; @@ -143,10 +232,22 @@ void ccl_qual_add (CCL_bibset b, const char *name, int no, int *pairs) { struct ccl_rpn_attr *attr; - attr = malloc (sizeof(*attr)); - assert (attr); - attr->type = *pairs++; - attr->value = *pairs++; + attr = (struct ccl_rpn_attr *)xmalloc (sizeof(*attr)); + ccl_assert (attr); + attr->set = *attsets++; + attr->type = *type_ar++; + if (*svalue_ar) + { + attr->kind = CCL_RPN_ATTR_STRING; + attr->value.str = *svalue_ar; + } + else + { + attr->kind = CCL_RPN_ATTR_NUMERIC; + attr->value.numeric = *value_ar; + } + svalue_ar++; + value_ar++; *attrp = attr; attrp = &attr->next; } @@ -159,9 +260,10 @@ void ccl_qual_add (CCL_bibset b, const char *name, int no, int *pairs) */ CCL_bibset ccl_qual_mk (void) { - CCL_bibset b = malloc (sizeof(*b)); - assert (b); + CCL_bibset b = (CCL_bibset)xmalloc (sizeof(*b)); + ccl_assert (b); b->list = NULL; + b->special = NULL; return b; } @@ -172,6 +274,7 @@ CCL_bibset ccl_qual_mk (void) void ccl_qual_rm (CCL_bibset *b) { struct ccl_qualifier *q, *q1; + struct ccl_qualifier_special *sp, *sp1; if (!*b) return; @@ -182,12 +285,26 @@ void ccl_qual_rm (CCL_bibset *b) for (attr = q->attr_list; attr; attr = attr1) { attr1 = attr->next; - free (attr); + if (attr->set) + xfree(attr->set); + if (attr->kind == CCL_RPN_ATTR_STRING) + xfree(attr->value.str); + xfree (attr); } q1 = q->next; - free (q); + xfree (q->name); + if (q->sub) + xfree (q->sub); + xfree (q); } - free (*b); + for (sp = (*b)->special; sp; sp = sp1) + { + sp1 = sp->next; + xfree (sp->name); + xfree (sp->value); + xfree (sp); + } + xfree (*b); *b = NULL; } @@ -199,25 +316,56 @@ void ccl_qual_rm (CCL_bibset *b) * return: Attribute info. NULL if not found. */ struct ccl_rpn_attr *ccl_qual_search (CCL_parser cclp, - const char *name, size_t len) + const char *name, size_t len, + int seq) { struct ccl_qualifier *q; + const char *aliases; + int case_sensitive = cclp->ccl_case_sensitive; - assert (cclp); + ccl_assert (cclp); if (!cclp->bibset) return NULL; + + aliases = ccl_qual_search_special(cclp->bibset, "case"); + if (aliases) + case_sensitive = atoi(aliases); + for (q = cclp->bibset->list; q; q = q->next) if (strlen(q->name) == len) - if (cclp->ccl_case_sensitive) + { + if (case_sensitive) { if (!memcmp (name, q->name, len)) - return q->attr_list; + break; } else { if (!ccl_memicmp (name, q->name, len)) - return q->attr_list; + break; } - return NULL; + } + if (q) + { + if (q->attr_list && seq == 0) + return q->attr_list; + if (seq < q->no_sub && q->sub[seq]) + { + return q->sub[seq]->attr_list; + } + } + return 0; } +const char *ccl_qual_search_special (CCL_bibset b, + const char *name) +{ + struct ccl_qualifier_special *q; + if (!b) + return 0; + for (q = b->special; q && strcmp(q->name, name); q = q->next) + ; + if (q) + return q->value; + return 0; +}