X-Git-Url: http://git.indexdata.com/?p=yaz-moved-to-github.git;a=blobdiff_plain;f=ccl%2Fcclfind.c;h=8153a0e3a1e4c2060538b3b42194f4c987af2705;hp=f8b19a600a5d8db6d400424c1ed70c4be416f77c;hb=e12377e7ea8e58cf447492b5cb9887b839a78700;hpb=ba3b08ceb55b7448c0022892d6d013a107b26ab7 diff --git a/ccl/cclfind.c b/ccl/cclfind.c index f8b19a6..8153a0e 100644 --- a/ccl/cclfind.c +++ b/ccl/cclfind.c @@ -44,30 +44,9 @@ /* CCL find (to rpn conversion) * Europagate, 1995 * - * $Log: cclfind.c,v $ - * Revision 1.11 1999-03-31 11:15:37 adam - * Fixed memory leaks in ccl_find_str and ccl_qual_rm. + * $Id: cclfind.c,v 1.33 2003-02-14 18:49:22 adam Exp $ * - * Revision 1.10 1998/02/11 11:53:33 adam - * Changed code so that it compiles as C++. - * - * Revision 1.9 1997/09/29 08:56:37 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. - * - * Revision 1.8 1997/09/01 08:48:11 adam - * New windows NT/95 port using MSV5.0. Only a few changes made - * to avoid warnings. - * - * Revision 1.7 1997/05/14 06:53:26 adam - * C++ support. - * - * Revision 1.6 1997/04/30 08:52:06 quinn - * Null - * - * Revision 1.5 1996/10/11 15:00:24 adam - * CCL parser from Europagate Email gateway 1.0. + * Old Europagate log: * * Revision 1.16 1996/01/08 08:41:13 adam * Removed unused function. @@ -119,12 +98,10 @@ * */ -#include #include -#include #include -#include +#include /* returns type of current lookahead */ #define KIND (cclp->look_token->kind) @@ -139,7 +116,8 @@ * 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) +static int qual_val_type (struct ccl_rpn_attr **qa, int type, int value, + char **attset) { int i; struct ccl_rpn_attr *q; @@ -148,11 +126,15 @@ static int qual_val_type (struct ccl_rpn_attr **qa, int type, int value) return 0; for (i = 0; (q=qa[i]); i++) while (q) - { + { if (q->type == type && q->value == value) - return 1; - q = q->next; - } + { + if (attset) + *attset = q->set; + return 1; + } + q = q->next; + } return 0; } @@ -165,9 +147,9 @@ static int qual_val_type (struct ccl_rpn_attr **qa, int type, int value) static void strxcat (char *n, const char *src, int len) { while (*n) - n++; + n++; while (--len >= 0) - *n++ = *src++; + *n++ = *src++; *n = '\0'; } @@ -178,8 +160,8 @@ static void strxcat (char *n, const char *src, int len) */ static char *copy_token_name (struct ccl_token *tp) { - char *str = (char *)malloc (tp->len + 1); - assert (str); + char *str = (char *)xmalloc (tp->len + 1); + ccl_assert (str); memcpy (str, tp->name, tp->len); str[tp->len] = '\0'; return str; @@ -193,8 +175,8 @@ static char *copy_token_name (struct ccl_token *tp) static struct ccl_rpn_node *mk_node (int kind) { struct ccl_rpn_node *p; - p = (struct ccl_rpn_node *)malloc (sizeof(*p)); - assert (p); + p = (struct ccl_rpn_node *)xmalloc (sizeof(*p)); + ccl_assert (p); p->kind = kind; return p; } @@ -217,41 +199,61 @@ void ccl_rpn_delete (struct ccl_rpn_node *rpn) ccl_rpn_delete (rpn->u.p[1]); break; case CCL_RPN_TERM: - free (rpn->u.t.term); + xfree (rpn->u.t.term); for (attr = rpn->u.t.attr_list; attr; attr = attr1) { attr1 = attr->next; - free (attr); + if (attr->set) + xfree (attr->set); + xfree (attr); } break; case CCL_RPN_SET: - free (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]); break; } - free (rpn); + xfree (rpn); } static struct ccl_rpn_node *find_spec (CCL_parser cclp, - struct ccl_rpn_attr **qa); + struct ccl_rpn_attr **qa); + +static int is_term_ok (int look, int *list) +{ + for (;*list >= 0; list++) + if (look == *list) + return 1; + return 0; +} + static struct ccl_rpn_node *search_terms (CCL_parser cclp, - struct ccl_rpn_attr **qa); + struct ccl_rpn_attr **qa); /* * add_attr: 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 (struct ccl_rpn_node *p, int type, int value) +static void add_attr (struct ccl_rpn_node *p, const char *set, + int type, int value) { struct ccl_rpn_attr *n; - n = (struct ccl_rpn_attr *)malloc (sizeof(*n)); - 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); + } + else + n->set = 0; n->type = type; n->value = value; n->next = p->u.t.attr_list; @@ -262,232 +264,254 @@ static void add_attr (struct ccl_rpn_node *p, int type, int value) * 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 (CCL_parser cclp, - struct ccl_rpn_attr **qa) +static struct ccl_rpn_node *search_term_x (CCL_parser cclp, + struct ccl_rpn_attr **qa, + int *term_list, int multi) { - struct ccl_rpn_node *p; + struct ccl_rpn_node *p_top = 0; struct ccl_token *lookahead = cclp->look_token; - int len = 0; - size_t no, i; - 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; - - if (KIND != CCL_TOK_TERM) - { - cclp->error_code = CCL_ERR_TERM_EXPECTED; - return NULL; - } - /* 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; + int and_list = 0; + int or_list = 0; + char *attset; + const char *truncation_aliases; - if (!qa) + 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)) + and_list = 1; + if (qual_val_type (qa, CCL_BIB1_STR, CCL_BIB1_STR_OR_LIST, 0)) + or_list = 1; + while (1) { - /* no qualifier(s) applied. Use 'term' if it is defined */ + struct ccl_rpn_node *p; + 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; + size_t max = 200; + if (and_list || or_list || !multi) + max = 1; + + /* ignore commas when dealing with and-lists .. */ + if (and_list && lookahead && lookahead->kind == CCL_TOK_COMMA) + { + lookahead = lookahead->next; + ADVANCE; + 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++) + { + 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; + lookahead = lookahead->next; + } - qa = (struct ccl_rpn_attr **)malloc (2*sizeof(*qa)); - assert (qa); - qa[0] = ccl_qual_search (cclp, "term", 4); - qa[1] = NULL; - } + if (len == 0) + break; /* no more terms . stop . */ - /* 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 = qa[i]; attr; attr = attr->next) - if (attr->value > 0) - { /* deal only with REAL attributes (positive) */ - switch (attr->type) - { - case CCL_BIB1_REL: - if (relation_value != -1) - continue; - relation_value = attr->value; - break; - case CCL_BIB1_POS: - if (position_value != -1) - continue; - position_value = attr->value; - break; - case CCL_BIB1_STR: - if (structure_value != -1) - continue; - structure_value = attr->value; - break; - case CCL_BIB1_TRU: - if (truncation_value != -1) - continue; - truncation_value = attr->value; - break; - case CCL_BIB1_COM: - if (completeness_value != -1) - continue; - completeness_value = attr->value; - break; - } - add_attr (p, attr->type, attr->value); - } - } - /* 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; lookahead->kind == CCL_TOK_TERM; no++) - { - for (i = 0; ilen; i++) - if (truncation_value == -1 && lookahead->name[i] == '?') - { - if (no == 0 && i == 0 && lookahead->len >= 1) - left_trunc = 1; - else if (lookahead->next->kind != CCL_TOK_TERM && - i == lookahead->len-1 && i >= 1) - right_trunc = 1; - else - mid_trunc = 1; - } - len += 1+lookahead->len; - lookahead = lookahead->next; - } - /* 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)) - { /* no structure attribute met. Apply either structure attribute - WORD or PHRASE depending on number of CCL tokens */ - if (no == 1) - add_attr (p, CCL_BIB1_STR, 2); + + 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 - add_attr (p, CCL_BIB1_STR, 1); - } + p_top = p; - /* make the RPN token */ - p->u.t.term = (char *)malloc (len); - 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) + /* go through all attributes and add them to the attribute list */ + for (i=0; qa && qa[i]; i++) { - src_len--; - src_str++; + struct ccl_rpn_attr *attr; + + for (attr = qa[i]; attr; attr = attr->next) + if (attr->value > 0) + { /* deal only with REAL attributes (positive) */ + switch (attr->type) + { + case CCL_BIB1_REL: + if (relation_value != -1) + continue; + relation_value = attr->value; + break; + case CCL_BIB1_POS: + if (position_value != -1) + continue; + position_value = attr->value; + break; + case CCL_BIB1_STR: + if (structure_value != -1) + continue; + structure_value = attr->value; + break; + case CCL_BIB1_TRU: + if (truncation_value != -1) + continue; + truncation_value = attr->value; + left_trunc = right_trunc = mid_trunc = 0; + break; + case CCL_BIB1_COM: + if (completeness_value != -1) + continue; + completeness_value = attr->value; + break; + } + add_attr (p, attr->set, attr->type, attr->value); + } } - else if (i == no-1 && right_trunc) - src_len--; - if (i) - strcat (p->u.t.term, " "); - 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)) + /* 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 (p, attset, CCL_BIB1_STR, 2); + else + add_attr (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; ierror_code = CCL_ERR_TRUNC_NOT_BOTH; - free (qa); - ccl_rpn_delete (p); - return NULL; + const char *src_str = cclp->look_token->name; + int src_len = cclp->look_token->len; + + if (i == 0 && left_trunc) + { + src_len--; + src_str++; + } + else 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])) + { + strcat (p->u.t.term, " "); + } + } + strxcat (p->u.t.term, src_str, src_len); + ADVANCE; } - add_attr (p, CCL_BIB1_TRU, 3); - } - else if (right_trunc) - { - if (!qual_val_type (qa, CCL_BIB1_TRU, CCL_BIB1_TRU_CAN_RIGHT)) + if (left_trunc && right_trunc) { - cclp->error_code = CCL_ERR_TRUNC_NOT_RIGHT; - free (qa); - ccl_rpn_delete (p); - return NULL; + 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 (p, attset, CCL_BIB1_TRU, 3); } - add_attr (p, CCL_BIB1_TRU, 1); - } - else if (left_trunc) - { - if (!qual_val_type (qa, CCL_BIB1_TRU, CCL_BIB1_TRU_CAN_LEFT)) + else if (right_trunc) { - cclp->error_code = CCL_ERR_TRUNC_NOT_LEFT; - free (qa); - ccl_rpn_delete (p); - return NULL; + 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 (p, attset, CCL_BIB1_TRU, 1); } - add_attr (p, CCL_BIB1_TRU, 2); - } - else - { - if (qual_val_type (qa, CCL_BIB1_TRU, CCL_BIB1_TRU_CAN_NONE)) - add_attr (p, CCL_BIB1_TRU, 100); + 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; + } + add_attr (p, attset, CCL_BIB1_TRU, 2); + } + else + { + if (qual_val_type (qa, CCL_BIB1_TRU, CCL_BIB1_TRU_CAN_NONE, + &attset)) + add_attr (p, attset, CCL_BIB1_TRU, 100); + } + if (!multi) + break; } - return p; + if (!p_top) + cclp->error_code = CCL_ERR_TERM_EXPECTED; + return p_top; } -/* - * qualifiers: 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 *qualifiers (CCL_parser cclp, struct ccl_token *la, - struct ccl_rpn_attr **qa) +static struct ccl_rpn_node *search_term (CCL_parser cclp, + struct ccl_rpn_attr **qa) { - struct ccl_token *lookahead = cclp->look_token; - struct ccl_rpn_attr **ap; - int no = 0; - int i, rel; -#if 0 - if (qa) - { - cclp->error_code = CCL_ERR_DOUBLE_QUAL; - return NULL; - } -#endif - for (lookahead = cclp->look_token; lookahead != la; - lookahead=lookahead->next) - no++; - if (qa) - for (i=0; qa[i]; i++) - no++; - ap = (struct ccl_rpn_attr **)malloc ((no+1) * sizeof(*ap)); - assert (ap); - for (i = 0; cclp->look_token != la; i++) - { - ap[i] = ccl_qual_search (cclp, cclp->look_token->name, - cclp->look_token->len); - if (!ap[i]) - { - cclp->error_code = CCL_ERR_UNKNOWN_QUAL; - free (ap); - return NULL; - } - ADVANCE; - if (KIND == CCL_TOK_COMMA) - ADVANCE; - } - if (qa) - while (*qa) - ap[i++] = *qa++; - ap[i] = NULL; - if (!qual_val_type (ap, CCL_BIB1_REL, CCL_BIB1_REL_ORDER)) + static int list[] = {CCL_TOK_TERM, CCL_TOK_COMMA, -1}; + return search_term_x(cclp, qa, list, 0); +} + +static struct ccl_rpn_node *qualifiers2 (CCL_parser cclp, + struct ccl_rpn_attr **ap) +{ + char *attset; + int rel; + + if (!qual_val_type(ap, CCL_BIB1_REL, CCL_BIB1_REL_ORDER, &attset)) { /* unordered relation */ struct ccl_rpn_node *p; if (KIND != CCL_TOK_EQ) { cclp->error_code = CCL_ERR_EQ_EXPECTED; - free (ap); return NULL; } ADVANCE; @@ -496,23 +520,21 @@ static struct ccl_rpn_node *qualifiers (CCL_parser cclp, struct ccl_token *la, ADVANCE; if (!(p = find_spec (cclp, ap))) { - free (ap); return NULL; } if (KIND != CCL_TOK_RP) { cclp->error_code = CCL_ERR_RP_EXPECTED; ccl_rpn_delete (p); - free (ap); return NULL; } ADVANCE; } else p = search_terms (cclp, ap); - free (ap); return p; } + /* ordered relation ... */ rel = 0; if (cclp->look_token->len == 1) { @@ -537,135 +559,283 @@ static struct ccl_rpn_node *qualifiers (CCL_parser cclp, struct ccl_token *la, else { struct ccl_rpn_node *p; - + ADVANCE; /* skip relation */ if (KIND == CCL_TOK_TERM && - cclp->look_token->next->kind == CCL_TOK_MINUS) + 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))) - { - free (ap); - return NULL; - } + 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); - free (ap); - return NULL; - } + return NULL; + } p = mk_node (CCL_RPN_AND); p->u.p[0] = p1; - add_attr (p1, CCL_BIB1_REL, 4); + add_attr (p1, attset, CCL_BIB1_REL, 4); p->u.p[1] = p2; - add_attr (p2, CCL_BIB1_REL, 2); - free (ap); + add_attr (p2, attset, CCL_BIB1_REL, 2); return p; } else /* = term - */ { - add_attr (p1, CCL_BIB1_REL, 4); - free (ap); + add_attr (p1, attset, CCL_BIB1_REL, 4); return p1; } } - else if (KIND == CCL_TOK_MINUS) /* = - term ? */ + else if (cclp->look_token->len == 1 && + cclp->look_token->name[0] == '-') /* = - term ? */ { ADVANCE; if (!(p = search_term (cclp, ap))) - { - free (ap); - return NULL; - } - add_attr (p, CCL_BIB1_REL, 2); - free (ap); + return NULL; + add_attr (p, attset, CCL_BIB1_REL, 2); return p; } - else if (KIND == CCL_TOK_LP) - { + else if (KIND == CCL_TOK_LP) + { ADVANCE; if (!(p = find_spec (cclp, ap))) - { - free (ap); return NULL; - } if (KIND != CCL_TOK_RP) { cclp->error_code = CCL_ERR_RP_EXPECTED; ccl_rpn_delete (p); - free (ap); return NULL; } ADVANCE; - free (ap); - return p; - } - else - { + return p; + } + else + { if (!(p = search_terms (cclp, ap))) - { - free (ap); - return NULL; - } - add_attr (p, CCL_BIB1_REL, rel); - free (ap); - return p; - } + return NULL; + add_attr (p, attset, CCL_BIB1_REL, rel); + return p; + } cclp->error_code = CCL_ERR_TERM_EXPECTED; } - free (ap); return NULL; } /* + * qualifiers1: 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) +{ + struct ccl_token *lookahead = cclp->look_token; + struct ccl_token *look_start = cclp->look_token; + struct ccl_rpn_attr **ap; + struct ccl_rpn_node *node = 0; + const char *field_str; + int no = 0; + int seq = 0; + int i; + int mode_merge = 1; +#if 0 + if (qa) + { + cclp->error_code = CCL_ERR_DOUBLE_QUAL; + return NULL; + } +#endif + for (lookahead = cclp->look_token; lookahead != la; + lookahead=lookahead->next) + no++; + if (qa) + for (i=0; qa[i]; i++) + no++; + ap = (struct ccl_rpn_attr **)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")) + mode_merge = 0; + else if (!strcmp (field_str, "merge")) + mode_merge = 1; + } + if (!mode_merge) + { + /* consider each field separately and OR */ + lookahead = look_start; + while (lookahead != la) + { + ap[1] = 0; + 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); + if (!node_sub) + { + ccl_rpn_delete (node); + xfree (ap); + return 0; + } + if (node) + { + struct ccl_rpn_node *node_this = mk_node(CCL_RPN_OR); + node_this->u.p[0] = node; + node_this->u.p[1] = node_sub; + node = node_this; + } + else + node = node_sub; + seq++; + } + if (seq == 0) + { + cclp->look_token = lookahead; + cclp->error_code = CCL_ERR_UNKNOWN_QUAL; + xfree (ap); + return NULL; + } + lookahead = lookahead->next; + if (lookahead->kind == CCL_TOK_COMMA) + lookahead = lookahead->next; + } + } + else + { + /* merge attributes from ALL fields - including inherited ones */ + while (1) + { + struct ccl_rpn_node *node_sub; + int found = 0; + lookahead = look_start; + for (i = 0; lookahead != la; i++) + { + 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, + lookahead->len, 0); + if (!ap[i]) + { + cclp->look_token = lookahead; + cclp->error_code = CCL_ERR_UNKNOWN_QUAL; + xfree (ap); + return NULL; + } + lookahead = lookahead->next; + if (lookahead->kind == CCL_TOK_COMMA) + lookahead = lookahead->next; + } + if (qa) + { + struct ccl_rpn_attr **qa0 = qa; + + while (*qa0) + ap[i++] = *qa0++; + } + ap[i] = NULL; + + if (!found) + break; + + cclp->look_token = lookahead; + + node_sub = qualifiers2(cclp, ap); + if (!node_sub) + { + ccl_rpn_delete (node); + break; + } + if (node) + { + struct ccl_rpn_node *node_this = mk_node(CCL_RPN_OR); + node_this->u.p[0] = node; + node_this->u.p[1] = node_sub; + node = node_this; + } + else + node = node_sub; + seq++; + } + } + 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) + struct ccl_rpn_attr **qa) { + static int list[] = { + 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 (cclp, qa); + p1 = search_term_x (cclp, qa, list, 1); if (!p1) return NULL; while (1) { - if (KIND == CCL_TOK_PROX) - { - ADVANCE; - p2 = search_term (cclp, qa); + if (KIND == CCL_TOK_PROX) + { + struct ccl_rpn_node *p_prox = 0; + /* ! word order specified */ + /* % word order not specified */ + p_prox = mk_node(CCL_RPN_TERM); + p_prox->u.t.term = (char *) xmalloc(cclp->look_token->len); + memcpy(p_prox->u.t.term, cclp->look_token->name, + cclp->look_token->len); + p_prox->u.t.term[cclp->look_token->len] = 0; + p_prox->u.t.attr_list = 0; + + ADVANCE; + p2 = search_term_x (cclp, qa, list, 1); if (!p2) { ccl_rpn_delete (p1); return NULL; } - pn = mk_node (CCL_RPN_PROX); - pn->u.p[0] = p1; - pn->u.p[1] = p2; - p1 = pn; - } - else if (KIND == CCL_TOK_TERM) - { - p2 = search_term (cclp, qa); + pn = mk_node (CCL_RPN_PROX); + pn->u.p[0] = p1; + pn->u.p[1] = p2; + pn->u.p[2] = p_prox; + p1 = pn; + } + else if (is_term_ok(KIND, list)) + { + p2 = search_term_x (cclp, qa, list, 1); if (!p2) { ccl_rpn_delete (p1); return NULL; } - pn = mk_node (CCL_RPN_PROX); - pn->u.p[0] = p1; - pn->u.p[1] = p2; - p1 = pn; - } - else - break; + pn = mk_node (CCL_RPN_PROX); + pn->u.p[0] = p1; + pn->u.p[1] = p2; + pn->u.p[2] = 0; + p1 = pn; + } + else + break; } return p1; } @@ -677,14 +847,14 @@ static struct ccl_rpn_node *search_terms (CCL_parser cclp, * return: pointer to node(s); NULL on error. */ static struct ccl_rpn_node *search_elements (CCL_parser cclp, - struct ccl_rpn_attr **qa) + struct ccl_rpn_attr **qa) { struct ccl_rpn_node *p1; struct ccl_token *lookahead; if (KIND == CCL_TOK_LP) { - ADVANCE; - p1 = find_spec (cclp, qa); + ADVANCE; + p1 = find_spec (cclp, qa); if (!p1) return NULL; if (KIND != CCL_TOK_RP) @@ -693,12 +863,12 @@ static struct ccl_rpn_node *search_elements (CCL_parser cclp, ccl_rpn_delete (p1); return NULL; } - ADVANCE; - return p1; + ADVANCE; + return p1; } else if (KIND == CCL_TOK_SET) { - ADVANCE; + ADVANCE; if (KIND == CCL_TOK_EQ) ADVANCE; if (KIND != CCL_TOK_TERM) @@ -706,10 +876,10 @@ 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); - ADVANCE; - return p1; + p1 = mk_node (CCL_RPN_SET); + p1->u.setname = copy_token_name (cclp->look_token); + ADVANCE; + return p1; } lookahead = cclp->look_token; @@ -717,12 +887,51 @@ 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 qualifiers (cclp, lookahead, qa); + return qualifiers1 (cclp, lookahead, qa); if (lookahead->kind != CCL_TOK_COMMA) break; lookahead = lookahead->next; } - return search_terms (cclp, qa); + if (qa) + return search_terms (cclp, qa); + else + { + struct ccl_rpn_attr *qa[2]; + struct ccl_rpn_node *node = 0; + int seq; + lookahead = cclp->look_token; + + qa[1] = 0; + for(seq = 0; ;seq++) + { + struct ccl_rpn_node *node_sub; + qa[0] = ccl_qual_search(cclp, "term", 4, seq); + if (!qa[0]) + break; + + cclp->look_token = lookahead; + + node_sub = search_terms (cclp, qa); + if (!node_sub) + { + ccl_rpn_delete (node); + return 0; + } + if (node) + { + struct ccl_rpn_node *node_this = mk_node(CCL_RPN_OR); + node_this->u.p[0] = node; + node_this->u.p[1] = node_sub; + node_this->u.p[2] = 0; + node = node_this; + } + else + node = node_sub; + } + if (!node) + node = search_terms (cclp, 0); + return node; + } } /* @@ -732,56 +941,59 @@ static struct ccl_rpn_node *search_elements (CCL_parser cclp, * return: pointer to node(s); NULL on error. */ static struct ccl_rpn_node *find_spec (CCL_parser cclp, - struct ccl_rpn_attr **qa) + struct ccl_rpn_attr **qa) { struct ccl_rpn_node *p1, *p2, *pn; if (!(p1 = search_elements (cclp, qa))) return NULL; while (1) { - switch (KIND) - { - case CCL_TOK_AND: - ADVANCE; - p2 = search_elements (cclp, qa); + switch (KIND) + { + case CCL_TOK_AND: + ADVANCE; + p2 = search_elements (cclp, qa); if (!p2) { ccl_rpn_delete (p1); return NULL; } - pn = mk_node (CCL_RPN_AND); - pn->u.p[0] = p1; - pn->u.p[1] = p2; - p1 = pn; - continue; - case CCL_TOK_OR: - ADVANCE; - p2 = search_elements (cclp, qa); + pn = mk_node (CCL_RPN_AND); + pn->u.p[0] = p1; + pn->u.p[1] = p2; + pn->u.p[2] = 0; + p1 = pn; + continue; + case CCL_TOK_OR: + ADVANCE; + p2 = search_elements (cclp, qa); if (!p2) { ccl_rpn_delete (p1); return NULL; } - pn = mk_node (CCL_RPN_OR); - pn->u.p[0] = p1; - pn->u.p[1] = p2; - p1 = pn; - continue; - case CCL_TOK_NOT: - ADVANCE; - p2 = search_elements (cclp, qa); + pn = mk_node (CCL_RPN_OR); + pn->u.p[0] = p1; + pn->u.p[1] = p2; + pn->u.p[2] = 0; + p1 = pn; + continue; + case CCL_TOK_NOT: + ADVANCE; + p2 = search_elements (cclp, qa); if (!p2) { ccl_rpn_delete (p1); return NULL; } - pn = mk_node (CCL_RPN_NOT); - pn->u.p[0] = p1; - pn->u.p[1] = p2; - p1 = pn; - continue; - } - break; + pn = mk_node (CCL_RPN_NOT); + pn->u.p[0] = p1; + pn->u.p[1] = p2; + pn->u.p[2] = 0; + p1 = pn; + continue; + } + break; } return p1; } @@ -790,6 +1002,8 @@ struct ccl_rpn_node *ccl_parser_find (CCL_parser cclp, struct ccl_token *list) { struct ccl_rpn_node *p; + + cclp->look_token = list; p = find_spec (cclp, NULL); if (p && KIND != CCL_TOK_EOL)