-/* $Id: cqltransform.c,v 1.1 2003-10-27 12:21:30 adam Exp $
- Copyright (C) 2002-2003
- 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) 1995-2008 Index Data
+ * See the file LICENSE for details.
+ */
+
+/**
+ * \file cqltransform.c
+ * \brief Implements CQL transform (CQL to RPN conversion).
+ *
+ * Evaluation order of rules:
+ *
+ * always
+ * relation
+ * structure
+ * position
+ * truncation
+ * index
+ * relationModifier
+ */
+
+#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <yaz/cql.h>
+#include <yaz/xmalloc.h>
+#include <yaz/diagsrw.h>
+#include <yaz/tokenizer.h>
+#include <yaz/wrbuf.h>
struct cql_prop_entry {
char *pattern;
struct cql_transform_t_ {
struct cql_prop_entry *entry;
+ yaz_tok_cfg_t tok_cfg;
int error;
char *addinfo;
+ WRBUF w;
};
cql_transform_t cql_transform_open_FILE(FILE *f)
{
char line[1024];
- cql_transform_t ct = (cql_transform_t) malloc (sizeof(*ct));
+ cql_transform_t ct = (cql_transform_t) xmalloc(sizeof(*ct));
struct cql_prop_entry **pp = &ct->entry;
+ ct->tok_cfg = yaz_tok_cfg_create();
+ ct->w = wrbuf_alloc();
+ yaz_tok_cfg_single_tokens(ct->tok_cfg, "=");
ct->error = 0;
ct->addinfo = 0;
+
while (fgets(line, sizeof(line)-1, f))
{
- const char *cp_value_start;
- const char *cp_value_end;
- const char *cp_pattern_end;
- const char *cp = line;
- while (*cp && !strchr(" \t=\r\n#", *cp))
- cp++;
- cp_pattern_end = cp;
- if (cp == line)
- continue;
- while (*cp && strchr(" \t\r\n", *cp))
- cp++;
- if (*cp != '=')
- continue;
- cp++;
- while (*cp && strchr(" \t\r\n", *cp))
- cp++;
- cp_value_start = cp;
- if (!(cp_value_end = strchr(cp, '#')))
- 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 *) malloc (sizeof(**pp));
- (*pp)->pattern = (char *) malloc (cp_pattern_end - line + 1);
- memcpy ((*pp)->pattern, line, cp_pattern_end - line);
- (*pp)->pattern[cp_pattern_end-line] = 0;
-
- (*pp)->value = (char *) malloc (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_t tp = yaz_tok_parse_buf(ct->tok_cfg, line);
+ int t;
+ wrbuf_rewind(ct->w);
+ 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;
+ }
+ t = yaz_tok_move(tp);
+
+ while (t == YAZ_TOK_STRING)
+ {
+ /* attset type=value OR type=value */
+ wrbuf_puts(ct->w, yaz_tok_parse_string(tp));
+ t = yaz_tok_move(tp);
+ if (t == YAZ_TOK_EOF)
+ break;
+ if (t == YAZ_TOK_STRING)
+ {
+ wrbuf_puts(ct->w, " ");
+ wrbuf_puts(ct->w, yaz_tok_parse_string(tp));
+ t = yaz_tok_move(tp);
+ }
+ if (t != '=')
+ {
+ yaz_tok_parse_destroy(tp);
+ cql_transform_close(ct);
+ return 0;
+ }
+ t = yaz_tok_move(tp);
+ if (t != YAZ_TOK_STRING) /* value */
+ {
+ yaz_tok_parse_destroy(tp);
+ cql_transform_close(ct);
+ return 0;
+ }
+ wrbuf_puts(ct->w, "=");
+ wrbuf_puts(ct->w, yaz_tok_parse_string(tp));
+ t = yaz_tok_move(tp);
+ wrbuf_puts(ct->w, " ");
+ }
+ *pp = (struct cql_prop_entry *) xmalloc(sizeof(**pp));
+ (*pp)->pattern = pattern;
+ (*pp)->value = xstrdup(wrbuf_cstr(ct->w));
+ pp = &(*pp)->next;
+ }
+ else if (t != YAZ_TOK_EOF)
+ {
+ yaz_tok_parse_destroy(tp);
+ cql_transform_close(ct);
+ return 0;
+ }
+ yaz_tok_parse_destroy(tp);
}
*pp = 0;
return ct;
while (pe)
{
struct cql_prop_entry *pe_next = pe->next;
- free (pe->pattern);
- free (pe->value);
- free (pe);
+ xfree(pe->pattern);
+ xfree(pe->value);
+ xfree(pe);
pe = pe_next;
}
- if (ct->addinfo)
- free (ct->addinfo);
- free (ct);
+ xfree(ct->addinfo);
+ yaz_tok_cfg_destroy(ct->tok_cfg);
+ wrbuf_destroy(ct->w);
+ xfree(ct);
}
cql_transform_t cql_transform_open_fname(const char *fname)
}
static const char *cql_lookup_property(cql_transform_t ct,
- const char *pat1, const char *pat2)
+ const char *pat1, const char *pat2,
+ const char *pat3)
{
- char pattern[80];
+ char pattern[120];
struct cql_prop_entry *e;
- if (pat2)
- sprintf (pattern, "%.39s%.39s", pat1, pat2);
+ if (pat1 && pat2 && pat3)
+ sprintf(pattern, "%.39s.%.39s.%.39s", pat1, pat2, pat3);
+ else if (pat1 && pat2)
+ sprintf(pattern, "%.39s.%.39s", pat1, pat2);
+ else if (pat1 && pat3)
+ sprintf(pattern, "%.39s.%.39s", pat1, pat3);
+ else if (pat1)
+ sprintf(pattern, "%.39s", pat1);
else
- sprintf (pattern, "%.39s", pat1);
+ return 0;
+
for (e = ct->entry; e; e = e->next)
{
- if (!strcmp(e->pattern, pattern))
+ if (!cql_strcmp(e->pattern, pattern))
return e->value;
}
return 0;
}
-static const char *cql_lookup_value(cql_transform_t ct,
- const char *prefix,
- const char *value)
+int cql_pr_attr_uri(cql_transform_t ct, const char *category,
+ const char *uri, const char *val, const char *default_val,
+ void (*pr)(const char *buf, void *client_data),
+ void *client_data,
+ int errcode)
{
- struct cql_prop_entry *e;
- int len = strlen(prefix);
-
- for (e = ct->entry; e; e = e->next)
+ const char *res = 0;
+ const char *eval = val ? val : default_val;
+ const char *prefix = 0;
+
+ if (uri)
{
- if (!memcmp(e->pattern, prefix, len) && !strcmp(e->value, value))
- return e->pattern + len;
+ 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))
+ {
+ prefix = e->pattern+4;
+ break;
+ }
+ /* must have a prefix now - if not it's an error */
}
- return 0;
-}
-
-int cql_pr_attr(cql_transform_t ct, const char *category,
- const char *val,
- const char *default_val,
- void (*pr)(const char *buf, void *client_data),
- void *client_data,
- int errcode)
-{
- const char *res;
- res = cql_lookup_property(ct, category, val ? val : default_val);
- if (!res)
- res = cql_lookup_property(ct, category, "*");
+ if (!uri || prefix)
+ {
+ 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, "*");
+ }
if (res)
{
char buf[64];
const char *cp0 = res, *cp1;
while ((cp1 = strchr(cp0, '=')))
{
+ int i;
while (*cp1 && *cp1 != ' ')
cp1++;
if (cp1 - cp0 >= sizeof(buf))
break;
- memcpy (buf, cp0, cp1 - cp0);
+ memcpy(buf, cp0, cp1 - cp0);
buf[cp1-cp0] = 0;
(*pr)("@attr ", client_data);
- (*pr)(buf, client_data);
+
+ for (i = 0; buf[i]; i++)
+ {
+ if (buf[i] == '*')
+ (*pr)(eval, client_data);
+ else
+ {
+ char tmp[2];
+ tmp[0] = buf[i];
+ tmp[1] = '\0';
+ (*pr)(tmp, client_data);
+ }
+ }
(*pr)(" ", client_data);
cp0 = cp1;
while (*cp0 == ' ')
if (errcode && !ct->error)
{
ct->error = errcode;
- ct->addinfo = strdup(val);
+ if (val)
+ ct->addinfo = xstrdup(val);
+ else
+ ct->addinfo = 0;
+ }
+ return 0;
+}
+
+int cql_pr_attr(cql_transform_t ct, 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 */,
+ 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)
+{
+ char buf[21]; /* enough characters to 2^64 */
+ sprintf(buf, "%d", val);
+ (*pr)(buf, client_data);
+ (*pr)(" ", client_data);
+}
+
+
+static int cql_pr_prox(cql_transform_t ct, struct cql_node *mods,
+ 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 ordered = 0;
+ int proxrel = 2; /* less than or equal */
+ int unit = 2; /* word */
+
+ 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, "="))
+ proxrel = 3;
+ else if (!strcmp(relation, ">"))
+ proxrel = 5;
+ else if (!strcmp(relation, "<"))
+ proxrel = 1;
+ else if (!strcmp(relation, ">="))
+ proxrel = 4;
+ else if (!strcmp(relation, "<="))
+ proxrel = 2;
+ else if (!strcmp(relation, "<>"))
+ proxrel = 6;
+ else
+ {
+ ct->error = YAZ_SRW_UNSUPP_PROX_RELATION;
+ ct->addinfo = xstrdup(relation);
+ return 0;
+ }
+ }
+ else if (!strcmp(name, "ordered"))
+ ordered = 1;
+ else if (!strcmp(name, "unordered"))
+ ordered = 0;
+ else if (!strcmp(name, "unit"))
+ {
+ if (!strcmp(term, "word"))
+ unit = 2;
+ else if (!strcmp(term, "sentence"))
+ unit = 3;
+ else if (!strcmp(term, "paragraph"))
+ unit = 4;
+ else if (!strcmp(term, "element"))
+ unit = 8;
+ else
+ {
+ ct->error = YAZ_SRW_UNSUPP_PROX_UNIT;
+ ct->addinfo = xstrdup(term);
+ return 0;
+ }
+ }
+ else
+ {
+ ct->error = YAZ_SRW_UNSUPP_BOOLEAN_MODIFIER;
+ ct->addinfo = xstrdup(name);
+ return 0;
+ }
+ mods = mods->u.st.modifiers;
}
+
+ if (!distance_defined)
+ distance = (unit == 2) ? 1 : 0;
+
+ cql_pr_int(exclusion, pr, client_data);
+ cql_pr_int(distance, pr, client_data);
+ cql_pr_int(ordered, pr, client_data);
+ cql_pr_int(proxrel, pr, client_data);
+ (*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;
+ for (mod = cn->u.st.modifiers; mod != 0; mod = mod->u.st.modifiers) {
+ if (!strcmp(mod->u.st.index, name))
+ return 1;
+ }
+
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)
{
int i;
- if (length > 0)
+ const char *ns = cn->u.st.index_uri;
+ int process_term = !has_modifier(cn, "regexp");
+ char *z3958_mem = 0;
+
+ assert(cn->which == CQL_NODE_ST);
+
+ if (process_term && length > 0)
{
if (length > 1 && term[0] == '^' && term[length-1] == '^')
{
- cql_pr_attr(ct, "position.", "firstAndLast", 0,
- pr, client_data, 32);
+ cql_pr_attr(ct, "position", "firstAndLast", 0,
+ pr, client_data, YAZ_SRW_ANCHORING_CHAR_IN_UNSUPP_POSITION);
term++;
length -= 2;
}
else if (term[0] == '^')
{
- cql_pr_attr(ct, "position.", "first", 0,
- pr, client_data, 32);
+ cql_pr_attr(ct, "position", "first", 0,
+ pr, client_data, YAZ_SRW_ANCHORING_CHAR_IN_UNSUPP_POSITION);
term++;
+ length--;
}
else if (term[length-1] == '^')
{
- cql_pr_attr(ct, "position.", "last", 0,
- pr, client_data, 32);
+ cql_pr_attr(ct, "position", "last", 0,
+ pr, client_data, YAZ_SRW_ANCHORING_CHAR_IN_UNSUPP_POSITION);
length--;
}
else
{
- cql_pr_attr(ct, "position.", "any", 0,
- pr, client_data, 32);
+ cql_pr_attr(ct, "position", "any", 0,
+ pr, client_data, YAZ_SRW_ANCHORING_CHAR_IN_UNSUPP_POSITION);
+ }
+ }
+
+ 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;
+ }
+ else if (first_wc == term && second_wc == 0 && *first_wc == '*'
+ && cql_pr_attr(ct, "truncation", "left", 0,
+ pr, client_data, 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, YAZ_SRW_MASKING_CHAR_UNSUPP);
+ z3958_mem = (char *) xmalloc(length+1);
+ for (i = 0; i < length; i++)
+ {
+ 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];
+ }
+ z3958_mem[length] = '\0';
+ term = z3958_mem;
+ }
+ else {
+ /* No masking characters. Use "truncation.none" if given. */
+ cql_pr_attr(ct, "truncation", "none", 0,
+ pr, client_data, 0);
+ }
+ }
+ if (ns) {
+ cql_pr_attr_uri(ct, "index", ns,
+ cn->u.st.index, "serverChoice",
+ pr, client_data, YAZ_SRW_UNSUPP_INDEX);
+ }
+ 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, YAZ_SRW_UNSUPP_RELATION_MODIFIER);
}
}
+
(*pr)("\"", client_data);
for (i = 0; i<length; i++)
{
+ /* pr(int) each character */
+ /* we do not need to deal with \-sequences because the
+ CQL and PQF terms have same \-format, bug #1988 */
char buf[2];
+
buf[0] = term[i];
- buf[1] = 0;
+ buf[1] = '\0';
(*pr)(buf, client_data);
}
(*pr)("\" ", client_data);
+ xfree(z3958_mem);
+}
+
+void emit_terms(cql_transform_t ct,
+ struct cql_node *cn,
+ void (*pr)(const char *buf, void *client_data),
+ void *client_data,
+ const char *op)
+{
+ struct cql_node *ne = cn->u.st.extra_terms;
+ if (ne)
+ {
+ (*pr)("@", client_data);
+ (*pr)(op, client_data);
+ (*pr)(" ", client_data);
+ }
+ emit_term(ct, cn, cn->u.st.term, strlen(cn->u.st.term),
+ pr, client_data);
+ for (; ne; ne = ne->u.st.extra_terms)
+ {
+ if (ne->u.st.extra_terms)
+ {
+ (*pr)("@", client_data);
+ (*pr)(op, client_data);
+ (*pr)(" ", client_data);
+ }
+ emit_term(ct, cn, ne->u.st.term, strlen(ne->u.st.term),
+ pr, client_data);
+ }
}
void emit_wordlist(cql_transform_t ct,
(*pr)("@", client_data);
(*pr)(op, client_data);
(*pr)(" ", client_data);
- emit_term(ct, last_term, last_length, pr, client_data);
+ emit_term(ct, cn, last_term, last_length, pr, client_data);
}
last_term = cp0;
if (cp1)
cp0 = cp1;
}
if (last_term)
- emit_term(ct, last_term, last_length, pr, client_data);
-}
-
-
-static const char *cql_get_ns(cql_transform_t ct,
- struct cql_node *cn,
- struct cql_node **prefix_ar, int prefix_level,
- const char **n_prefix,
- const char **n_suffix)
-{
- int i;
- const char *ns = 0;
- char prefix[32];
- const char *cp = cn->u.st.index;
- const char *cp_dot = strchr(cp, '.');
-
- /* strz current prefix (empty if not given) */
- if (cp_dot && cp_dot-cp < sizeof(prefix))
- {
- memcpy (prefix, cp, cp_dot - cp);
- prefix[cp_dot - cp] = 0;
- }
- else
- *prefix = 0;
-
- /* 2. lookup in prefix_ar. and return NS */
- for (i = prefix_level; !ns && --i >= 0; )
- {
- struct cql_node *cn_prefix = prefix_ar[i];
- for (; cn_prefix; cn_prefix = cn_prefix->u.mod.next)
- {
- if (*prefix && cn_prefix->u.mod.name &&
- !strcmp(prefix, cn_prefix->u.mod.name))
- {
- ns = cn_prefix->u.mod.value;
- break;
- }
- else if (!*prefix && !cn_prefix->u.mod.name)
- {
- ns = cn_prefix->u.mod.value;
- break;
- }
- }
- }
- if (!ns)
- {
- if (!ct->error)
- {
- ct->error = 15;
- ct->addinfo = strdup(prefix);
- }
- return 0;
- }
- /* 3. lookup in set.NS for new prefix */
- *n_prefix = cql_lookup_value(ct, "set.", ns);
- if (!*n_prefix)
- {
- if (!ct->error)
- {
- ct->error = 15;
- ct->addinfo = strdup(ns);
- }
- return 0;
- }
- /* 4. lookup qualifier.prefix. */
-
- cp = cn->u.st.index;
- cp_dot = strchr(cp, '.');
-
- *n_suffix = cp_dot ? cp_dot+1 : cp;
- return ns;
+ emit_term(ct, cn, last_term, last_length, pr, client_data);
}
void cql_transform_r(cql_transform_t ct,
struct cql_node *cn,
void (*pr)(const char *buf, void *client_data),
- void *client_data,
- struct cql_node **prefix_ar, int prefix_level)
+ void *client_data)
{
- const char *ns, *n_prefix, *n_suffix;
+ const char *ns;
+ struct cql_node *mods;
if (!cn)
return;
switch (cn->which)
{
case CQL_NODE_ST:
- if (cn->u.st.prefixes && prefix_level < 20)
- prefix_ar[prefix_level++] = cn->u.st.prefixes;
- ns = cql_get_ns(ct, cn, prefix_ar, prefix_level, &n_prefix, &n_suffix);
+ ns = cn->u.st.index_uri;
if (ns)
{
- char n_full[64];
- sprintf (n_full, "%.20s.%.40s", n_prefix, n_suffix);
-
- if (!strcmp(ns, "http://www.loc.gov/zing/cql/srw-indexes/v1.0/")
- && !strcmp(n_suffix, "resultSet"))
+ if (!strcmp(ns, cql_uri())
+ && cn->u.st.index && !cql_strcmp(cn->u.st.index, "resultSet"))
{
(*pr)("@set \"", client_data);
(*pr)(cn->u.st.term, client_data);
(*pr)("\" ", client_data);
return ;
}
- cql_pr_attr(ct, "qualifier.", n_full, "srw.serverChoice",
- pr, client_data, 16);
}
-
- if (cn->u.st.relation && !strcmp(cn->u.st.relation, "="))
- cql_pr_attr(ct, "relation.", "eq", "scr",
- pr, client_data, 19);
- else if (cn->u.st.relation && !strcmp(cn->u.st.relation, "<="))
- cql_pr_attr(ct, "relation.", "le", "scr",
- pr, client_data, 19);
- else if (cn->u.st.relation && !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);
- if (cn->u.st.modifiers)
{
- struct cql_node *mod = cn->u.st.modifiers;
- for (; mod; mod = mod->u.mod.next)
+ if (!ct->error)
{
- cql_pr_attr(ct, "relationModifier.", mod->u.mod.value, 0,
- pr, client_data, 20);
+ ct->error = YAZ_SRW_UNSUPP_CONTEXT_SET;
+ ct->addinfo = 0;
}
}
- cql_pr_attr(ct, "structure.", cn->u.st.relation, 0,
- pr, client_data, 24);
- if (cn->u.st.relation && !strcmp(cn->u.st.relation, "all"))
- {
+ cql_pr_attr(ct, "always", 0, 0, pr, client_data, 0);
+ cql_pr_attr(ct, "relation", cn->u.st.relation, 0, pr, client_data,
+ YAZ_SRW_UNSUPP_RELATION);
+ cql_pr_attr(ct, "structure", cn->u.st.relation, 0,
+ pr, client_data, YAZ_SRW_UNSUPP_COMBI_OF_RELATION_AND_TERM);
+ if (cn->u.st.relation && !cql_strcmp(cn->u.st.relation, "all"))
emit_wordlist(ct, cn, pr, client_data, "and");
- }
- else if (cn->u.st.relation && !strcmp(cn->u.st.relation, "any"))
- {
+ else if (cn->u.st.relation && !cql_strcmp(cn->u.st.relation, "any"))
emit_wordlist(ct, cn, pr, client_data, "or");
- }
else
- {
- emit_term(ct, cn->u.st.term, strlen(cn->u.st.term),
- pr, client_data);
- }
+ emit_terms(ct, cn, pr, client_data, "and");
break;
case CQL_NODE_BOOL:
- if (cn->u.boolean.prefixes && prefix_level < 20)
- prefix_ar[prefix_level++] = cn->u.boolean.prefixes;
(*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)
+ {
+ /* Boolean modifiers other than on proximity not supported */
+ ct->error = YAZ_SRW_UNSUPP_BOOLEAN_MODIFIER;
+ ct->addinfo = xstrdup(mods->u.st.index);
+ return;
+ }
+
+ cql_transform_r(ct, cn->u.boolean.left, pr, client_data);
+ cql_transform_r(ct, cn->u.boolean.right, pr, client_data);
+ break;
- cql_transform_r(ct, cn->u.boolean.left, pr, client_data,
- prefix_ar, prefix_level);
- cql_transform_r(ct, cn->u.boolean.right, pr, client_data,
- prefix_ar, prefix_level);
+ default:
+ fprintf(stderr, "Fatal: impossible CQL node-type %d\n", cn->which);
+ abort();
}
}
-int cql_transform(cql_transform_t ct,
- struct cql_node *cn,
+int cql_transform(cql_transform_t ct, struct cql_node *cn,
void (*pr)(const char *buf, void *client_data),
void *client_data)
{
- struct cql_node *prefix_ar[20], **pp;
struct cql_prop_entry *e;
+ NMEM nmem = nmem_create();
ct->error = 0;
- if (ct->addinfo)
- free (ct->addinfo);
+ xfree(ct->addinfo);
ct->addinfo = 0;
- prefix_ar[0] = 0;
- pp = &prefix_ar[0];
for (e = ct->entry; e ; e = e->next)
{
- if (!memcmp(e->pattern, "set.", 4))
- {
- *pp = cql_node_mk_mod(e->pattern+4, e->value);
- pp = &(*pp)->u.mod.next;
- }
- else if (!strcmp(e->pattern, "set"))
- {
- *pp = cql_node_mk_mod(0, e->value);
- pp = &(*pp)->u.mod.next;
- }
+ if (!cql_strncmp(e->pattern, "set.", 4))
+ cql_apply_prefix(nmem, cn, e->pattern+4, e->value);
+ else if (!cql_strcmp(e->pattern, "set"))
+ cql_apply_prefix(nmem, cn, 0, e->value);
}
- cql_transform_r (ct, cn, pr, client_data, prefix_ar, 1);
- cql_node_destroy(prefix_ar[0]);
+ cql_transform_r(ct, cn, pr, client_data);
+ nmem_destroy(nmem);
return ct->error;
}
return cql_transform(ct, cn, cql_fputs, f);
}
-int cql_transform_buf(cql_transform_t ct, struct cql_node *cn,
- char *out, int max)
+int cql_transform_buf(cql_transform_t ct, struct cql_node *cn, char *out, int max)
{
struct cql_buf_write_info info;
int r;
info.max = max;
info.buf = out;
r = cql_transform(ct, cn, cql_buf_write_handler, &info);
+ if (info.off < 0) {
+ /* Attempt to write past end of buffer. For some reason, this
+ 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);
+ return -1;
+ }
if (info.off >= 0)
info.buf[info.off] = '\0';
return r;
*addinfo = ct->addinfo;
return ct->error;
}
+
+void cql_transform_set_error(cql_transform_t ct, int error, const char *addinfo)
+{
+ xfree(ct->addinfo);
+ ct->addinfo = addinfo ? xstrdup(addinfo) : 0;
+ ct->error = error;
+}
+
+/*
+ * Local variables:
+ * c-basic-offset: 4
+ * indent-tabs-mode: nil
+ * End:
+ * vim: shiftwidth=4 tabstop=8 expandtab
+ */
+