X-Git-Url: http://git.indexdata.com/?p=yaz-moved-to-github.git;a=blobdiff_plain;f=src%2Fcqltransform.c;h=b5fe140e12ddfd652551dab643b9b67940ad7dfb;hp=8411878d1e29e7be5ed30b15d3bbaa64e58f6a4f;hb=a2a4b952e0742e1527fcb8c9a0e6c85fe35c65f8;hpb=c8f8034d0c8c592d036d19a7885ebc2db1706c59 diff --git a/src/cqltransform.c b/src/cqltransform.c index 8411878..b5fe140 100644 --- a/src/cqltransform.c +++ b/src/cqltransform.c @@ -1,12 +1,7 @@ -/* $Id: cqltransform.c,v 1.30 2007-12-20 22:45:37 adam Exp $ - Copyright (C) 1995-2007, Index Data ApS - Index Data Aps - -This file is part of the YAZ toolkit. - -See the file LICENSE. -*/ - +/* This file is part of the YAZ toolkit. + * Copyright (C) Index Data + * See the file LICENSE for details. + */ /** * \file cqltransform.c * \brief Implements CQL transform (CQL to RPN conversion). @@ -21,83 +16,239 @@ See the file LICENSE. * index * relationModifier */ +#if HAVE_CONFIG_H +#include +#endif #include #include #include -#include +#include #include #include +#include +#include +#include +#include +#include +#include struct cql_prop_entry { char *pattern; char *value; + Z_AttributeList attr_list; struct cql_prop_entry *next; }; struct cql_transform_t_ { struct cql_prop_entry *entry; + yaz_tok_cfg_t tok_cfg; int error; - char *addinfo; + WRBUF addinfo; + NMEM nmem; }; + +cql_transform_t cql_transform_create(void) +{ + cql_transform_t ct = (cql_transform_t) xmalloc(sizeof(*ct)); + ct->tok_cfg = yaz_tok_cfg_create(); + ct->error = 0; + ct->addinfo = wrbuf_alloc(); + ct->entry = 0; + ct->nmem = nmem_create(); + return ct; +} + +static int cql_transform_parse_tok_line(cql_transform_t ct, + const char *pattern, + yaz_tok_parse_t tp) +{ + int ae_num = 0; + Z_AttributeElement *ae[20]; + int ret = 0; /* 0=OK, != 0 FAIL */ + int t; + WRBUF w = wrbuf_alloc(); + + t = yaz_tok_move(tp); + + while (t == YAZ_TOK_STRING && ae_num < 20) + { + WRBUF type_str = wrbuf_alloc(); + WRBUF set_str = 0; + Z_AttributeElement *elem = 0; + const char *value_str = 0; + /* attset type=value OR type=value */ + + elem = (Z_AttributeElement *) nmem_malloc(ct->nmem, sizeof(*elem)); + elem->attributeSet = 0; + ae[ae_num] = elem; + wrbuf_puts(w, yaz_tok_parse_string(tp)); + wrbuf_puts(type_str, yaz_tok_parse_string(tp)); + t = yaz_tok_move(tp); + if (t == YAZ_TOK_EOF) + { + wrbuf_destroy(type_str); + if (set_str) + wrbuf_destroy(set_str); + break; + } + if (t == YAZ_TOK_STRING) + { + wrbuf_puts(w, " "); + wrbuf_puts(w, yaz_tok_parse_string(tp)); + set_str = type_str; + + elem->attributeSet = + yaz_string_to_oid_nmem(yaz_oid_std(), CLASS_ATTSET, + wrbuf_cstr(set_str), ct->nmem); + + type_str = wrbuf_alloc(); + wrbuf_puts(type_str, yaz_tok_parse_string(tp)); + t = yaz_tok_move(tp); + } + elem->attributeType = nmem_intdup(ct->nmem, 0); + if (sscanf(wrbuf_cstr(type_str), ODR_INT_PRINTF, elem->attributeType) + != 1) + { + wrbuf_destroy(type_str); + if (set_str) + wrbuf_destroy(set_str); + yaz_log(YLOG_WARN, "Expected numeric attribute type"); + ret = -1; + break; + } + + wrbuf_destroy(type_str); + if (set_str) + wrbuf_destroy(set_str); + + if (t != '=') + { + yaz_log(YLOG_WARN, "Expected = after after attribute type"); + ret = -1; + break; + } + t = yaz_tok_move(tp); + if (t != YAZ_TOK_STRING) /* value */ + { + yaz_log(YLOG_WARN, "Missing attribute value"); + ret = -1; + break; + } + value_str = yaz_tok_parse_string(tp); + if (yaz_isdigit(*value_str)) + { + elem->which = Z_AttributeValue_numeric; + elem->value.numeric = + nmem_intdup(ct->nmem, atoi(value_str)); + } + else + { + Z_ComplexAttribute *ca = (Z_ComplexAttribute *) + nmem_malloc(ct->nmem, sizeof(*ca)); + elem->which = Z_AttributeValue_complex; + elem->value.complex = ca; + ca->num_list = 1; + ca->list = (Z_StringOrNumeric **) + nmem_malloc(ct->nmem, sizeof(Z_StringOrNumeric *)); + ca->list[0] = (Z_StringOrNumeric *) + nmem_malloc(ct->nmem, sizeof(Z_StringOrNumeric)); + ca->list[0]->which = Z_StringOrNumeric_string; + ca->list[0]->u.string = nmem_strdup(ct->nmem, value_str); + ca->num_semanticAction = 0; + ca->semanticAction = 0; + } + wrbuf_puts(w, "="); + wrbuf_puts(w, yaz_tok_parse_string(tp)); + t = yaz_tok_move(tp); + wrbuf_puts(w, " "); + ae_num++; + } + if (ret == 0) /* OK? */ + { + struct cql_prop_entry **pp = &ct->entry; + while (*pp) + pp = &(*pp)->next; + *pp = (struct cql_prop_entry *) xmalloc(sizeof(**pp)); + (*pp)->pattern = xstrdup(pattern); + (*pp)->value = xstrdup(wrbuf_cstr(w)); + + (*pp)->attr_list.num_attributes = ae_num; + if (ae_num == 0) + (*pp)->attr_list.attributes = 0; + else + { + (*pp)->attr_list.attributes = (Z_AttributeElement **) + nmem_malloc(ct->nmem, + ae_num * sizeof(Z_AttributeElement *)); + memcpy((*pp)->attr_list.attributes, ae, + ae_num * sizeof(Z_AttributeElement *)); + } + (*pp)->next = 0; + + if (0) + { + ODR pr = odr_createmem(ODR_PRINT); + Z_AttributeList *alp = &(*pp)->attr_list; + odr_setprint_noclose(pr, yaz_log_file()); + z_AttributeList(pr, &alp, 0, 0); + odr_destroy(pr); + } + } + wrbuf_destroy(w); + return ret; +} + +int cql_transform_define_pattern(cql_transform_t ct, const char *pattern, + const char *value) +{ + int r; + yaz_tok_parse_t tp = yaz_tok_parse_buf(ct->tok_cfg, value); + yaz_tok_cfg_single_tokens(ct->tok_cfg, "="); + r = cql_transform_parse_tok_line(ct, pattern, tp); + yaz_tok_parse_destroy(tp); + return r; +} + cql_transform_t cql_transform_open_FILE(FILE *f) { + cql_transform_t ct = cql_transform_create(); char line[1024]; - cql_transform_t ct = (cql_transform_t) xmalloc (sizeof(*ct)); - struct cql_prop_entry **pp = &ct->entry; - ct->error = 0; - ct->addinfo = 0; + yaz_tok_cfg_single_tokens(ct->tok_cfg, "="); + while (fgets(line, sizeof(line)-1, f)) { - const char *cp_value_start; - const char *cp_value_end; - const char *cp_pattern_start; - const char *cp_pattern_end; - const char *cp = line; - - while (*cp && strchr(" \t", *cp)) - cp++; - cp_pattern_start = cp; - - while (*cp && !strchr(" \t\r\n=#", *cp)) - cp++; - cp_pattern_end = cp; - if (cp == cp_pattern_start) - continue; - while (*cp && strchr(" \t", *cp)) - cp++; - if (*cp != '=') - { - *pp = 0; + yaz_tok_parse_t tp = yaz_tok_parse_buf(ct->tok_cfg, line); + int t; + t = yaz_tok_move(tp); + if (t == YAZ_TOK_STRING) + { + char * pattern = xstrdup(yaz_tok_parse_string(tp)); + t = yaz_tok_move(tp); + if (t != '=') + { + yaz_tok_parse_destroy(tp); + cql_transform_close(ct); + return 0; + } + if (cql_transform_parse_tok_line(ct, pattern, tp)) + { + yaz_tok_parse_destroy(tp); + cql_transform_close(ct); + return 0; + } + xfree(pattern); + } + else if (t != YAZ_TOK_EOF) + { + yaz_tok_parse_destroy(tp); cql_transform_close(ct); return 0; } - cp++; - while (*cp && strchr(" \t\r\n", *cp)) - cp++; - cp_value_start = cp; - cp_value_end = strchr(cp, '#'); - if (!cp_value_end) - cp_value_end = strlen(line) + line; - - if (cp_value_end != cp_value_start && - strchr(" \t\r\n", cp_value_end[-1])) - cp_value_end--; - *pp = (struct cql_prop_entry *) xmalloc (sizeof(**pp)); - (*pp)->pattern = (char *) xmalloc(cp_pattern_end-cp_pattern_start + 1); - memcpy ((*pp)->pattern, cp_pattern_start, - cp_pattern_end-cp_pattern_start); - (*pp)->pattern[cp_pattern_end-cp_pattern_start] = '\0'; - - (*pp)->value = (char *) xmalloc (cp_value_end-cp_value_start + 1); - if (cp_value_start != cp_value_end) - memcpy ((*pp)->value, cp_value_start, cp_value_end-cp_value_start); - (*pp)->value[cp_value_end - cp_value_start] = '\0'; - pp = &(*pp)->next; + yaz_tok_parse_destroy(tp); } - *pp = 0; return ct; } @@ -110,14 +261,15 @@ void cql_transform_close(cql_transform_t ct) while (pe) { struct cql_prop_entry *pe_next = pe->next; - xfree (pe->pattern); - xfree (pe->value); - xfree (pe); + xfree(pe->pattern); + xfree(pe->value); + xfree(pe); pe = pe_next; } - if (ct->addinfo) - xfree (ct->addinfo); - xfree (ct); + wrbuf_destroy(ct->addinfo); + yaz_tok_cfg_destroy(ct->tok_cfg); + nmem_destroy(ct->nmem); + xfree(ct); } cql_transform_t cql_transform_open_fname(const char *fname) @@ -131,6 +283,78 @@ cql_transform_t cql_transform_open_fname(const char *fname) return ct; } +#if 0 +struct Z_AttributeElement { + Z_AttributeSetId *attributeSet; /* OPT */ + int *attributeType; + int which; + union { + int *numeric; + Z_ComplexAttribute *complex; +#define Z_AttributeValue_numeric 1 +#define Z_AttributeValue_complex 2 + } value; +}; +#endif + +static int compare_attr(Z_AttributeElement *a, Z_AttributeElement *b) +{ + ODR odr_a = odr_createmem(ODR_ENCODE); + ODR odr_b = odr_createmem(ODR_ENCODE); + int len_a, len_b; + char *buf_a, *buf_b; + int ret; + + z_AttributeElement(odr_a, &a, 0, 0); + z_AttributeElement(odr_b, &b, 0, 0); + + buf_a = odr_getbuf(odr_a, &len_a, 0); + buf_b = odr_getbuf(odr_b, &len_b, 0); + + ret = yaz_memcmp(buf_a, buf_b, len_a, len_b); + + odr_destroy(odr_a); + odr_destroy(odr_b); + return ret; +} + +const char *cql_lookup_reverse(cql_transform_t ct, + const char *category, + Z_AttributeList *attributes) +{ + struct cql_prop_entry *e; + size_t clen = strlen(category); + for (e = ct->entry; e; e = e->next) + { + if (!strncmp(e->pattern, category, clen)) + { + /* category matches.. See if attributes in pattern value + are all listed in actual attributes */ + int i; + for (i = 0; i < e->attr_list.num_attributes; i++) + { + /* entry attribute */ + Z_AttributeElement *e_ae = e->attr_list.attributes[i]; + int j; + for (j = 0; j < attributes->num_attributes; j++) + { + /* actual attribute */ + Z_AttributeElement *a_ae = attributes->attributes[j]; + int r = compare_attr(e_ae, a_ae); + if (r == 0) + break; + } + if (j == attributes->num_attributes) + break; /* i was not found at all.. try next pattern */ + + } + if (i == e->attr_list.num_attributes) + return e->pattern + clen; + } + } + return 0; +} + static const char *cql_lookup_property(cql_transform_t ct, const char *pat1, const char *pat2, const char *pat3) @@ -139,16 +363,16 @@ static const char *cql_lookup_property(cql_transform_t ct, struct cql_prop_entry *e; if (pat1 && pat2 && pat3) - sprintf (pattern, "%.39s.%.39s.%.39s", pat1, pat2, pat3); + sprintf(pattern, "%.39s.%.39s.%.39s", pat1, pat2, pat3); else if (pat1 && pat2) - sprintf (pattern, "%.39s.%.39s", pat1, pat2); + sprintf(pattern, "%.39s.%.39s", pat1, pat2); else if (pat1 && pat3) - sprintf (pattern, "%.39s.%.39s", pat1, pat3); + sprintf(pattern, "%.39s.%.39s", pat1, pat3); else if (pat1) - sprintf (pattern, "%.39s", pat1); + sprintf(pattern, "%.39s", pat1); else return 0; - + for (e = ct->entry; e; e = e->next) { if (!cql_strcmp(e->pattern, pattern)) @@ -157,7 +381,7 @@ static const char *cql_lookup_property(cql_transform_t ct, return 0; } -int cql_pr_attr_uri(cql_transform_t ct, const char *category, +int cql_pr_attr_uri(cql_transform_t ct, WRBUF addinfo, const char *category, const char *uri, const char *val, const char *default_val, void (*pr)(const char *buf, void *client_data), void *client_data, @@ -166,11 +390,11 @@ int cql_pr_attr_uri(cql_transform_t ct, const char *category, const char *res = 0; const char *eval = val ? val : default_val; const char *prefix = 0; - + if (uri) { struct cql_prop_entry *e; - + for (e = ct->entry; e; e = e->next) if (!memcmp(e->pattern, "set.", 4) && e->value && !strcmp(e->value, uri)) @@ -185,6 +409,18 @@ int cql_pr_attr_uri(cql_transform_t ct, const char *category, { if (!res) res = cql_lookup_property(ct, category, prefix, eval); + /* we have some aliases for some relations unfortunately.. */ + if (!res && !prefix && !strcmp(category, "relation")) + { + if (!strcmp(val, "==")) + res = cql_lookup_property(ct, category, prefix, "exact"); + if (!strcmp(val, "=")) + res = cql_lookup_property(ct, category, prefix, "eq"); + if (!strcmp(val, "<=")) + res = cql_lookup_property(ct, category, prefix, "le"); + if (!strcmp(val, ">=")) + res = cql_lookup_property(ct, category, prefix, "ge"); + } if (!res) res = cql_lookup_property(ct, category, prefix, "*"); } @@ -198,9 +434,9 @@ int cql_pr_attr_uri(cql_transform_t ct, const char *category, int i; while (*cp1 && *cp1 != ' ') cp1++; - if (cp1 - cp0 >= sizeof(buf)) + if (cp1 - cp0 >= (ptrdiff_t) sizeof(buf)) break; - memcpy (buf, cp0, cp1 - cp0); + memcpy(buf, cp0, cp1 - cp0); buf[cp1-cp0] = 0; (*pr)("@attr ", client_data); @@ -221,34 +457,30 @@ int cql_pr_attr_uri(cql_transform_t ct, const char *category, while (*cp0 == ' ') cp0++; } - return 1; + return 0; } /* error ... */ - if (errcode && !ct->error) - { - ct->error = errcode; - if (val) - ct->addinfo = xstrdup(val); - else - ct->addinfo = 0; - } - return 0; + if (errcode == 0) + return 1; /* signal error, but do not set addinfo */ + if (val) + wrbuf_puts(addinfo, val); + return errcode; } -int cql_pr_attr(cql_transform_t ct, const char *category, +int cql_pr_attr(cql_transform_t ct, WRBUF addinfo, const char *category, const char *val, const char *default_val, void (*pr)(const char *buf, void *client_data), void *client_data, int errcode) { - return cql_pr_attr_uri(ct, category, 0 /* uri */, + return cql_pr_attr_uri(ct, addinfo, category, 0 /* uri */, val, default_val, pr, client_data, errcode); } -static void cql_pr_int (int val, - void (*pr)(const char *buf, void *client_data), - void *client_data) +static void cql_pr_int(int val, + void (*pr)(const char *buf, void *client_data), + void *client_data) { char buf[21]; /* enough characters to 2^64 */ sprintf(buf, "%d", val); @@ -258,69 +490,71 @@ static void cql_pr_int (int val, static int cql_pr_prox(cql_transform_t ct, struct cql_node *mods, + WRBUF addinfo, void (*pr)(const char *buf, void *client_data), void *client_data) { int exclusion = 0; - int distance; /* to be filled in later depending on unit */ - int distance_defined = 0; + int distance = -1; int ordered = 0; int proxrel = 2; /* less than or equal */ int unit = 2; /* word */ - while (mods != 0) { - char *name = mods->u.st.index; - char *term = mods->u.st.term; - char *relation = mods->u.st.relation; + while (mods) + { + const char *name = mods->u.st.index; + const char *term = mods->u.st.term; + const char *relation = mods->u.st.relation; if (!strcmp(name, "distance")) { distance = strtol(term, (char**) 0, 0); - distance_defined = 1; - if (!strcmp(relation, "=")) { + if (!strcmp(relation, "=")) proxrel = 3; - } else if (!strcmp(relation, ">")) { + else if (!strcmp(relation, ">")) proxrel = 5; - } else if (!strcmp(relation, "<")) { + else if (!strcmp(relation, "<")) proxrel = 1; - } else if (!strcmp(relation, ">=")) { + else if (!strcmp(relation, ">=")) proxrel = 4; - } else if (!strcmp(relation, "<=")) { + else if (!strcmp(relation, "<=")) proxrel = 2; - } else if (!strcmp(relation, "<>")) { + else if (!strcmp(relation, "<>")) proxrel = 6; - } else { - ct->error = 40; /* Unsupported proximity relation */ - ct->addinfo = xstrdup(relation); - return 0; + else + { + wrbuf_puts(addinfo, relation); + return YAZ_SRW_UNSUPP_PROX_RELATION; } - } else if (!strcmp(name, "ordered")) { + } + else if (!strcmp(name, "ordered")) ordered = 1; - } else if (!strcmp(name, "unordered")) { + else if (!strcmp(name, "unordered")) ordered = 0; - } else if (!strcmp(name, "unit")) { - if (!strcmp(term, "word")) { + else if (!strcmp(name, "unit")) + { + if (!strcmp(term, "word")) unit = 2; - } else if (!strcmp(term, "sentence")) { + else if (!strcmp(term, "sentence")) unit = 3; - } else if (!strcmp(term, "paragraph")) { + else if (!strcmp(term, "paragraph")) unit = 4; - } else if (!strcmp(term, "element")) { + else if (!strcmp(term, "element")) unit = 8; - } else { - ct->error = 42; /* Unsupported proximity unit */ - ct->addinfo = xstrdup(term); - return 0; + else + { + wrbuf_puts(addinfo, term); + return YAZ_SRW_UNSUPP_PROX_UNIT; } - } else { - ct->error = 46; /* Unsupported boolean modifier */ - ct->addinfo = xstrdup(name); - return 0; } - + else + { + wrbuf_puts(addinfo, name); + return YAZ_SRW_UNSUPP_BOOLEAN_MODIFIER; + } mods = mods->u.st.modifiers; } - if (!distance_defined) + if (distance == -1) distance = (unit == 2) ? 1 : 0; cql_pr_int(exclusion, pr, client_data); @@ -330,28 +564,9 @@ static int cql_pr_prox(cql_transform_t ct, struct cql_node *mods, (*pr)("k ", client_data); cql_pr_int(unit, pr, client_data); - return 1; -} - -/* Returns location of first wildcard character in the `length' - * characters starting at `term', or a null pointer of there are - * none -- like memchr(). - */ -static const char *wcchar(int start, const char *term, int length) -{ - while (length > 0) - { - if (start || term[-1] != '\\') - if (strchr("*?", *term)) - return term; - term++; - length--; - start = 0; - } return 0; } - /* ### checks for CQL relation-name rather than Type-1 attribute */ static int has_modifier(struct cql_node *cn, const char *name) { struct cql_node *mod; @@ -363,159 +578,246 @@ static int has_modifier(struct cql_node *cn, const char *name) { return 0; } - -void emit_term(cql_transform_t ct, - struct cql_node *cn, - const char *term, int length, - void (*pr)(const char *buf, void *client_data), - void *client_data) +static int emit_term(cql_transform_t ct, + struct cql_node *cn, WRBUF addinfo, + const char *term, int length, + void (*pr)(const char *buf, void *client_data), + void *client_data) { - int i; + int i, r; const char *ns = cn->u.st.index_uri; - int process_term = !has_modifier(cn, "regexp"); - char *z3958_mem = 0; - + int z3958_mode = 0; + int process_term = 1; + + if (has_modifier(cn, "regexp")) + process_term = 0; + else if (has_modifier(cn, "unmasked")) + process_term = 0; + else if (cql_lookup_property(ct, "truncation", 0, "cql")) + { + process_term = 0; + r = cql_pr_attr(ct, addinfo, "truncation", "cql", 0, + pr, client_data, YAZ_SRW_MASKING_CHAR_UNSUPP); + if (r) + return r; + } assert(cn->which == CQL_NODE_ST); - if (process_term && length > 0) - { - if (length > 1 && term[0] == '^' && term[length-1] == '^') + if (process_term) + { /* convert term via truncation.things */ + unsigned anchor = 0; + unsigned trunc = 0; + for (i = 0; i < length; i++) + { + if (term[i] == '\\' && i < length - 1) + i++; + else + { + switch (term[i]) + { + case '^': + if (i == 0) + anchor |= 1; + else if (i == length - 1) + anchor |= 2; + break; + case '*': + if (i == 0) + trunc |= 1; + else if (i == length - 1) + trunc |= 2; + else + z3958_mode = 1; + break; + case '?': + z3958_mode = 1; + break; + } + } + } + if (anchor == 3) { - cql_pr_attr(ct, "position", "firstAndLast", 0, - pr, client_data, 32); + r = cql_pr_attr(ct, addinfo, "position", "firstAndLast", 0, + pr, client_data, + YAZ_SRW_ANCHORING_CHAR_IN_UNSUPP_POSITION); + if (r) + return r; term++; length -= 2; } - else if (term[0] == '^') + else if (anchor == 1) { - cql_pr_attr(ct, "position", "first", 0, - pr, client_data, 32); + r = cql_pr_attr(ct, addinfo, "position", "first", 0, + pr, client_data, + YAZ_SRW_ANCHORING_CHAR_IN_UNSUPP_POSITION); + if (r) + return r; term++; length--; } - else if (term[length-1] == '^') + else if (anchor == 2) { - cql_pr_attr(ct, "position", "last", 0, - pr, client_data, 32); + r = cql_pr_attr(ct, addinfo, "position", "last", 0, + pr, client_data, + YAZ_SRW_ANCHORING_CHAR_IN_UNSUPP_POSITION); + if (r) + return r; length--; } else { - cql_pr_attr(ct, "position", "any", 0, - pr, client_data, 32); - } - } - - if (process_term && length > 0) - { - const char *first_wc = wcchar(1, term, length); - const char *second_wc = first_wc ? - wcchar(0, first_wc+1, length-(first_wc-term)-1) : 0; - - /* Check for well-known globbing patterns that represent - * simple truncation attributes as expected by, for example, - * Bath-compliant server. If we find such a pattern but - * there's no mapping for it, that's fine: we just use a - * general pattern-matching attribute. - */ - if (first_wc == term && second_wc == term + length-1 - && *first_wc == '*' && *second_wc == '*' - && cql_pr_attr(ct, "truncation", "both", 0, pr, client_data, 0)) - { - term++; - length -= 2; + r = cql_pr_attr(ct, addinfo, "position", "any", 0, + pr, client_data, + YAZ_SRW_ANCHORING_CHAR_IN_UNSUPP_POSITION); + if (r) + return r; } - else if (first_wc == term && second_wc == 0 && *first_wc == '*' - && cql_pr_attr(ct, "truncation", "left", 0, - pr, client_data, 0)) + if (z3958_mode == 0) { - term++; - length--; - } - else if (first_wc == term + length-1 && second_wc == 0 - && *first_wc == '*' - && cql_pr_attr(ct, "truncation", "right", 0, - pr, client_data, 0)) - { - length--; - } - else if (first_wc) - { - /* We have one or more wildcard characters, but not in a - * way that can be dealt with using only the standard - * left-, right- and both-truncation attributes. We need - * to translate the pattern into a Z39.58-type pattern, - * which has been supported in BIB-1 since 1996. If - * there's no configuration element for "truncation.z3958" - * we indicate this as error 28 "Masking character not - * supported". - */ - int i; - cql_pr_attr(ct, "truncation", "z3958", 0, - pr, client_data, 28); - z3958_mem = (char *) xmalloc(length+1); - for (i = 0; i < length; i++) + if (trunc == 3 && !cql_pr_attr(ct, addinfo, "truncation", + "both", 0, pr, client_data, 0)) { - if (i > 0 && term[i-1] == '\\') - z3958_mem[i] = term[i]; - else if (term[i] == '*') - z3958_mem[i] = '?'; - else if (term[i] == '?') - z3958_mem[i] = '#'; - else - z3958_mem[i] = term[i]; + term++; + length -= 2; + } + else if (trunc == 1 && !cql_pr_attr(ct, addinfo, "truncation", + "left", 0, pr, client_data, 0)) + { + term++; + length--; + } + else if (trunc == 2 && !cql_pr_attr(ct, addinfo, "truncation", + "right", 0, pr, client_data, 0)) + { + length--; } - z3958_mem[length] = '\0'; - term = z3958_mem; + else if (trunc) + z3958_mode = 1; + else + cql_pr_attr(ct, addinfo, "truncation", "none", 0, + pr, client_data, 0); } - else { - /* No masking characters. Use "truncation.none" if given. */ - cql_pr_attr(ct, "truncation", "none", 0, - pr, client_data, 0); + if (z3958_mode) + { + r = cql_pr_attr(ct, addinfo, "truncation", "z3958", 0, + pr, client_data, YAZ_SRW_MASKING_CHAR_UNSUPP); + if (r) + return r; } } - if (ns) { - cql_pr_attr_uri(ct, "index", ns, - cn->u.st.index, "serverChoice", - pr, client_data, 16); + if (ns) + { + r = cql_pr_attr_uri(ct, addinfo, "index", ns, + cn->u.st.index, "serverChoice", + pr, client_data, YAZ_SRW_UNSUPP_INDEX); + if (r) + return r; } if (cn->u.st.modifiers) { struct cql_node *mod = cn->u.st.modifiers; for (; mod; mod = mod->u.st.modifiers) { - cql_pr_attr(ct, "relationModifier", mod->u.st.index, 0, - pr, client_data, 20); + r = cql_pr_attr(ct, addinfo, + "relationModifier", mod->u.st.index, 0, + pr, client_data, YAZ_SRW_UNSUPP_RELATION_MODIFIER); + if (r) + return r; } } - (*pr)("\"", client_data); - for (i = 0; iu.st.extra_terms; + int r; + if (ne) + { + (*pr)("@", client_data); + (*pr)(op, client_data); + (*pr)(" ", client_data); + } + r = emit_term(ct, cn, addinfo, cn->u.st.term, strlen(cn->u.st.term), + pr, client_data); + for (; !r && ne; ne = ne->u.st.extra_terms) + { + if (ne->u.st.extra_terms) + { + (*pr)("@", client_data); + (*pr)(op, client_data); + (*pr)(" ", client_data); + } + r = emit_term(ct, cn, addinfo, ne->u.st.term, strlen(ne->u.st.term), + pr, client_data); + } + return r; +} + +static int emit_wordlist(cql_transform_t ct, struct cql_node *cn, + WRBUF addinfo, + void (*pr)(const char *buf, void *client_data), + void *client_data, + const char *op) { + int r = 0; const char *cp0 = cn->u.st.term; const char *cp1; const char *last_term = 0; int last_length = 0; - while(cp0) + while (!r && cp0) { while (*cp0 == ' ') cp0++; @@ -525,7 +827,8 @@ void emit_wordlist(cql_transform_t ct, (*pr)("@", client_data); (*pr)(op, client_data); (*pr)(" ", client_data); - emit_term(ct, cn, last_term, last_length, pr, client_data); + r = emit_term(ct, cn, addinfo, last_term, last_length, + pr, client_data); } last_term = cp0; if (cp1) @@ -534,20 +837,22 @@ void emit_wordlist(cql_transform_t ct, last_length = strlen(cp0); cp0 = cp1; } - if (last_term) - emit_term(ct, cn, last_term, last_length, pr, client_data); + if (!r && last_term) + r = emit_term(ct, cn, addinfo, last_term, last_length, pr, client_data); + return r; } -void cql_transform_r(cql_transform_t ct, - struct cql_node *cn, +static int emit_node(cql_transform_t ct, struct cql_node *cn, + WRBUF addinfo, void (*pr)(const char *buf, void *client_data), void *client_data) { const char *ns; + int r = 0; struct cql_node *mods; if (!cn) - return; + return 0; switch (cn->which) { case CQL_NODE_ST: @@ -560,83 +865,73 @@ void cql_transform_r(cql_transform_t ct, (*pr)("@set \"", client_data); (*pr)(cn->u.st.term, client_data); (*pr)("\" ", client_data); - return ; + return 0; } } else { - if (!ct->error) - { - ct->error = 15; - ct->addinfo = 0; - } + return YAZ_SRW_UNSUPP_CONTEXT_SET; } - cql_pr_attr(ct, "always", 0, 0, pr, client_data, 0); - if (cn->u.st.relation && !cql_strcmp(cn->u.st.relation, "=")) - cql_pr_attr(ct, "relation", "eq", "scr", - pr, client_data, 19); - else if (cn->u.st.relation && !cql_strcmp(cn->u.st.relation, "<=")) - cql_pr_attr(ct, "relation", "le", "scr", - pr, client_data, 19); - else if (cn->u.st.relation && !cql_strcmp(cn->u.st.relation, ">=")) - cql_pr_attr(ct, "relation", "ge", "scr", - pr, client_data, 19); - else - cql_pr_attr(ct, "relation", cn->u.st.relation, "eq", - pr, client_data, 19); - cql_pr_attr(ct, "structure", cn->u.st.relation, 0, - pr, client_data, 24); + cql_pr_attr(ct, addinfo, "always", 0, 0, pr, client_data, 0); + r = cql_pr_attr(ct, addinfo, "relation", cn->u.st.relation, 0, + pr, client_data, YAZ_SRW_UNSUPP_RELATION); + if (r) + return r; + r = cql_pr_attr(ct, addinfo, "structure", cn->u.st.relation, 0, + pr, client_data, + YAZ_SRW_UNSUPP_COMBI_OF_RELATION_AND_TERM); + if (r) + return r; if (cn->u.st.relation && !cql_strcmp(cn->u.st.relation, "all")) - { - emit_wordlist(ct, cn, pr, client_data, "and"); - } + r = emit_wordlist(ct, cn, addinfo, pr, client_data, "and"); else if (cn->u.st.relation && !cql_strcmp(cn->u.st.relation, "any")) - { - emit_wordlist(ct, cn, pr, client_data, "or"); - } + r = emit_wordlist(ct, cn, addinfo, pr, client_data, "or"); else - { - emit_term(ct, cn, cn->u.st.term, strlen(cn->u.st.term), - pr, client_data); - } + r = emit_terms(ct, cn, addinfo, pr, client_data, "and"); break; case CQL_NODE_BOOL: (*pr)("@", client_data); (*pr)(cn->u.boolean.value, client_data); (*pr)(" ", client_data); mods = cn->u.boolean.modifiers; - if (!strcmp(cn->u.boolean.value, "prox")) { - if (!cql_pr_prox(ct, mods, pr, client_data)) - return; - } else if (mods) { + if (!strcmp(cn->u.boolean.value, "prox")) + { + r = cql_pr_prox(ct, mods, addinfo, pr, client_data); + if (r) + return r; + } + else if (mods) + { /* Boolean modifiers other than on proximity not supported */ - ct->error = 46; /* SRW diag: "Unsupported boolean modifier" */ - ct->addinfo = xstrdup(mods->u.st.index); - return; + wrbuf_puts(addinfo, mods->u.st.index); + return YAZ_SRW_UNSUPP_BOOLEAN_MODIFIER; } - cql_transform_r(ct, cn->u.boolean.left, pr, client_data); - cql_transform_r(ct, cn->u.boolean.right, pr, client_data); + r = emit_node(ct, cn->u.boolean.left, addinfo, pr, client_data); + if (r) + return r; + r = emit_node(ct, cn->u.boolean.right, addinfo, pr, client_data); + if (r) + return r; + break; + case CQL_NODE_SORT: + r = emit_node(ct, cn->u.sort.search, addinfo, pr, client_data); break; - default: fprintf(stderr, "Fatal: impossible CQL node-type %d\n", cn->which); abort(); } + return r; } -int cql_transform(cql_transform_t ct, - struct cql_node *cn, - void (*pr)(const char *buf, void *client_data), - void *client_data) +int cql_transform_r(cql_transform_t ct, struct cql_node *cn, + WRBUF addinfo, + void (*pr)(const char *buf, void *client_data), + void *client_data) { struct cql_prop_entry *e; NMEM nmem = nmem_create(); - - ct->error = 0; - if (ct->addinfo) - xfree (ct->addinfo); - ct->addinfo = 0; + int r; for (e = ct->entry; e ; e = e->next) { @@ -645,11 +940,21 @@ int cql_transform(cql_transform_t ct, else if (!cql_strcmp(e->pattern, "set")) cql_apply_prefix(nmem, cn, 0, e->value); } - cql_transform_r (ct, cn, pr, client_data); + r = emit_node(ct, cn, addinfo, pr, client_data); nmem_destroy(nmem); - return ct->error; + return r; } +int cql_transform(cql_transform_t ct, struct cql_node *cn, + void (*pr)(const char *buf, void *client_data), + void *client_data) +{ + WRBUF addinfo = wrbuf_alloc(); + int r = cql_transform_r(ct, cn, addinfo, pr, client_data); + cql_transform_set_error(ct, r, wrbuf_cstr(addinfo)); + wrbuf_destroy(addinfo); + return r; +} int cql_transform_FILE(cql_transform_t ct, struct cql_node *cn, FILE *f) { @@ -671,9 +976,8 @@ int cql_transform_buf(cql_transform_t ct, struct cql_node *cn, SRW diagnostic is deprecated, but it's so perfect for our purposes that it would be stupid not to use it. */ char numbuf[30]; - ct->error = YAZ_SRW_TOO_MANY_CHARS_IN_QUERY; sprintf(numbuf, "%ld", (long) info.max); - ct->addinfo = xstrdup(numbuf); + cql_transform_set_error(ct, YAZ_SRW_TOO_MANY_CHARS_IN_QUERY, numbuf); return -1; } if (info.off >= 0) @@ -683,12 +987,22 @@ int cql_transform_buf(cql_transform_t ct, struct cql_node *cn, int cql_transform_error(cql_transform_t ct, const char **addinfo) { - *addinfo = ct->addinfo; + *addinfo = wrbuf_len(ct->addinfo) ? wrbuf_cstr(ct->addinfo) : 0; return ct->error; } + +void cql_transform_set_error(cql_transform_t ct, int error, const char *addinfo) +{ + wrbuf_rewind(ct->addinfo); + if (addinfo) + wrbuf_puts(ct->addinfo, addinfo); + ct->error = error; +} + /* * Local variables: * c-basic-offset: 4 + * c-file-style: "Stroustrup" * indent-tabs-mode: nil * End: * vim: shiftwidth=4 tabstop=8 expandtab