X-Git-Url: http://git.indexdata.com/?p=yaz-moved-to-github.git;a=blobdiff_plain;f=src%2Fcclfind.c;h=f4dbaa4b9debbcb1b6da14ee53ebf3b4c60e4059;hp=bef1d81e5c30a65cbb7591f75bd45c0472aaa4a9;hb=ba058997e52b990c7fa140301a1970be96ab6a4b;hpb=2d2263d4725895b9bc52a91d3a2b1ceca85e2919 diff --git a/src/cclfind.c b/src/cclfind.c index bef1d81..f4dbaa4 100644 --- a/src/cclfind.c +++ b/src/cclfind.c @@ -1,107 +1,25 @@ -/* - * 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. */ -/* CCL find (to rpn conversion) - * Europagate, 1995 - * - * $Id: cclfind.c,v 1.5 2004-10-10 21:43:21 adam Exp $ - * - * Old Europagate log: - * - * Revision 1.16 1996/01/08 08:41:13 adam - * Removed unused function. - * - * Revision 1.15 1995/07/20 08:14:34 adam - * Qualifiers were observed too often. Instead tokens are treated as - * qualifiers only when separated by comma. - * - * Revision 1.14 1995/05/16 09:39:26 adam - * LICENSE. - * - * Revision 1.13 1995/04/17 09:31:42 adam - * Improved handling of qualifiers. Aliases or reserved words. - * - * Revision 1.12 1995/03/20 15:27:43 adam - * Minor changes. - * - * Revision 1.11 1995/02/23 08:31:59 adam - * Changed header. - * - * Revision 1.9 1995/02/16 13:20:06 adam - * Spell fix. - * - * Revision 1.8 1995/02/14 19:59:42 adam - * Removed a syntax error. - * - * Revision 1.7 1995/02/14 19:55:10 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.6 1995/02/14 16:20:55 adam - * Qualifiers are read from a file now. - * - * Revision 1.5 1995/02/14 14:12:41 adam - * Ranges for ordered qualfiers implemented (e.g. pd=1980-1990). - * - * Revision 1.4 1995/02/14 13:16:29 adam - * Left and/or right truncation implemented. - * - * Revision 1.3 1995/02/14 10:25:56 adam - * The constructions 'qualifier rel term ...' implemented. - * - * Revision 1.2 1995/02/13 15:15:07 adam - * Added handling of qualifiers. Not finished yet. - * - * Revision 1.1 1995/02/13 12:35:20 adam - * First version of CCL. Qualifiers aren't handled yet. +/** + * \file cclfind.c + * \brief Implements parsing of a CCL FIND query. * + * This source file implements parsing of a CCL Query (ISO8777). + * The parser uses predictive parsing, but it does several tokens + * of lookahead in the handling of relational operations.. So + * it's not really pure. */ +#if HAVE_CONFIG_H +#include +#endif #include #include +#include -#include +#include "cclp.h" /* returns type of current lookahead */ #define KIND (cclp->look_token->kind) @@ -109,26 +27,27 @@ /* move one token forward */ #define ADVANCE cclp->look_token = cclp->look_token->next -/* +/** * qual_val_type: test for existance of attribute type/value pair. * qa: Attribute array * type: Type of attribute to search for * value: Value of attribute to seach for * return: 1 if found; 0 otherwise. */ -static int qual_val_type (struct ccl_rpn_attr **qa, int type, int value, - char **attset) +static int qual_val_type(ccl_qualifier_t *qa, int type, int value, + char **attset) { int i; - struct ccl_rpn_attr *q; if (!qa) return 0; - for (i = 0; (q=qa[i]); i++) + for (i = 0; qa[i]; i++) + { + struct ccl_rpn_attr *q = ccl_qual_get_attr(qa[i]); while (q) { if (q->type == type && q->kind == CCL_RPN_ATTR_NUMERIC && - q->value.numeric == value) + q->value.numeric == value) { if (attset) *attset = q->set; @@ -136,16 +55,17 @@ static int qual_val_type (struct ccl_rpn_attr **qa, int type, int value, } q = q->next; } + } return 0; } -/* +/** * strxcat: concatenate strings. - * n: Null-terminated Destination string + * n: Null-terminated Destination string * src: Source string to be appended (not null-terminated) * len: Length of source string. */ -static void strxcat (char *n, const char *src, int len) +static void strxcat(char *n, const char *src, int len) { while (*n) n++; @@ -154,39 +74,50 @@ static void strxcat (char *n, const char *src, int len) *n = '\0'; } -/* +/** * copy_token_name: Return copy of CCL token name * tp: Pointer to token info. * return: malloc(3) allocated copy of token name. */ -static char *copy_token_name (struct ccl_token *tp) +static char *copy_token_name(struct ccl_token *tp) { - char *str = (char *)xmalloc (tp->len + 1); - ccl_assert (str); - memcpy (str, tp->name, tp->len); + char *str = (char *)xmalloc(tp->len + 1); + ccl_assert(str); + memcpy(str, tp->name, tp->len); str[tp->len] = '\0'; return str; } -/* +/** * mk_node: Create RPN node. * kind: Type of node. * return: pointer to allocated node. */ -static struct ccl_rpn_node *mk_node (int kind) +struct ccl_rpn_node *ccl_rpn_node_create(enum ccl_rpn_kind kind) { struct ccl_rpn_node *p; - p = (struct ccl_rpn_node *)xmalloc (sizeof(*p)); - ccl_assert (p); + p = (struct ccl_rpn_node *)xmalloc(sizeof(*p)); + ccl_assert(p); p->kind = kind; + + switch(kind) + { + case CCL_RPN_TERM: + p->u.t.attr_list = 0; + p->u.t.term = 0; + p->u.t.qual = 0; + break; + default: + break; + } return p; } -/* +/** * ccl_rpn_delete: Delete RPN tree. * rpn: Pointer to tree. */ -void ccl_rpn_delete (struct ccl_rpn_node *rpn) +void ccl_rpn_delete(struct ccl_rpn_node *rpn) { struct ccl_rpn_attr *attr, *attr1; if (!rpn) @@ -196,37 +127,37 @@ void ccl_rpn_delete (struct ccl_rpn_node *rpn) case CCL_RPN_AND: case CCL_RPN_OR: case CCL_RPN_NOT: - ccl_rpn_delete (rpn->u.p[0]); - ccl_rpn_delete (rpn->u.p[1]); + ccl_rpn_delete(rpn->u.p[0]); + ccl_rpn_delete(rpn->u.p[1]); break; case CCL_RPN_TERM: - xfree (rpn->u.t.term); + xfree(rpn->u.t.term); + xfree(rpn->u.t.qual); for (attr = rpn->u.t.attr_list; attr; attr = attr1) { attr1 = attr->next; - if (attr->kind == CCL_RPN_ATTR_STRING) - xfree(attr->value.str); + if (attr->kind == CCL_RPN_ATTR_STRING) + xfree(attr->value.str); if (attr->set) - xfree (attr->set); - xfree (attr); + xfree(attr->set); + xfree(attr); } break; case CCL_RPN_SET: - xfree (rpn->u.setname); + xfree(rpn->u.setname); break; case CCL_RPN_PROX: - ccl_rpn_delete (rpn->u.p[0]); - ccl_rpn_delete (rpn->u.p[1]); - ccl_rpn_delete (rpn->u.p[2]); + ccl_rpn_delete(rpn->u.p[0]); + ccl_rpn_delete(rpn->u.p[1]); + ccl_rpn_delete(rpn->u.p[2]); break; } - xfree (rpn); + xfree(rpn); } -static struct ccl_rpn_node *find_spec (CCL_parser cclp, - struct ccl_rpn_attr **qa); +static struct ccl_rpn_node *find_spec(CCL_parser cclp, ccl_qualifier_t *qa); -static int is_term_ok (int look, int *list) +static int is_term_ok(int look, int *list) { for (;*list >= 0; list++) if (look == *list) @@ -234,41 +165,35 @@ static int is_term_ok (int look, int *list) return 0; } -static struct ccl_rpn_node *search_terms (CCL_parser cclp, - struct ccl_rpn_attr **qa); +static struct ccl_rpn_node *search_terms(CCL_parser cclp, ccl_qualifier_t *qa); -static struct ccl_rpn_attr *add_attr_node (struct ccl_rpn_node *p, - const char *set, int type) +static struct ccl_rpn_attr *add_attr_node(struct ccl_rpn_node *p, + const char *set, int type) { struct ccl_rpn_attr *n; - - n = (struct ccl_rpn_attr *)xmalloc (sizeof(*n)); - ccl_assert (n); + + n = (struct ccl_rpn_attr *)xmalloc(sizeof(*n)); + ccl_assert(n); if (set) - { - n->set = (char*) xmalloc (strlen(set)+1); - strcpy (n->set, set); - } + n->set = xstrdup(set); else n->set = 0; n->type = type; n->next = p->u.t.attr_list; p->u.t.attr_list = n; - - n->kind = CCL_RPN_ATTR_NUMERIC; - n->value.numeric = 0; + return n; } -/* +/** * add_attr_numeric: Add attribute (type/value) to RPN term node. * p: RPN node of type term. * type: Type of attribute * value: Value of attribute * set: Attribute set name */ -static void add_attr_numeric (struct ccl_rpn_node *p, const char *set, - int type, int value) +void ccl_add_attr_numeric(struct ccl_rpn_node *p, const char *set, + int type, int value) { struct ccl_rpn_attr *n; @@ -277,8 +202,8 @@ static void add_attr_numeric (struct ccl_rpn_node *p, const char *set, n->value.numeric = value; } -static void add_attr_string (struct ccl_rpn_node *p, const char *set, - int type, char *value) +void ccl_add_attr_string(struct ccl_rpn_node *p, const char *set, + int type, char *value) { struct ccl_rpn_attr *n; @@ -287,240 +212,451 @@ static void add_attr_string (struct ccl_rpn_node *p, const char *set, n->value.str = xstrdup(value); } +static size_t cmp_operator(const char **aliases, const char *input) +{ + for (; *aliases; aliases++) + { + const char *cp = *aliases; + size_t i; + for (i = 0; *cp && *cp == input[i]; i++, cp++) + ; + if (*cp == '\0') + return i; + } + return 0; +} -/* - * search_term: Parse CCL search term. + +#define REGEX_CHARS "^[]{}()|.*+?!$" +#define CCL_CHARS "#?\\" + +static int has_ccl_masking(const char *src_str, + size_t src_len, + const char **truncation_aliases, + const char **mask_aliases) +{ + size_t j; + int quote_mode = 0; + + for (j = 0; j < src_len; j++) + { + size_t op_size; + if (j > 0 && src_str[j-1] == '\\') + ; + else if (src_str[j] == '"') + quote_mode = !quote_mode; + else if (!quote_mode && + (op_size = cmp_operator(truncation_aliases, + src_str + j))) + return 1; + else if (!quote_mode && + (op_size = cmp_operator(mask_aliases, + src_str + j))) + return 1; + } + return 0; +} + +static int append_term(CCL_parser cclp, const char *src_str, size_t src_len, + char *dst_term, int regex_trunc, int z3958_trunc, + const char **truncation_aliases, + const char **mask_aliases, + int is_first, int is_last, + int *left_trunc, int *right_trunc) +{ + size_t j; + int quote_mode = 0; + + for (j = 0; j < src_len; j++) + { + size_t op_size; + if (j > 0 && src_str[j-1] == '\\') + { + if (regex_trunc && strchr(REGEX_CHARS "\\", src_str[j])) + strcat(dst_term, "\\"); + else if (z3958_trunc && strchr(CCL_CHARS "\\", src_str[j])) + strcat(dst_term, "\\"); + strxcat(dst_term, src_str + j, 1); + } + else if (src_str[j] == '"') + quote_mode = !quote_mode; + else if (!quote_mode && + (op_size = cmp_operator(truncation_aliases, + src_str + j)) + ) + { + j += (op_size - 1); /* j++ in for loop */ + if (regex_trunc) + strcat(dst_term, ".*"); + else if (z3958_trunc) + strcat(dst_term, "?"); + else if (is_first && j == 0) + *left_trunc = 1; + else if (is_last && j == src_len - 1) + *right_trunc = 1; + else + { + cclp->error_code = CCL_ERR_TRUNC_NOT_EMBED; + return -1; + } + } + else if (!quote_mode && + (op_size = cmp_operator(mask_aliases, src_str + j))) + { + j += (op_size - 1); /* j++ in for loop */ + if (regex_trunc) + strcat(dst_term, "."); + else if (z3958_trunc) + strcat(dst_term, "#"); + else + { + cclp->error_code = CCL_ERR_TRUNC_NOT_SINGLE; + return -1; + } + } + else if (src_str[j] != '\\') + { + if (regex_trunc && strchr(REGEX_CHARS, src_str[j])) + strcat(dst_term, "\\"); + else if (z3958_trunc && strchr(CCL_CHARS, src_str[j])) + strcat(dst_term, "\\"); + strxcat(dst_term, src_str + j, 1); + } + } + return 0; +} + + +static struct ccl_rpn_node *ccl_term_one_use(CCL_parser cclp, + struct ccl_rpn_attr *attr_use, + ccl_qualifier_t *qa, + size_t no, int term_len, + int is_phrase, + int auto_group) +{ + struct ccl_rpn_node *p; + size_t i; + int relation_value = -1; + int position_value = -1; + int structure_value = -1; + int truncation_value = -1; + int completeness_value = -1; + + int left_trunc = 0; + int right_trunc = 0; + int regex_trunc = 0; + int z3958_trunc = 0; + int is_ccl_masked = 0; + char *attset; + struct ccl_token *lookahead = cclp->look_token; + const char **truncation_aliases; + const char *t_default[2]; + const char **mask_aliases; + const char *m_default[2]; + + truncation_aliases = + ccl_qual_search_special(cclp->bibset, "truncation"); + if (!truncation_aliases) + { + truncation_aliases = t_default; + t_default[0] = "?"; + t_default[1] = 0; + } + + mask_aliases = + ccl_qual_search_special(cclp->bibset, "mask"); + if (!mask_aliases) + { + mask_aliases = m_default; + m_default[0] = "#"; + m_default[1] = 0; + } + + + for (i = 0; i < no; i++) + { + if (has_ccl_masking(lookahead->name, lookahead->len, + truncation_aliases, + mask_aliases)) + is_ccl_masked = 1; + lookahead = lookahead->next; + } + lookahead = cclp->look_token; + + p = ccl_rpn_node_create(CCL_RPN_TERM); + p->u.t.attr_list = NULL; + p->u.t.term = NULL; + if (qa && qa[0]) + { + const char *n = ccl_qual_get_name(qa[0]); + if (n) + p->u.t.qual = xstrdup(n); + } + /* go through all attributes and add them to the attribute list */ + for (i = 0; qa && qa[i]; i++) + { + struct ccl_rpn_attr *attr; + for (attr = ccl_qual_get_attr(qa[i]); attr; attr = attr->next) + if (attr->type != 1 || attr == attr_use) + { + switch (attr->kind) + { + case CCL_RPN_ATTR_STRING: + ccl_add_attr_string(p, attr->set, attr->type, + attr->value.str); + break; + case CCL_RPN_ATTR_NUMERIC: + if (attr->value.numeric > 0) + { /* deal only with REAL attributes (positive) */ + switch (attr->type) + { + case CCL_BIB1_REL: + if (relation_value != -1) + continue; + relation_value = attr->value.numeric; + break; + case CCL_BIB1_POS: + if (position_value != -1) + continue; + position_value = attr->value.numeric; + break; + case CCL_BIB1_STR: + if (structure_value != -1) + continue; + structure_value = attr->value.numeric; + break; + case CCL_BIB1_TRU: + if (truncation_value != -1) + continue; + truncation_value = attr->value.numeric; + break; + case CCL_BIB1_COM: + if (completeness_value != -1) + continue; + completeness_value = attr->value.numeric; + break; + } + ccl_add_attr_numeric(p, attr->set, attr->type, + attr->value.numeric); + } + } + } + } + attset = 0; + if (structure_value == -1 && ( + auto_group || + qual_val_type(qa, CCL_BIB1_STR, CCL_BIB1_STR_WP, &attset)) + ) + { + if (!is_phrase) + ccl_add_attr_numeric(p, attset, CCL_BIB1_STR, 2); + else + ccl_add_attr_numeric(p, attset, CCL_BIB1_STR, 1); + } + if (qual_val_type(qa, CCL_BIB1_TRU, CCL_BIB1_TRU_CAN_REGEX, + &attset)) + { + if (is_ccl_masked) + regex_trunc = 1; /* regex trunc (102) allowed */ + } + else if (qual_val_type(qa, CCL_BIB1_TRU, CCL_BIB1_TRU_CAN_Z3958, + &attset)) + { + if (is_ccl_masked) + z3958_trunc = 1; /* Z39.58 trunc (CCL) trunc allowed */ + } + /* make the RPN token */ + p->u.t.term = (char *)xmalloc(term_len * 2 + 2); + ccl_assert(p->u.t.term); + p->u.t.term[0] = '\0'; + + for (i = 0; i < no; i++) + { + const char *src_str = lookahead->name; + size_t src_len = lookahead->len; + + if (p->u.t.term[0] && lookahead->ws_prefix_len) + { + strxcat(p->u.t.term, lookahead->ws_prefix_buf, + lookahead->ws_prefix_len); + } + if (append_term(cclp, src_str, src_len, p->u.t.term, regex_trunc, + z3958_trunc, truncation_aliases, mask_aliases, + i == 0, i == no - 1, + &left_trunc, &right_trunc)) + { + ccl_rpn_delete(p); + return NULL; + } + lookahead = lookahead->next; + } + if (left_trunc && right_trunc) + { + if (!qual_val_type(qa, CCL_BIB1_TRU, CCL_BIB1_TRU_CAN_BOTH, + &attset)) + { + cclp->error_code = CCL_ERR_TRUNC_NOT_BOTH; + ccl_rpn_delete(p); + return NULL; + } + ccl_add_attr_numeric(p, attset, CCL_BIB1_TRU, 3); + } + else if (right_trunc) + { + if (!qual_val_type(qa, CCL_BIB1_TRU, CCL_BIB1_TRU_CAN_RIGHT, + &attset)) + { + cclp->error_code = CCL_ERR_TRUNC_NOT_RIGHT; + ccl_rpn_delete(p); + return NULL; + } + ccl_add_attr_numeric(p, attset, CCL_BIB1_TRU, 1); + } + else if (left_trunc) + { + if (!qual_val_type(qa, CCL_BIB1_TRU, CCL_BIB1_TRU_CAN_LEFT, + &attset)) + { + cclp->error_code = CCL_ERR_TRUNC_NOT_LEFT; + ccl_rpn_delete(p); + return NULL; + } + ccl_add_attr_numeric(p, attset, CCL_BIB1_TRU, 2); + } + else if (regex_trunc) + { + ccl_add_attr_numeric(p, attset, CCL_BIB1_TRU, 102); + } + else if (z3958_trunc) + { + ccl_add_attr_numeric(p, attset, CCL_BIB1_TRU, 104); + } + else + { + if (qual_val_type(qa, CCL_BIB1_TRU, CCL_BIB1_TRU_CAN_NONE, + &attset)) + ccl_add_attr_numeric(p, attset, CCL_BIB1_TRU, 100); + } + return p; +} + +/** + * search_term: Parse CCL search term. * cclp: CCL Parser * qa: Qualifier attributes already applied. * term_list: tokens we accept as terms in context * multi: whether we accept "multiple" tokens * return: pointer to node(s); NULL on error. */ -static struct ccl_rpn_node *search_term_x (CCL_parser cclp, - struct ccl_rpn_attr **qa, - int *term_list, int multi) +static struct ccl_rpn_node *search_term_x(CCL_parser cclp, + ccl_qualifier_t *qa, + int *term_list, int multi) { struct ccl_rpn_node *p_top = 0; struct ccl_token *lookahead = cclp->look_token; int and_list = 0; + int auto_group = 0; int or_list = 0; - char *attset; - const char *truncation_aliases; - truncation_aliases = - ccl_qual_search_special(cclp->bibset, "truncation"); - if (!truncation_aliases) - truncation_aliases = "?"; - - if (qual_val_type (qa, CCL_BIB1_STR, CCL_BIB1_STR_AND_LIST, 0)) + if (qual_val_type(qa, CCL_BIB1_STR, CCL_BIB1_STR_AND_LIST, 0)) and_list = 1; - if (qual_val_type (qa, CCL_BIB1_STR, CCL_BIB1_STR_OR_LIST, 0)) + if (qual_val_type(qa, CCL_BIB1_STR, CCL_BIB1_STR_AUTO_GROUP, 0)) + auto_group = 1; + if (qual_val_type(qa, CCL_BIB1_STR, CCL_BIB1_STR_OR_LIST, 0)) or_list = 1; while (1) { - struct ccl_rpn_node *p; + struct ccl_rpn_node *p = 0; size_t no, i; - int no_spaces = 0; - int left_trunc = 0; - int right_trunc = 0; - int mid_trunc = 0; - int relation_value = -1; - int position_value = -1; - int structure_value = -1; - int truncation_value = -1; - int completeness_value = -1; int len = 0; + int is_phrase = 0; size_t max = 200; if (and_list || or_list || !multi) max = 1; - - /* ignore commas when dealing with and-lists .. */ + + /* ignore commas when dealing with and-lists .. */ if (and_list && lookahead && lookahead->kind == CCL_TOK_COMMA) { - lookahead = lookahead->next; + lookahead = lookahead->next; ADVANCE; - continue; + continue; } - /* go through each TERM token. If no truncation attribute is yet - met, then look for left/right truncation markers (?) and - set left_trunc/right_trunc/mid_trunc accordingly */ for (no = 0; no < max && is_term_ok(lookahead->kind, term_list); no++) { + int this_is_phrase = 0; for (i = 0; ilen; i++) if (lookahead->name[i] == ' ') - no_spaces++; - else if (strchr(truncation_aliases, lookahead->name[i])) - { - if (no == 0 && i == 0 && lookahead->len >= 1) - left_trunc = 1; - else if (!is_term_ok(lookahead->next->kind, term_list) && - i == lookahead->len-1 && i >= 1) - right_trunc = 1; - else - mid_trunc = 1; - } - len += 1+lookahead->len; + this_is_phrase = 1; + if (auto_group) + { + if (no > 0 && (is_phrase || is_phrase != this_is_phrase)) + break; + is_phrase = this_is_phrase; + } + else if (this_is_phrase || no > 0) + is_phrase = 1; + len += 1+lookahead->len+lookahead->ws_prefix_len; lookahead = lookahead->next; } if (len == 0) break; /* no more terms . stop . */ - - if (p_top) - { - if (or_list) - p = mk_node (CCL_RPN_OR); - else if (and_list) - p = mk_node (CCL_RPN_AND); - else - p = mk_node (CCL_RPN_AND); - p->u.p[0] = p_top; - p_top = p; - } - - /* create the term node, but wait a moment before adding the term */ - p = mk_node (CCL_RPN_TERM); - p->u.t.attr_list = NULL; - p->u.t.term = NULL; - - /* make the top node point to us.. */ - if (p_top) - p_top->u.p[1] = p; - else - p_top = p; - - /* go through all attributes and add them to the attribute list */ - for (i=0; qa && qa[i]; i++) + for (i = 0; qa && qa[i]; i++) { struct ccl_rpn_attr *attr; - - for (attr = qa[i]; attr; attr = attr->next) - switch(attr->kind) - { - case CCL_RPN_ATTR_STRING: - add_attr_string(p, attr->set, attr->type, - attr->value.str); - break; - case CCL_RPN_ATTR_NUMERIC: - if (attr->value.numeric > 0) - { /* deal only with REAL attributes (positive) */ - switch (attr->type) - { - case CCL_BIB1_REL: - if (relation_value != -1) - continue; - relation_value = attr->value.numeric; - break; - case CCL_BIB1_POS: - if (position_value != -1) - continue; - position_value = attr->value.numeric; - break; - case CCL_BIB1_STR: - if (structure_value != -1) - continue; - structure_value = attr->value.numeric; - break; - case CCL_BIB1_TRU: - if (truncation_value != -1) - continue; - truncation_value = attr->value.numeric; - left_trunc = right_trunc = mid_trunc = 0; - break; - case CCL_BIB1_COM: - if (completeness_value != -1) - continue; - completeness_value = attr->value.numeric; - break; - } - add_attr_numeric(p, attr->set, attr->type, - attr->value.numeric); - } - } - } - /* len now holds the number of characters in the RPN term */ - /* no holds the number of CCL tokens (1 or more) */ - - if (structure_value == -1 && - qual_val_type (qa, CCL_BIB1_STR, CCL_BIB1_STR_WP, &attset)) - { /* no structure attribute met. Apply either structure attribute - WORD or PHRASE depending on number of CCL tokens */ - if (no == 1 && no_spaces == 0) - add_attr_numeric (p, attset, CCL_BIB1_STR, 2); - else - add_attr_numeric (p, attset, CCL_BIB1_STR, 1); - } - /* make the RPN token */ - p->u.t.term = (char *)xmalloc (len); - ccl_assert (p->u.t.term); - p->u.t.term[0] = '\0'; - for (i = 0; ilook_token->name; - int src_len = cclp->look_token->len; - - if (i == 0 && left_trunc) - { - src_len--; - src_str++; - } - if (i == no-1 && right_trunc) - src_len--; - if (src_len) - { - int len = strlen(p->u.t.term); - if (len && - !strchr("-+", *src_str) && - !strchr("-+", p->u.t.term[len-1])) + for (attr = ccl_qual_get_attr(qa[i]); attr; attr = attr->next) + if (attr->type == 1) { - strcat (p->u.t.term, " "); + struct ccl_rpn_node *tmp2; + tmp2 = ccl_term_one_use(cclp, attr, qa, no, len, + is_phrase, + auto_group); + if (!tmp2) + { + ccl_rpn_delete(p); + return 0; + } + if (!p) + p = tmp2; + else + { + struct ccl_rpn_node *tmp1; + tmp1 = ccl_rpn_node_create(CCL_RPN_OR); + tmp1->u.p[0] = p; + tmp1->u.p[1] = tmp2; + p = tmp1; + } } - } - strxcat (p->u.t.term, src_str, src_len); - ADVANCE; - } - if (left_trunc && right_trunc) - { - if (!qual_val_type (qa, CCL_BIB1_TRU, CCL_BIB1_TRU_CAN_BOTH, - &attset)) - { - cclp->error_code = CCL_ERR_TRUNC_NOT_BOTH; - ccl_rpn_delete (p); - return NULL; - } - add_attr_numeric (p, attset, CCL_BIB1_TRU, 3); } - else if (right_trunc) - { - if (!qual_val_type (qa, CCL_BIB1_TRU, CCL_BIB1_TRU_CAN_RIGHT, - &attset)) - { - cclp->error_code = CCL_ERR_TRUNC_NOT_RIGHT; - ccl_rpn_delete (p); - return NULL; - } - add_attr_numeric (p, attset, CCL_BIB1_TRU, 1); - } - else if (left_trunc) + if (!p) + p = ccl_term_one_use(cclp, 0 /* attr: no use */, qa, no, len, + is_phrase, auto_group); + for (i = 0; i < no; i++) + ADVANCE; + if (!p) + return 0; + /* make the top node point to us.. */ + if (p_top) { - if (!qual_val_type (qa, CCL_BIB1_TRU, CCL_BIB1_TRU_CAN_LEFT, - &attset)) - { - cclp->error_code = CCL_ERR_TRUNC_NOT_LEFT; - ccl_rpn_delete (p); - return NULL; - } - add_attr_numeric (p, attset, CCL_BIB1_TRU, 2); + struct ccl_rpn_node *tmp; + + if (or_list) + tmp = ccl_rpn_node_create(CCL_RPN_OR); + else if (and_list) + tmp = ccl_rpn_node_create(CCL_RPN_AND); + else + tmp = ccl_rpn_node_create(CCL_RPN_AND); + tmp->u.p[0] = p_top; + tmp->u.p[1] = p; + + p_top = tmp; } else - { - if (qual_val_type (qa, CCL_BIB1_TRU, CCL_BIB1_TRU_CAN_NONE, - &attset)) - add_attr_numeric (p, attset, CCL_BIB1_TRU, 100); - } + p_top = p; + if (!multi) break; } @@ -529,16 +665,46 @@ static struct ccl_rpn_node *search_term_x (CCL_parser cclp, return p_top; } -static struct ccl_rpn_node *search_term (CCL_parser cclp, - struct ccl_rpn_attr **qa) +static struct ccl_rpn_node *search_term(CCL_parser cclp, ccl_qualifier_t *qa) { static int list[] = {CCL_TOK_TERM, CCL_TOK_COMMA, -1}; return search_term_x(cclp, qa, list, 0); } + +static struct ccl_rpn_node *search_terms2(CCL_parser cclp, + ccl_qualifier_t *qa) +{ + if (KIND == CCL_TOK_LP) + { + struct ccl_rpn_node *p; + ADVANCE; + if (!(p = find_spec(cclp, qa))) + return NULL; + if (KIND != CCL_TOK_RP) + { + cclp->error_code = CCL_ERR_RP_EXPECTED; + ccl_rpn_delete(p); + return NULL; + } + ADVANCE; + return p; + } + else + { + static int list[] = { + CCL_TOK_TERM, CCL_TOK_COMMA,CCL_TOK_EQ, + CCL_TOK_REL, CCL_TOK_SET, -1}; + + return search_term_x(cclp, qa, list, 1); + } +} + + + static -struct ccl_rpn_node *qualifiers_order (CCL_parser cclp, - struct ccl_rpn_attr **ap, char *attset) +struct ccl_rpn_node *qualifiers_order(CCL_parser cclp, + ccl_qualifier_t *ap, char *attset) { int rel = 0; struct ccl_rpn_node *p; @@ -554,207 +720,182 @@ struct ccl_rpn_node *qualifiers_order (CCL_parser cclp, } else if (cclp->look_token->len == 2) { - if (!memcmp (cclp->look_token->name, "<=", 2)) + if (!memcmp(cclp->look_token->name, "<=", 2)) rel = 2; - else if (!memcmp (cclp->look_token->name, ">=", 2)) + else if (!memcmp(cclp->look_token->name, ">=", 2)) rel = 4; - else if (!memcmp (cclp->look_token->name, "<>", 2)) + else if (!memcmp(cclp->look_token->name, "<>", 2)) rel = 6; } if (!rel) { cclp->error_code = CCL_ERR_BAD_RELATION; - return NULL; + return NULL; } ADVANCE; /* skip relation */ if (rel == 3 && - qual_val_type(ap, CCL_BIB1_REL, CCL_BIB1_REL_PORDER, 0)) + qual_val_type(ap, CCL_BIB1_REL, CCL_BIB1_REL_PORDER, 0)) { - /* allow - inside term and treat it as range _always_ */ - /* relation is =. Extract "embedded" - to separate terms */ - if (KIND == CCL_TOK_TERM) - { - size_t i; - for (i = 0; ilook_token->len; i++) - { - if (cclp->look_token->name[i] == '-') - break; - } - - if (cclp->look_token->len > 1 && i == 0) - { /* -xx*/ - struct ccl_token *ntoken = ccl_token_add (cclp->look_token); - - ntoken->kind = CCL_TOK_TERM; - ntoken->name = cclp->look_token->name + 1; - ntoken->len = cclp->look_token->len - 1; - - cclp->look_token->len = 1; - cclp->look_token->name = "-"; - } - else if (cclp->look_token->len > 1 && i == cclp->look_token->len-1) - { /* xx- */ - struct ccl_token *ntoken = ccl_token_add (cclp->look_token); - - ntoken->kind = CCL_TOK_TERM; - ntoken->name = "-"; - ntoken->len = 1; - - (cclp->look_token->len)--; - } - else if (cclp->look_token->len > 2 && i < cclp->look_token->len) - { /* xx-yy */ - struct ccl_token *ntoken1 = ccl_token_add (cclp->look_token); - struct ccl_token *ntoken2 = ccl_token_add (ntoken1); - - ntoken1->kind = CCL_TOK_TERM; /* generate - */ - ntoken1->name = "-"; - ntoken1->len = 1; - - ntoken2->kind = CCL_TOK_TERM; /* generate yy */ - ntoken2->name = cclp->look_token->name + (i+1); - ntoken2->len = cclp->look_token->len - (i+1); - - cclp->look_token->len = i; /* adjust xx */ - } - else if (i == cclp->look_token->len && - cclp->look_token->next && - cclp->look_token->next->kind == CCL_TOK_TERM && - cclp->look_token->next->len > 1 && - cclp->look_token->next->name[0] == '-') - - { /* xx -yy */ - /* we _know_ that xx does not have - in it */ - struct ccl_token *ntoken = ccl_token_add (cclp->look_token); - - ntoken->kind = CCL_TOK_TERM; /* generate - */ - ntoken->name = "-"; - ntoken->len = 1; - - (ntoken->next->name)++; /* adjust yy */ - (ntoken->next->len)--; - } - } + /* allow - inside term and treat it as range _always_ */ + /* relation is =. Extract "embedded" - to separate terms */ + if (KIND == CCL_TOK_TERM) + { + size_t i; + int quote_mode = 0; + for (i = 0; ilook_token->len; i++) + { + if (i > 0 && cclp->look_token->name[i] == '\\') + ; + else if (cclp->look_token->name[i] == '"') + quote_mode = !quote_mode; + else if (cclp->look_token->name[i] == '-' && !quote_mode) + break; + } + + if (cclp->look_token->len > 1 && i == 0) + { /* -xx*/ + struct ccl_token *ntoken = ccl_token_add(cclp->look_token); + + ntoken->kind = CCL_TOK_TERM; + ntoken->name = cclp->look_token->name + 1; + ntoken->len = cclp->look_token->len - 1; + + cclp->look_token->len = 1; + cclp->look_token->name = "-"; + } + else if (cclp->look_token->len > 1 && i == cclp->look_token->len-1) + { /* xx- */ + struct ccl_token *ntoken = ccl_token_add(cclp->look_token); + + ntoken->kind = CCL_TOK_TERM; + ntoken->name = "-"; + ntoken->len = 1; + + (cclp->look_token->len)--; + } + else if (cclp->look_token->len > 2 && i < cclp->look_token->len) + { /* xx-yy */ + struct ccl_token *ntoken1 = ccl_token_add(cclp->look_token); + struct ccl_token *ntoken2 = ccl_token_add(ntoken1); + + ntoken1->kind = CCL_TOK_TERM; /* generate - */ + ntoken1->name = "-"; + ntoken1->len = 1; + + ntoken2->kind = CCL_TOK_TERM; /* generate yy */ + ntoken2->name = cclp->look_token->name + (i+1); + ntoken2->len = cclp->look_token->len - (i+1); + + cclp->look_token->len = i; /* adjust xx */ + } + else if (i == cclp->look_token->len && + cclp->look_token->next && + cclp->look_token->next->kind == CCL_TOK_TERM && + cclp->look_token->next->len > 1 && + cclp->look_token->next->name[0] == '-') + + { /* xx -yy */ + /* we _know_ that xx does not have - in it */ + struct ccl_token *ntoken = ccl_token_add(cclp->look_token); + + ntoken->kind = CCL_TOK_TERM; /* generate - */ + ntoken->name = "-"; + ntoken->len = 1; + + (ntoken->next->name)++; /* adjust yy */ + (ntoken->next->len)--; + } + } } - + if (rel == 3 && - KIND == CCL_TOK_TERM && - cclp->look_token->next && cclp->look_token->next->len == 1 && - cclp->look_token->next->name[0] == '-') + KIND == CCL_TOK_TERM && + cclp->look_token->next && cclp->look_token->next->len == 1 && + cclp->look_token->next->name[0] == '-') { - struct ccl_rpn_node *p1; - if (!(p1 = search_term (cclp, ap))) - return NULL; - ADVANCE; /* skip '-' */ - if (KIND == CCL_TOK_TERM) /* = term - term ? */ - { - struct ccl_rpn_node *p2; - - if (!(p2 = search_term (cclp, ap))) - { - ccl_rpn_delete (p1); - return NULL; - } - p = mk_node (CCL_RPN_AND); - p->u.p[0] = p1; - add_attr_numeric (p1, attset, CCL_BIB1_REL, 4); - p->u.p[1] = p2; - add_attr_numeric (p2, attset, CCL_BIB1_REL, 2); - return p; - } - else /* = term - */ - { - add_attr_numeric (p1, attset, CCL_BIB1_REL, 4); - return p1; - } + struct ccl_rpn_node *p1; + if (!(p1 = search_term(cclp, ap))) + return NULL; + ADVANCE; /* skip '-' */ + if (KIND == CCL_TOK_TERM) /* = term - term ? */ + { + struct ccl_rpn_node *p2; + + if (!(p2 = search_term(cclp, ap))) + { + ccl_rpn_delete(p1); + return NULL; + } + p = ccl_rpn_node_create(CCL_RPN_AND); + p->u.p[0] = p1; + ccl_add_attr_numeric(p1, attset, CCL_BIB1_REL, 4); + p->u.p[1] = p2; + ccl_add_attr_numeric(p2, attset, CCL_BIB1_REL, 2); + return p; + } + else /* = term - */ + { + ccl_add_attr_numeric(p1, attset, CCL_BIB1_REL, 4); + return p1; + } } else if (rel == 3 && - cclp->look_token->len == 1 && - cclp->look_token->name[0] == '-') /* = - term ? */ + cclp->look_token->len == 1 && + cclp->look_token->name[0] == '-') /* = - term ? */ { - ADVANCE; - if (!(p = search_term (cclp, ap))) - return NULL; - add_attr_numeric (p, attset, CCL_BIB1_REL, 2); - return p; - } - else if (KIND == CCL_TOK_LP) - { - ADVANCE; - if (!(p = find_spec (cclp, ap))) - return NULL; - if (KIND != CCL_TOK_RP) - { - cclp->error_code = CCL_ERR_RP_EXPECTED; - ccl_rpn_delete (p); - return NULL; - } - ADVANCE; - return p; + ADVANCE; + if (!(p = search_term(cclp, ap))) + return NULL; + ccl_add_attr_numeric(p, attset, CCL_BIB1_REL, 2); + return p; } else { - if (!(p = search_terms (cclp, ap))) - return NULL; - add_attr_numeric (p, attset, CCL_BIB1_REL, rel); - return p; + if (!(p = search_terms(cclp, ap))) + return NULL; + if (rel != 3 || + !qual_val_type(ap, CCL_BIB1_REL, CCL_BIB1_REL_OMIT_EQUALS, 0)) + ccl_add_attr_numeric(p, attset, CCL_BIB1_REL, rel); + return p; } - cclp->error_code = CCL_ERR_TERM_EXPECTED; return NULL; } static -struct ccl_rpn_node *qualifiers2 (CCL_parser cclp, struct ccl_rpn_attr **ap) +struct ccl_rpn_node *qualifier_relation(CCL_parser cclp, ccl_qualifier_t *ap) { char *attset; - struct ccl_rpn_node *p; - + if (qual_val_type(ap, CCL_BIB1_REL, CCL_BIB1_REL_ORDER, &attset) - || qual_val_type(ap, CCL_BIB1_REL, CCL_BIB1_REL_PORDER, &attset)) - return qualifiers_order(cclp, ap, attset); + || qual_val_type(ap, CCL_BIB1_REL, CCL_BIB1_REL_PORDER, &attset)) + return qualifiers_order(cclp, ap, attset); /* unordered relation */ if (KIND != CCL_TOK_EQ) { - cclp->error_code = CCL_ERR_EQ_EXPECTED; - return NULL; + cclp->error_code = CCL_ERR_EQ_EXPECTED; + return NULL; } ADVANCE; - if (KIND == CCL_TOK_LP) - { - ADVANCE; - if (!(p = find_spec (cclp, ap))) - { - return NULL; - } - if (KIND != CCL_TOK_RP) - { - cclp->error_code = CCL_ERR_RP_EXPECTED; - ccl_rpn_delete (p); - return NULL; - } - ADVANCE; - } - else - p = search_terms (cclp, ap); - return p; + return search_terms(cclp, ap); } -/* - * qualifiers1: Parse CCL qualifiers and search terms. +/** + * qualifier_list: Parse CCL qualifiers and search terms. * cclp: CCL Parser * la: Token pointer to RELATION token. * qa: Qualifier attributes already applied. * return: pointer to node(s); NULL on error. */ -static struct ccl_rpn_node *qualifiers1 (CCL_parser cclp, struct ccl_token *la, - struct ccl_rpn_attr **qa) +static struct ccl_rpn_node *qualifier_list(CCL_parser cclp, + struct ccl_token *la, + ccl_qualifier_t *qa) { struct ccl_token *lookahead = cclp->look_token; struct ccl_token *look_start = cclp->look_token; - struct ccl_rpn_attr **ap; + ccl_qualifier_t *ap; struct ccl_rpn_node *node = 0; - const char *field_str; + const char **field_str; int no = 0; int seq = 0; int i; @@ -772,15 +913,15 @@ static struct ccl_rpn_node *qualifiers1 (CCL_parser cclp, struct ccl_token *la, if (qa) for (i=0; qa[i]; i++) no++; - ap = (struct ccl_rpn_attr **)xmalloc ((no ? (no+1) : 2) * sizeof(*ap)); - ccl_assert (ap); + ap = (ccl_qualifier_t *)xmalloc((no ? (no+1) : 2) * sizeof(*ap)); + ccl_assert(ap); field_str = ccl_qual_search_special(cclp->bibset, "field"); if (field_str) { - if (!strcmp (field_str, "or")) + if (!strcmp(field_str[0], "or")) mode_merge = 0; - else if (!strcmp (field_str, "merge")) + else if (!strcmp(field_str[0], "merge")) mode_merge = 1; } if (!mode_merge) @@ -791,22 +932,23 @@ static struct ccl_rpn_node *qualifiers1 (CCL_parser cclp, struct ccl_token *la, { ap[1] = 0; seq = 0; - while ((ap[0] = ccl_qual_search (cclp, lookahead->name, - lookahead->len, seq)) != 0) + while ((ap[0] = ccl_qual_search(cclp, lookahead->name, + lookahead->len, seq)) != 0) { struct ccl_rpn_node *node_sub; cclp->look_token = la; - - node_sub = qualifiers2(cclp, ap); + + node_sub = qualifier_relation(cclp, ap); if (!node_sub) { - ccl_rpn_delete (node); - xfree (ap); + ccl_rpn_delete(node); + xfree(ap); return 0; } if (node) { - struct ccl_rpn_node *node_this = mk_node(CCL_RPN_OR); + struct ccl_rpn_node *node_this = + ccl_rpn_node_create(CCL_RPN_OR); node_this->u.p[0] = node; node_this->u.p[1] = node_sub; node = node_this; @@ -819,7 +961,7 @@ static struct ccl_rpn_node *qualifiers1 (CCL_parser cclp, struct ccl_token *la, { cclp->look_token = lookahead; cclp->error_code = CCL_ERR_UNKNOWN_QUAL; - xfree (ap); + xfree(ap); return NULL; } lookahead = lookahead->next; @@ -837,18 +979,18 @@ static struct ccl_rpn_node *qualifiers1 (CCL_parser cclp, struct ccl_token *la, lookahead = look_start; for (i = 0; lookahead != la; i++) { - ap[i] = ccl_qual_search (cclp, lookahead->name, + ap[i] = ccl_qual_search(cclp, lookahead->name, lookahead->len, seq); if (ap[i]) found++; if (!ap[i] && seq > 0) - ap[i] = ccl_qual_search (cclp, lookahead->name, + ap[i] = ccl_qual_search(cclp, lookahead->name, lookahead->len, 0); if (!ap[i]) { cclp->look_token = lookahead; cclp->error_code = CCL_ERR_UNKNOWN_QUAL; - xfree (ap); + xfree(ap); return NULL; } lookahead = lookahead->next; @@ -857,27 +999,28 @@ static struct ccl_rpn_node *qualifiers1 (CCL_parser cclp, struct ccl_token *la, } if (qa) { - struct ccl_rpn_attr **qa0 = qa; - + ccl_qualifier_t *qa0 = qa; + while (*qa0) ap[i++] = *qa0++; } ap[i] = NULL; - + if (!found) break; - + cclp->look_token = lookahead; - - node_sub = qualifiers2(cclp, ap); + + node_sub = qualifier_relation(cclp, ap); if (!node_sub) { - ccl_rpn_delete (node); + ccl_rpn_delete(node); break; } if (node) { - struct ccl_rpn_node *node_this = mk_node(CCL_RPN_OR); + struct ccl_rpn_node *node_this = + ccl_rpn_node_create(CCL_RPN_OR); node_this->u.p[0] = node; node_this->u.p[1] = node_sub; node = node_this; @@ -887,24 +1030,24 @@ static struct ccl_rpn_node *qualifiers1 (CCL_parser cclp, struct ccl_token *la, seq++; } } - xfree (ap); + xfree(ap); return node; } -/* +/** * search_terms: Parse CCL search terms - including proximity. * cclp: CCL Parser * qa: Qualifier attributes already applied. * return: pointer to node(s); NULL on error. */ -static struct ccl_rpn_node *search_terms (CCL_parser cclp, - struct ccl_rpn_attr **qa) +static struct ccl_rpn_node *search_terms(CCL_parser cclp, ccl_qualifier_t *qa) { static int list[] = { - CCL_TOK_TERM, CCL_TOK_COMMA,CCL_TOK_EQ, CCL_TOK_REL, CCL_TOK_SET, -1}; + CCL_TOK_TERM, CCL_TOK_COMMA,CCL_TOK_EQ, + CCL_TOK_REL, CCL_TOK_SET, -1}; struct ccl_rpn_node *p1, *p2, *pn; - p1 = search_term_x (cclp, qa, list, 1); + p1 = search_terms2(cclp, qa); if (!p1) return NULL; while (1) @@ -914,7 +1057,7 @@ static struct ccl_rpn_node *search_terms (CCL_parser cclp, struct ccl_rpn_node *p_prox = 0; /* ! word order specified */ /* % word order not specified */ - p_prox = mk_node(CCL_RPN_TERM); + p_prox = ccl_rpn_node_create(CCL_RPN_TERM); p_prox->u.t.term = (char *) xmalloc(1 + cclp->look_token->len); memcpy(p_prox->u.t.term, cclp->look_token->name, cclp->look_token->len); @@ -922,13 +1065,13 @@ static struct ccl_rpn_node *search_terms (CCL_parser cclp, p_prox->u.t.attr_list = 0; ADVANCE; - p2 = search_term_x (cclp, qa, list, 1); + p2 = search_terms2(cclp, qa); if (!p2) { - ccl_rpn_delete (p1); + ccl_rpn_delete(p1); return NULL; } - pn = mk_node (CCL_RPN_PROX); + pn = ccl_rpn_node_create(CCL_RPN_PROX); pn->u.p[0] = p1; pn->u.p[1] = p2; pn->u.p[2] = p_prox; @@ -936,13 +1079,13 @@ static struct ccl_rpn_node *search_terms (CCL_parser cclp, } else if (is_term_ok(KIND, list)) { - p2 = search_term_x (cclp, qa, list, 1); + p2 = search_terms2(cclp, qa); if (!p2) { - ccl_rpn_delete (p1); + ccl_rpn_delete(p1); return NULL; } - pn = mk_node (CCL_RPN_PROX); + pn = ccl_rpn_node_create(CCL_RPN_PROX); pn->u.p[0] = p1; pn->u.p[1] = p2; pn->u.p[2] = 0; @@ -954,33 +1097,18 @@ static struct ccl_rpn_node *search_terms (CCL_parser cclp, return p1; } -/* +/** * search_elements: Parse CCL search elements * cclp: CCL Parser * qa: Qualifier attributes already applied. * return: pointer to node(s); NULL on error. */ -static struct ccl_rpn_node *search_elements (CCL_parser cclp, - struct ccl_rpn_attr **qa) +static struct ccl_rpn_node *search_elements(CCL_parser cclp, + ccl_qualifier_t *qa) { struct ccl_rpn_node *p1; struct ccl_token *lookahead; - if (KIND == CCL_TOK_LP) - { - ADVANCE; - p1 = find_spec (cclp, qa); - if (!p1) - return NULL; - if (KIND != CCL_TOK_RP) - { - cclp->error_code = CCL_ERR_RP_EXPECTED; - ccl_rpn_delete (p1); - return NULL; - } - ADVANCE; - return p1; - } - else if (KIND == CCL_TOK_SET) + if (KIND == CCL_TOK_SET) { ADVANCE; if (KIND == CCL_TOK_EQ) @@ -990,8 +1118,8 @@ static struct ccl_rpn_node *search_elements (CCL_parser cclp, cclp->error_code = CCL_ERR_SETNAME_EXPECTED; return NULL; } - p1 = mk_node (CCL_RPN_SET); - p1->u.setname = copy_token_name (cclp->look_token); + p1 = ccl_rpn_node_create(CCL_RPN_SET); + p1->u.setname = copy_token_name(cclp->look_token); ADVANCE; return p1; } @@ -1001,16 +1129,16 @@ static struct ccl_rpn_node *search_elements (CCL_parser cclp, { lookahead = lookahead->next; if (lookahead->kind == CCL_TOK_REL || lookahead->kind == CCL_TOK_EQ) - return qualifiers1 (cclp, lookahead, qa); + return qualifier_list(cclp, lookahead, qa); if (lookahead->kind != CCL_TOK_COMMA) break; lookahead = lookahead->next; } - if (qa) - return search_terms (cclp, qa); + if (qa || lookahead->kind == CCL_TOK_LP) + return search_terms(cclp, qa); else { - struct ccl_rpn_attr *qa[2]; + ccl_qualifier_t qa[2]; struct ccl_rpn_node *node = 0; int seq; lookahead = cclp->look_token; @@ -1025,15 +1153,16 @@ static struct ccl_rpn_node *search_elements (CCL_parser cclp, cclp->look_token = lookahead; - node_sub = search_terms (cclp, qa); + node_sub = search_terms(cclp, qa); if (!node_sub) { - ccl_rpn_delete (node); + ccl_rpn_delete(node); return 0; } if (node) { - struct ccl_rpn_node *node_this = mk_node(CCL_RPN_OR); + struct ccl_rpn_node *node_this = + ccl_rpn_node_create(CCL_RPN_OR); node_this->u.p[0] = node; node_this->u.p[1] = node_sub; node_this->u.p[2] = 0; @@ -1043,22 +1172,21 @@ static struct ccl_rpn_node *search_elements (CCL_parser cclp, node = node_sub; } if (!node) - node = search_terms (cclp, 0); + node = search_terms(cclp, 0); return node; } } -/* +/** * find_spec: Parse CCL find specification * cclp: CCL Parser * qa: Qualifier attributes already applied. * return: pointer to node(s); NULL on error. */ -static struct ccl_rpn_node *find_spec (CCL_parser cclp, - struct ccl_rpn_attr **qa) +static struct ccl_rpn_node *find_spec(CCL_parser cclp, ccl_qualifier_t *qa) { struct ccl_rpn_node *p1, *p2, *pn; - if (!(p1 = search_elements (cclp, qa))) + if (!(p1 = search_elements(cclp, qa))) return NULL; while (1) { @@ -1066,13 +1194,13 @@ static struct ccl_rpn_node *find_spec (CCL_parser cclp, { case CCL_TOK_AND: ADVANCE; - p2 = search_elements (cclp, qa); + p2 = search_elements(cclp, qa); if (!p2) { - ccl_rpn_delete (p1); + ccl_rpn_delete(p1); return NULL; } - pn = mk_node (CCL_RPN_AND); + pn = ccl_rpn_node_create(CCL_RPN_AND); pn->u.p[0] = p1; pn->u.p[1] = p2; pn->u.p[2] = 0; @@ -1080,13 +1208,13 @@ static struct ccl_rpn_node *find_spec (CCL_parser cclp, continue; case CCL_TOK_OR: ADVANCE; - p2 = search_elements (cclp, qa); + p2 = search_elements(cclp, qa); if (!p2) { - ccl_rpn_delete (p1); + ccl_rpn_delete(p1); return NULL; } - pn = mk_node (CCL_RPN_OR); + pn = ccl_rpn_node_create(CCL_RPN_OR); pn->u.p[0] = p1; pn->u.p[1] = p2; pn->u.p[2] = 0; @@ -1094,13 +1222,13 @@ static struct ccl_rpn_node *find_spec (CCL_parser cclp, continue; case CCL_TOK_NOT: ADVANCE; - p2 = search_elements (cclp, qa); + p2 = search_elements(cclp, qa); if (!p2) { - ccl_rpn_delete (p1); + ccl_rpn_delete(p1); return NULL; } - pn = mk_node (CCL_RPN_NOT); + pn = ccl_rpn_node_create(CCL_RPN_NOT); pn->u.p[0] = p1; pn->u.p[1] = p2; pn->u.p[2] = 0; @@ -1112,19 +1240,29 @@ static struct ccl_rpn_node *find_spec (CCL_parser cclp, return p1; } -struct ccl_rpn_node *ccl_parser_find (CCL_parser cclp, struct ccl_token *list) +struct ccl_rpn_node *ccl_parser_find_str(CCL_parser cclp, const char *str) +{ + struct ccl_rpn_node *p; + struct ccl_token *list = ccl_parser_tokenize(cclp, str); + p = ccl_parser_find_token(cclp, list); + ccl_token_del(list); + return p; +} + +struct ccl_rpn_node *ccl_parser_find_token(CCL_parser cclp, + struct ccl_token *list) { struct ccl_rpn_node *p; cclp->look_token = list; - p = find_spec (cclp, NULL); + p = find_spec(cclp, NULL); if (p && KIND != CCL_TOK_EOL) { if (KIND == CCL_TOK_RP) cclp->error_code = CCL_ERR_BAD_RP; else cclp->error_code = CCL_ERR_OP_EXPECTED; - ccl_rpn_delete (p); + ccl_rpn_delete(p); p = NULL; } cclp->error_pos = cclp->look_token->name; @@ -1135,33 +1273,7 @@ struct ccl_rpn_node *ccl_parser_find (CCL_parser cclp, struct ccl_token *list) return p; } -/* - * ccl_find: Parse CCL find - token representation - * bibset: Bibset to be used for the parsing - * list: List of tokens - * error: Pointer to integer. Holds error no. on completion. - * pos: Pointer to char position. Holds approximate error position. - * return: RPN tree on successful completion; NULL otherwise. - */ -struct ccl_rpn_node *ccl_find (CCL_bibset bibset, struct ccl_token *list, - int *error, const char **pos) -{ - struct ccl_rpn_node *p; - CCL_parser cclp = ccl_parser_create (); - - cclp->bibset = bibset; - - p = ccl_parser_find (cclp, list); - - *error = cclp->error_code; - *pos = cclp->error_pos; - - ccl_parser_destroy (cclp); - - return p; -} - -/* +/** * ccl_find_str: Parse CCL find - string representation * bibset: Bibset to be used for the parsing * str: String to be parsed @@ -1169,22 +1281,30 @@ struct ccl_rpn_node *ccl_find (CCL_bibset bibset, struct ccl_token *list, * pos: Pointer to char position. Holds approximate error position. * return: RPN tree on successful completion; NULL otherwise. */ -struct ccl_rpn_node *ccl_find_str (CCL_bibset bibset, const char *str, - int *error, int *pos) +struct ccl_rpn_node *ccl_find_str(CCL_bibset bibset, const char *str, + int *error, int *pos) { - CCL_parser cclp = ccl_parser_create (); + CCL_parser cclp = ccl_parser_create(bibset); struct ccl_token *list; struct ccl_rpn_node *p; - cclp->bibset = bibset; - - list = ccl_parser_tokenize (cclp, str); - p = ccl_parser_find (cclp, list); + list = ccl_parser_tokenize(cclp, str); + p = ccl_parser_find_token(cclp, list); *error = cclp->error_code; if (*error) *pos = cclp->error_pos - str; - ccl_parser_destroy (cclp); - ccl_token_del (list); + ccl_parser_destroy(cclp); + ccl_token_del(list); return p; } + +/* + * Local variables: + * c-basic-offset: 4 + * c-file-style: "Stroustrup" + * indent-tabs-mode: nil + * End: + * vim: shiftwidth=4 tabstop=8 expandtab + */ +