X-Git-Url: http://git.indexdata.com/?p=yaz-moved-to-github.git;a=blobdiff_plain;f=src%2Fcclqual.c;h=963bbd1eceed3c4ee7346fd1164ffa89a62fc2bf;hp=287836c730781bae34df5732cfdb1c605f031365;hb=171fd9ec0fba5789a6d14b733f77bbfe90df5512;hpb=de80462103c0fc554c8fa40827894f92fa9d8fe6 diff --git a/src/cclqual.c b/src/cclqual.c index 287836c..963bbd1 100644 --- a/src/cclqual.c +++ b/src/cclqual.c @@ -1,91 +1,20 @@ -/* - * 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. - * +/* This file is part of the YAZ toolkit. + * Copyright (C) Index Data + * See the file LICENSE for details. */ -/** +/** * \file cclqual.c * \brief Implements CCL qualifier utilities */ -/* CCL qualifiers - * Europagate, 1995 - * - * $Id: cclqual.c,v 1.4 2007-04-25 20:52:19 adam Exp $ - * - * 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. - * - * Revision 1.4 1995/02/14 19:55:12 adam - * Header files ccl.h/cclp.h are gone! They have been merged an - * moved to ../include/ccl.h. - * Node kind(s) in ccl_rpn_node have changed names. - * - * Revision 1.3 1995/02/14 16:20:56 adam - * Qualifiers are read from a file now. - * - * Revision 1.2 1995/02/14 10:25:56 adam - * The constructions 'qualifier rel term ...' implemented. - * - * Revision 1.1 1995/02/13 15:15:07 adam - * Added handling of qualifiers. Not finished yet. - * - */ +#if HAVE_CONFIG_H +#include +#endif #include #include #include - +#include +#include #include "cclp.h" /** CCL Qualifier */ @@ -108,146 +37,148 @@ struct ccl_qualifiers { /** CCL Qualifier special */ struct ccl_qualifier_special { char *name; - char *value; + const char **values; struct ccl_qualifier_special *next; }; -static struct ccl_qualifier *ccl_qual_lookup (CCL_bibset b, - const char *n, size_t len) +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)) + 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) +void ccl_qual_add_special_ar(CCL_bibset bibset, const char *n, + const char **values) { 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); + { + if (p->values) + { + int i; + for (i = 0; p->values[i]; i++) + xfree((char *) p->values[i]); + xfree((char **)p->values); + } + } else { - p = (struct ccl_qualifier_special *) xmalloc (sizeof(*p)); - p->name = ccl_strdup (n); - p->value = 0; + p = (struct ccl_qualifier_special *) xmalloc(sizeof(*p)); + p->name = xstrdup(n); 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'; + p->values = values; } -static int next_token(const char **cpp, const char **dst) +void ccl_qual_add_special(CCL_bibset bibset, const char *n, const char *cp) { - 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)) + size_t no = 2; + char **vlist = (char **) xmalloc(no * sizeof(*vlist)); + yaz_tok_cfg_t yt = yaz_tok_cfg_create(); + int t; + size_t i = 0; + + yaz_tok_parse_t tp = yaz_tok_parse_buf(yt, cp); + + yaz_tok_cfg_destroy(yt); + + t = yaz_tok_move(tp); + while (t == YAZ_TOK_STRING) { - cp++; - len++; + if (i >= no-1) + vlist = (char **) xrealloc(vlist, (no = no * 2) * sizeof(*vlist)); + vlist[i++] = xstrdup(yaz_tok_parse_string(tp)); + t = yaz_tok_move(tp); } - *cpp = cp; - return len; + vlist[i] = 0; + ccl_qual_add_special_ar(bibset, n, (const char **) vlist); + + yaz_tok_parse_destroy(tp); } -void ccl_qual_add_combi (CCL_bibset b, const char *n, const char *names) + +/** \brief adds specifies qualifier aliases + + \param b bibset + \param n qualifier name + \param names list of qualifier aliases +*/ +void ccl_qual_add_combi(CCL_bibset b, const char *n, const char **names) { - const char *cp, *cp1; - int i, len; + int i; 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 = (struct ccl_qualifier *) xmalloc(sizeof(*q)); + q->name = xstrdup(n); q->attr_list = 0; q->next = b->list; b->list = q; - - cp = names; - for (i = 0; next_token(&cp, 0); i++) + + for (i = 0; names[i]; 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); - } + q->sub = (struct ccl_qualifier **) + xmalloc(sizeof(*q->sub) * (1+q->no_sub)); + for (i = 0; names[i]; i++) + q->sub[i] = ccl_qual_lookup(b, names[i], strlen(names[i])); } -/** - * 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. - */ +/** \brief adds specifies attributes for qualifier + + \param b bibset + \param name qualifier name + \param no number of attribute type+value pairs + \param type_ar attributes type of size no + \param value_ar attribute value of size no + \param svalue_ar attribute string values ([i] only used if != NULL) + \param attsets attribute sets of size no +*/ -void ccl_qual_add_set (CCL_bibset b, const char *name, int no, +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; - ccl_assert (b); + ccl_assert(b); for (q = b->list; q; q = q->next) - if (!strcmp (name, q->name)) + if (!strcmp(name, q->name)) break; if (!q) { - 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 = 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; + q = (struct ccl_qualifier *)xmalloc(sizeof(*q)); + ccl_assert(q); + + q->next = b->list; + b->list = q; + + q->name = xstrdup(name); + q->attr_list = 0; + + q->no_sub = 0; + q->sub = 0; } + attrp = &q->attr_list; + while (*attrp) + attrp = &(*attrp)->next; while (--no >= 0) { struct ccl_rpn_attr *attr; - attr = (struct ccl_rpn_attr *)xmalloc (sizeof(*attr)); - ccl_assert (attr); + attr = (struct ccl_rpn_attr *)xmalloc(sizeof(*attr)); + ccl_assert(attr); attr->set = *attsets++; attr->type = *type_ar++; if (*svalue_ar) @@ -268,24 +199,24 @@ void ccl_qual_add_set (CCL_bibset b, const char *name, int no, *attrp = NULL; } -/** - * ccl_qual_mk: Make new (empty) bibset. - * return: empty bibset. +/** \brief creates Bibset + \returns bibset */ -CCL_bibset ccl_qual_mk (void) +CCL_bibset ccl_qual_mk(void) { - CCL_bibset b = (CCL_bibset)xmalloc (sizeof(*b)); - ccl_assert (b); - b->list = NULL; + CCL_bibset b = (CCL_bibset)xmalloc(sizeof(*b)); + ccl_assert(b); + b->list = NULL; b->special = NULL; return b; } -/** - * ccl_qual_rm: Delete bibset. - * b: pointer to bibset +/** \brief destroys Bibset + \param b pointer to Bibset + + *b will be set to NULL. */ -void ccl_qual_rm (CCL_bibset *b) +void ccl_qual_rm(CCL_bibset *b) { struct ccl_qualifier *q, *q1; struct ccl_qualifier_special *sp, *sp1; @@ -303,76 +234,166 @@ void ccl_qual_rm (CCL_bibset *b) xfree(attr->set); if (attr->kind == CCL_RPN_ATTR_STRING) xfree(attr->value.str); - xfree (attr); + xfree(attr); } q1 = q->next; - xfree (q->name); + xfree(q->name); if (q->sub) - xfree (q->sub); - xfree (q); + xfree(q->sub); + xfree(q); } for (sp = (*b)->special; sp; sp = sp1) { sp1 = sp->next; - xfree (sp->name); - xfree (sp->value); - xfree (sp); + xfree(sp->name); + if (sp->values) + { + int i; + for (i = 0; sp->values[i]; i++) + xfree((char*) sp->values[i]); + xfree((char **)sp->values); + } + xfree(sp); } - xfree (*b); + xfree(*b); *b = NULL; } -/** - * 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) +CCL_bibset ccl_qual_dup(CCL_bibset b) { - struct ccl_qualifier *q; - const char *aliases; + CCL_bibset n = ccl_qual_mk(); + struct ccl_qualifier *q, **qp; + struct ccl_qualifier_special *s, **sp; + + qp = &n->list; + for (q = b->list; q; q = q->next) + { + struct ccl_rpn_attr *attr, **attrp; + *qp = xmalloc(sizeof(**qp)); + (*qp)->next = 0; + (*qp)->attr_list = 0; + (*qp)->name = xstrdup(q->name); + + attrp = &(*qp)->attr_list; + for (attr = q->attr_list; attr; attr = attr->next) + { + *attrp = xmalloc(sizeof(**attrp)); + (*attrp)->next = 0; + (*attrp)->set = attr->set ? xstrdup(attr->set) : 0; + (*attrp)->type = attr->type; + (*attrp)->kind = attr->kind; + if (attr->kind == CCL_RPN_ATTR_NUMERIC) + (*attrp)->value.numeric = attr->value.numeric; + else if (attr->kind == CCL_RPN_ATTR_STRING) + (*attrp)->value.str = xstrdup(attr->value.str); + + attrp = &(*attrp)->next; + } + (*qp)->no_sub = q->no_sub; + if (!q->sub) + (*qp)->sub = 0; + else + { + /* fix up the sub qualifiers.. */ + int i; + (*qp)->sub = xmalloc(sizeof(*q->sub) * (q->no_sub + 1)); + for (i = 0; i < q->no_sub; i++) + { + struct ccl_qualifier *q1, *q2; + + /* sweep though original and match up the corresponding ent */ + q2 = n->list; + for (q1 = b->list; q1 && q2; q1 = q1->next, q2 = q2->next) + if (q1 == q->sub[i]) + break; + (*qp)->sub[i] = q2; + } + } + qp = &(*qp)->next; + } + sp = &n->special; + for (s = b->special; s; s = s->next) + { + int i; + + for (i = 0; s->values[i]; i++) + ; + *sp = xmalloc(sizeof(**sp)); + (*sp)->next = 0; + (*sp)->name = xstrdup(s->name); + (*sp)->values = xmalloc(sizeof(*(*sp)->values) * (i+1)); + for (i = 0; s->values[i]; i++) + (*sp)->values[i] = xstrdup(s->values[i]); + (*sp)->values[i] = 0; + sp = &(*sp)->next; + } + return n; +} + +ccl_qualifier_t ccl_qual_search(CCL_parser cclp, const char *name, + size_t name_len, int seq) +{ + struct ccl_qualifier *q = 0; + const char **aliases; int case_sensitive = cclp->ccl_case_sensitive; - ccl_assert (cclp); + ccl_assert(cclp); if (!cclp->bibset) - return NULL; + return 0; aliases = ccl_qual_search_special(cclp->bibset, "case"); if (aliases) - case_sensitive = atoi(aliases); + case_sensitive = atoi(aliases[0]); for (q = cclp->bibset->list; q; q = q->next) - if (strlen(q->name) == len) + if (strlen(q->name) == name_len) { if (case_sensitive) { - if (!memcmp (name, q->name, len)) + if (!memcmp(name, q->name, name_len)) break; } else { - if (!ccl_memicmp (name, q->name, len)) + if (!ccl_memicmp(name, q->name, name_len)) break; } } if (q) { - if (q->attr_list && seq == 0) - return q->attr_list; - if (seq < q->no_sub && q->sub[seq]) + if (q->no_sub) { - return q->sub[seq]->attr_list; + if (seq < q->no_sub) + q = q->sub[seq]; + else + q = 0; } + else if (seq) + q = 0; } + return q; +} + +struct ccl_rpn_attr *ccl_qual_get_attr(ccl_qualifier_t q) +{ + return q->attr_list; +} + +struct ccl_rpn_attr *ccl_parser_qual_search(CCL_parser cclp, const char *name, + size_t name_len) +{ + ccl_qualifier_t q = ccl_qual_search(cclp, name, name_len, 0); + if (q) + return q->attr_list; return 0; } -const char *ccl_qual_search_special (CCL_bibset b, - const char *name) +const char *ccl_qual_get_name(ccl_qualifier_t q) +{ + return q->name; +} + +const char **ccl_qual_search_special(CCL_bibset b, const char *name) { struct ccl_qualifier_special *q; if (!b) @@ -380,12 +401,38 @@ const char *ccl_qual_search_special (CCL_bibset b, for (q = b->special; q && strcmp(q->name, name); q = q->next) ; if (q) - return q->value; + return q->values; + return 0; +} + +int ccl_search_stop(CCL_bibset bibset, const char *qname, + const char *src_str, size_t src_len) +{ + const char **slist = 0; + if (qname) + { + char qname_buf[80]; + yaz_snprintf(qname_buf, sizeof(qname_buf)-1, "stop.%s", + qname); + slist = ccl_qual_search_special(bibset, qname_buf); + } + if (!slist) + slist = ccl_qual_search_special(bibset, "stop.*"); + if (slist) + { + int i; + for (i = 0; slist[i]; i++) + if (src_len == strlen(slist[i]) + && ccl_memicmp(slist[i], src_str, src_len) == 0) + return 1; + } return 0; } + /* * Local variables: * c-basic-offset: 4 + * c-file-style: "Stroustrup" * indent-tabs-mode: nil * End: * vim: shiftwidth=4 tabstop=8 expandtab