X-Git-Url: http://git.indexdata.com/?a=blobdiff_plain;f=ccl%2Fcclqual.c;h=3fbb6c3be9c9a039b12821c37f55193f41dc367c;hb=6b3cf0738c53080781fedd852e26b299224af3c3;hp=3fb76c71a58430d530a15323041df9f120a5f8fc;hpb=657fb99115b87a5244e9a33bbe4ca3d9d18849c4;p=yaz-moved-to-github.git diff --git a/ccl/cclqual.c b/ccl/cclqual.c index 3fb76c7..3fbb6c3 100644 --- a/ccl/cclqual.c +++ b/ccl/cclqual.c @@ -1,12 +1,63 @@ +/* + * Copyright (c) 1995, the EUROPAGATE consortium (see below). + * + * The EUROPAGATE consortium members are: + * + * University College Dublin + * Danmarks Teknologiske Videnscenter + * An Chomhairle Leabharlanna + * Consejo Superior de Investigaciones Cientificas + * + * Permission to use, copy, modify, distribute, and sell this software and + * its documentation, in whole or in part, for any purpose, is hereby granted, + * provided that: + * + * 1. This copyright and permission notice appear in all copies of the + * software and its documentation. Notices of copyright or attribution + * which appear at the beginning of any file must remain unchanged. + * + * 2. The names of EUROPAGATE or the project partners may not be used to + * endorse or promote products derived from this software without specific + * prior written permission. + * + * 3. Users of this software (implementors and gateway operators) agree to + * inform the EUROPAGATE consortium of their use of the software. This + * information will be used to evaluate the EUROPAGATE project and the + * software, and to plan further developments. The consortium may use + * the information in later publications. + * + * 4. Users of this software agree to make their best efforts, when + * documenting their use of the software, to acknowledge the EUROPAGATE + * consortium, and the role played by the software in their work. + * + * THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT WARRANTY OF ANY KIND, + * EXPRESS, IMPLIED, OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY + * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. + * IN NO EVENT SHALL THE EUROPAGATE CONSORTIUM OR ITS MEMBERS BE LIABLE + * FOR ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF + * ANY KIND, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA + * OR PROFITS, WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND + * ON ANY THEORY OF LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE + * USE OR PERFORMANCE OF THIS SOFTWARE. + * + */ /* CCL qualifiers * Europagate, 1995 * - * $Log: cclqual.c,v $ - * Revision 1.2 1995-09-27 15:02:44 quinn - * Modified function heads & prototypes. + * $Id: cclqual.c,v 1.17 2002-06-06 12:54:24 adam Exp $ * - * Revision 1.1 1995/04/10 10:28:20 quinn - * Added copy of CCL. + * Old Europagate Log: + * + * Revision 1.9 1995/05/16 09:39:27 adam + * LICENSE. + * + * Revision 1.8 1995/05/11 14:03:57 adam + * Changes in the reading of qualifier(s). New function: ccl_qual_fitem. + * New variable ccl_case_sensitive, which controls whether reserved + * words and field names are case sensitive or not. + * + * Revision 1.7 1995/04/17 09:31:46 adam + * Improved handling of qualifiers. Aliases or reserved words. * * Revision 1.6 1995/02/23 08:32:00 adam * Changed header. @@ -29,39 +80,148 @@ #include #include -#include #include -#include +#include +/* Definition of CCL_bibset pointer */ struct ccl_qualifiers { struct ccl_qualifier *list; + struct ccl_qualifier_special *special; }; -void MDF ccl_qual_add (CCL_bibset b, const char *name, int no, int *pairs) + +/* 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 + * definition. + * name: name of qualifier + * no: No of attribute type/value pairs. + * 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_set (CCL_bibset b, const char *name, int no, int *pairs, + 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) + xfree (q->sub); attrp = &q->attr_list; while (*attrp) attrp = &(*attrp)->next; @@ -70,8 +230,9 @@ void MDF 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 = (struct ccl_rpn_attr *)xmalloc (sizeof(*attr)); + ccl_assert (attr); + attr->set = *attsets++; attr->type = *pairs++; attr->value = *pairs++; *attrp = attr; @@ -80,109 +241,109 @@ void MDF ccl_qual_add (CCL_bibset b, const char *name, int no, int *pairs) *attrp = NULL; } -CCL_bibset MDF ccl_qual_mk (void) +/* + * ccl_qual_mk: Make new (empty) bibset. + * return: empty bibset. + */ +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; } -void MDF ccl_qual_rm (CCL_bibset *b) +/* + * ccl_qual_rm: Delete bibset. + * b: pointer to bibset + */ +void ccl_qual_rm (CCL_bibset *b) { - assert (*b); - *b = NULL; -} + struct ccl_qualifier *q, *q1; + struct ccl_qualifier_special *sp, *sp1; -struct ccl_rpn_attr MDF *ccl_qual_search (CCL_bibset b, const char *name, int len) -{ - struct ccl_qualifier *q; + if (!*b) + return; + for (q = (*b)->list; q; q = q1) + { + struct ccl_rpn_attr *attr, *attr1; - assert (b); - for (q = b->list; q; q = q->next) - if (strlen(q->name) == len && !memcmp (name, q->name, len)) - return q->attr_list; - return NULL; + for (attr = q->attr_list; attr; attr = attr1) + { + attr1 = attr->next; + if (attr->set) + xfree (attr->set); + xfree (attr); + } + q1 = q->next; + xfree (q->name); + if (q->sub) + xfree (q->sub); + xfree (q); + } + for (sp = (*b)->special; sp; sp = sp1) + { + sp1 = sp->next; + xfree (sp->name); + xfree (sp->value); + xfree (sp); + } + xfree (*b); + *b = NULL; } -void MDF ccl_qual_file (CCL_bibset bibset, FILE *inf) +/* + * ccl_qual_search: Search for qualifier in bibset. + * b: Bibset + * name: Name of qualifier to search for (need no null-termination) + * len: Length of name. + * return: Attribute info. NULL if not found. + */ +struct ccl_rpn_attr *ccl_qual_search (CCL_parser cclp, + const char *name, size_t len, + int seq) { - char line[256]; - char *cp; - char qual_name[128]; - char qual_des[128]; - int no_scan; + struct ccl_qualifier *q; - while (fgets (line, 255, inf)) - { - cp = line; - if (*cp == '#') - continue; - if (sscanf (cp, "%s%n", qual_name, &no_scan) != 1) - continue; - cp += no_scan; - while (1) + ccl_assert (cclp); + if (!cclp->bibset) + return NULL; + for (q = cclp->bibset->list; q; q = q->next) + if (strlen(q->name) == len) { - int pair[2]; - char *qual_type; - char *qual_value; - char *split; - - if (sscanf (cp, "%s%n", qual_des, &no_scan) != 1) - break; - - if (!(split = strchr (qual_des, '='))) - break; - cp += no_scan; - - *split++ = '\0'; - qual_type = qual_des; - qual_value = split; - while (1) + if (cclp->ccl_case_sensitive) { - if ((split = strchr (qual_value, ','))) - *split++ = '\0'; - pair[1] = atoi (qual_value); - switch (qual_type[0]) - { - case 'u': - pair[0] = CCL_BIB1_USE; + if (!memcmp (name, q->name, len)) break; - case 'r': - pair[0] = CCL_BIB1_REL; - if (!strcmp (qual_value, "o")) - pair[1] = CCL_BIB1_REL_ORDER; - break; - case 'p': - pair[0] = CCL_BIB1_POS; - break; - case 's': - pair[0] = CCL_BIB1_STR; - if (!strcmp (qual_value, "pw")) - pair[1] = CCL_BIB1_STR_WP; - break; - case 't': - pair[0] = CCL_BIB1_TRU; - if (!strcmp (qual_value, "l")) - pair[1] = CCL_BIB1_TRU_CAN_LEFT; - else if (!strcmp (qual_value, "r")) - pair[1] = CCL_BIB1_TRU_CAN_RIGHT; - else if (!strcmp (qual_value, "b")) - pair[1] = CCL_BIB1_TRU_CAN_BOTH; - else if (!strcmp (qual_value, "n")) - pair[1] = CCL_BIB1_TRU_CAN_NONE; - break; - case 'c': - pair[0] = CCL_BIB1_COM; - break; - default: - pair[0] = atoi (qual_type); - } - ccl_qual_add (bibset, qual_name, 1, pair); - if (!split) + } + else + { + if (!ccl_memicmp (name, q->name, len)) break; - qual_value = split; } } + 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; }