Add support for implementationId and implementationVersion options to
[yaz-moved-to-github.git] / src / cqltransform.c
1 /* $Id: cqltransform.c,v 1.1 2003-10-27 12:21:30 adam Exp $
2    Copyright (C) 2002-2003
3    Index Data Aps
4
5 This file is part of the YAZ toolkit.
6
7 See the file LICENSE.
8 */
9
10 #include <stdlib.h>
11 #include <string.h>
12 #include <yaz/cql.h>
13
14 struct cql_prop_entry {
15     char *pattern;
16     char *value;
17     struct cql_prop_entry *next;
18 };
19
20 struct cql_transform_t_ {
21     struct cql_prop_entry *entry;
22     int error;
23     char *addinfo;
24 };
25
26 cql_transform_t cql_transform_open_FILE(FILE *f)
27 {
28     char line[1024];
29     cql_transform_t ct = (cql_transform_t) malloc (sizeof(*ct));
30     struct cql_prop_entry **pp = &ct->entry;
31
32     ct->error = 0;
33     ct->addinfo = 0;
34     while (fgets(line, sizeof(line)-1, f))
35     {
36         const char *cp_value_start;
37         const char *cp_value_end;
38         const char *cp_pattern_end;
39         const char *cp = line;
40         while (*cp && !strchr(" \t=\r\n#", *cp))
41             cp++;
42         cp_pattern_end = cp;
43         if (cp == line)
44             continue;
45         while (*cp && strchr(" \t\r\n", *cp))
46             cp++;
47         if (*cp != '=')
48             continue;
49         cp++;
50         while (*cp && strchr(" \t\r\n", *cp))
51             cp++;
52         cp_value_start = cp;
53         if (!(cp_value_end = strchr(cp, '#')))
54             cp_value_end = strlen(line) + line;
55
56         if (cp_value_end != cp_value_start &&
57             strchr(" \t\r\n", cp_value_end[-1]))
58             cp_value_end--;
59         *pp = (struct cql_prop_entry *) malloc (sizeof(**pp));
60         (*pp)->pattern = (char *) malloc (cp_pattern_end - line + 1);
61         memcpy ((*pp)->pattern, line, cp_pattern_end - line);
62         (*pp)->pattern[cp_pattern_end-line] = 0;
63
64         (*pp)->value = (char *) malloc (cp_value_end - cp_value_start + 1);
65         if (cp_value_start != cp_value_end)
66             memcpy ((*pp)->value, cp_value_start, cp_value_end-cp_value_start);
67         (*pp)->value[cp_value_end - cp_value_start] = 0;
68         pp = &(*pp)->next;
69     }
70     *pp = 0;
71     return ct;
72 }
73
74 void cql_transform_close(cql_transform_t ct)
75 {
76     struct cql_prop_entry *pe;
77     if (!ct)
78         return;
79     pe = ct->entry;
80     while (pe)
81     {
82         struct cql_prop_entry *pe_next = pe->next;
83         free (pe->pattern);
84         free (pe->value);
85         free (pe);
86         pe = pe_next;
87     }
88     if (ct->addinfo)
89         free (ct->addinfo);
90     free (ct);
91 }
92
93 cql_transform_t cql_transform_open_fname(const char *fname)
94 {
95     cql_transform_t ct;
96     FILE *f = fopen(fname, "r");
97     if (!f)
98         return 0;
99     ct = cql_transform_open_FILE(f);
100     fclose(f);
101     return ct;
102 }
103
104 static const char *cql_lookup_property(cql_transform_t ct,
105                                        const char *pat1, const char *pat2)
106 {
107     char pattern[80];
108     struct cql_prop_entry *e;
109
110     if (pat2)
111         sprintf (pattern, "%.39s%.39s", pat1, pat2);
112     else
113         sprintf (pattern, "%.39s", pat1);
114     for (e = ct->entry; e; e = e->next)
115     {
116         if (!strcmp(e->pattern, pattern))
117             return e->value;
118     }
119     return 0;
120 }
121
122 static const char *cql_lookup_value(cql_transform_t ct,
123                                     const char *prefix,
124                                     const char *value)
125 {
126     struct cql_prop_entry *e;
127     int len = strlen(prefix);
128
129     for (e = ct->entry; e; e = e->next)
130     {
131         if (!memcmp(e->pattern, prefix, len) && !strcmp(e->value, value))
132             return e->pattern + len;
133     }
134     return 0;
135 }
136
137
138 int cql_pr_attr(cql_transform_t ct, const char *category,
139                 const char *val,
140                 const char *default_val,
141                 void (*pr)(const char *buf, void *client_data),
142                 void *client_data,
143                 int errcode)
144 {
145     const char *res;
146     res = cql_lookup_property(ct, category, val ? val : default_val);
147     if (!res)
148         res = cql_lookup_property(ct, category, "*");
149     if (res)
150     {
151         char buf[64];
152
153         const char *cp0 = res, *cp1;
154         while ((cp1 = strchr(cp0, '=')))
155         {
156             while (*cp1 && *cp1 != ' ')
157                 cp1++;
158             if (cp1 - cp0 >= sizeof(buf))
159                 break;
160             memcpy (buf, cp0, cp1 - cp0);
161             buf[cp1-cp0] = 0;
162             (*pr)("@attr ", client_data);
163             (*pr)(buf, client_data);
164             (*pr)(" ", client_data);
165             cp0 = cp1;
166             while (*cp0 == ' ')
167                 cp0++;
168         }
169         return 1;
170     }
171     /* error ... */
172     if (errcode && !ct->error)
173     {
174         ct->error = errcode;
175         ct->addinfo = strdup(val);
176     }
177     return 0;
178 }
179
180 void emit_term(cql_transform_t ct,
181                const char *term, int length,
182                void (*pr)(const char *buf, void *client_data),
183                void *client_data)
184 {
185     int i;
186     if (length > 0)
187     {
188         if (length > 1 && term[0] == '^' && term[length-1] == '^')
189         {
190             cql_pr_attr(ct, "position.", "firstAndLast", 0,
191                         pr, client_data, 32);
192             term++;
193             length -= 2;
194         }
195         else if (term[0] == '^')
196         {
197             cql_pr_attr(ct, "position.", "first", 0,
198                         pr, client_data, 32);
199             term++;
200         }
201         else if (term[length-1] == '^')
202         {
203             cql_pr_attr(ct, "position.", "last", 0,
204                         pr, client_data, 32);
205             length--;
206         }
207         else
208         {
209             cql_pr_attr(ct, "position.", "any", 0,
210                         pr, client_data, 32);
211         }
212     }
213     (*pr)("\"", client_data);
214     for (i = 0; i<length; i++)
215     {
216         char buf[2];
217         buf[0] = term[i];
218         buf[1] = 0;
219         (*pr)(buf, client_data);
220     }
221     (*pr)("\" ", client_data);
222 }
223
224 void emit_wordlist(cql_transform_t ct,
225                    struct cql_node *cn,
226                    void (*pr)(const char *buf, void *client_data),
227                    void *client_data,
228                    const char *op)
229 {
230     const char *cp0 = cn->u.st.term;
231     const char *cp1;
232     const char *last_term = 0;
233     int last_length = 0;
234     while(cp0)
235     {
236         while (*cp0 == ' ')
237             cp0++;
238         cp1 = strchr(cp0, ' ');
239         if (last_term)
240         {
241             (*pr)("@", client_data);
242             (*pr)(op, client_data);
243             (*pr)(" ", client_data);
244             emit_term(ct, last_term, last_length, pr, client_data);
245         }
246         last_term = cp0;
247         if (cp1)
248             last_length = cp1 - cp0;
249         else
250             last_length = strlen(cp0);
251         cp0 = cp1;
252     }
253     if (last_term)
254         emit_term(ct, last_term, last_length, pr, client_data);
255 }
256
257
258 static const char *cql_get_ns(cql_transform_t ct,
259                               struct cql_node *cn,
260                               struct cql_node **prefix_ar, int prefix_level,
261                               const char **n_prefix,
262                               const char **n_suffix)
263 {
264     int i;
265     const char *ns = 0;
266     char prefix[32];
267     const char *cp = cn->u.st.index;
268     const char *cp_dot = strchr(cp, '.');
269
270     /* strz current prefix (empty if not given) */
271     if (cp_dot && cp_dot-cp < sizeof(prefix))
272     {
273         memcpy (prefix, cp, cp_dot - cp);
274         prefix[cp_dot - cp] = 0;
275     }
276     else
277         *prefix = 0;
278
279     /* 2. lookup in prefix_ar. and return NS */
280     for (i = prefix_level; !ns && --i >= 0; )
281     {
282         struct cql_node *cn_prefix = prefix_ar[i];
283         for (; cn_prefix; cn_prefix = cn_prefix->u.mod.next)
284         {
285             if (*prefix && cn_prefix->u.mod.name &&
286                 !strcmp(prefix, cn_prefix->u.mod.name))
287             {
288                 ns = cn_prefix->u.mod.value;
289                 break;
290             }
291             else if (!*prefix && !cn_prefix->u.mod.name)
292             {
293                 ns = cn_prefix->u.mod.value;
294                 break;
295             }
296         }
297     }
298     if (!ns)
299     {
300         if (!ct->error)
301         {
302             ct->error = 15;
303             ct->addinfo = strdup(prefix);
304         }
305         return 0;
306     }
307     /* 3. lookup in set.NS for new prefix */
308     *n_prefix = cql_lookup_value(ct, "set.", ns);
309     if (!*n_prefix)
310     {
311         if (!ct->error)
312         {
313             ct->error = 15;
314             ct->addinfo = strdup(ns);
315         }
316         return 0;
317     }
318     /* 4. lookup qualifier.prefix. */
319     
320     cp = cn->u.st.index;
321     cp_dot = strchr(cp, '.');
322     
323     *n_suffix = cp_dot ? cp_dot+1 : cp;
324     return ns;
325 }
326
327 void cql_transform_r(cql_transform_t ct,
328                      struct cql_node *cn,
329                      void (*pr)(const char *buf, void *client_data),
330                      void *client_data,
331                      struct cql_node **prefix_ar, int prefix_level)
332 {
333     const char *ns, *n_prefix, *n_suffix;
334
335     if (!cn)
336         return;
337     switch (cn->which)
338     {
339     case CQL_NODE_ST:
340         if (cn->u.st.prefixes && prefix_level < 20)
341             prefix_ar[prefix_level++] = cn->u.st.prefixes;
342         ns = cql_get_ns(ct, cn, prefix_ar, prefix_level, &n_prefix, &n_suffix);
343         if (ns)
344         {
345             char n_full[64];
346             sprintf (n_full, "%.20s.%.40s", n_prefix, n_suffix);
347         
348             if (!strcmp(ns, "http://www.loc.gov/zing/cql/srw-indexes/v1.0/")
349                 && !strcmp(n_suffix, "resultSet"))
350             {
351                 (*pr)("@set \"", client_data);
352                 (*pr)(cn->u.st.term, client_data);
353                 (*pr)("\" ", client_data);
354                 return ;
355             }
356             cql_pr_attr(ct, "qualifier.", n_full, "srw.serverChoice",
357                         pr, client_data, 16);
358         }
359
360         if (cn->u.st.relation && !strcmp(cn->u.st.relation, "="))
361             cql_pr_attr(ct, "relation.", "eq", "scr",
362                         pr, client_data, 19);
363         else if (cn->u.st.relation && !strcmp(cn->u.st.relation, "<="))
364             cql_pr_attr(ct, "relation.", "le", "scr",
365                         pr, client_data, 19);
366         else if (cn->u.st.relation && !strcmp(cn->u.st.relation, ">="))
367             cql_pr_attr(ct, "relation.", "ge", "scr",
368                         pr, client_data, 19);
369         else
370             cql_pr_attr(ct, "relation.", cn->u.st.relation, "eq",
371                         pr, client_data, 19);
372         if (cn->u.st.modifiers)
373         {
374             struct cql_node *mod = cn->u.st.modifiers;
375             for (; mod; mod = mod->u.mod.next)
376             {
377                 cql_pr_attr(ct, "relationModifier.", mod->u.mod.value, 0,
378                             pr, client_data, 20);
379             }
380         }
381         cql_pr_attr(ct, "structure.", cn->u.st.relation, 0,
382                     pr, client_data, 24);
383         if (cn->u.st.relation && !strcmp(cn->u.st.relation, "all"))
384         {
385             emit_wordlist(ct, cn, pr, client_data, "and");
386         }
387         else if (cn->u.st.relation && !strcmp(cn->u.st.relation, "any"))
388         {
389             emit_wordlist(ct, cn, pr, client_data, "or");
390         }
391         else
392         {
393             emit_term(ct, cn->u.st.term, strlen(cn->u.st.term),
394                       pr, client_data);
395         }
396         break;
397     case CQL_NODE_BOOL:
398         if (cn->u.boolean.prefixes && prefix_level < 20)
399             prefix_ar[prefix_level++] = cn->u.boolean.prefixes;
400         (*pr)("@", client_data);
401         (*pr)(cn->u.boolean.value, client_data);
402         (*pr)(" ", client_data);
403
404         cql_transform_r(ct, cn->u.boolean.left, pr, client_data,
405                         prefix_ar, prefix_level);
406         cql_transform_r(ct, cn->u.boolean.right, pr, client_data,
407                         prefix_ar, prefix_level);
408     }
409 }
410
411 int cql_transform(cql_transform_t ct,
412                   struct cql_node *cn,
413                   void (*pr)(const char *buf, void *client_data),
414                   void *client_data)
415 {
416     struct cql_node *prefix_ar[20], **pp;
417     struct cql_prop_entry *e;
418
419     ct->error = 0;
420     if (ct->addinfo)
421         free (ct->addinfo);
422     ct->addinfo = 0;
423
424     prefix_ar[0] = 0;
425     pp = &prefix_ar[0];
426     for (e = ct->entry; e ; e = e->next)
427     {
428         if (!memcmp(e->pattern, "set.", 4))
429         {
430             *pp = cql_node_mk_mod(e->pattern+4, e->value);
431             pp = &(*pp)->u.mod.next;
432         }
433         else if (!strcmp(e->pattern, "set"))
434         {
435             *pp = cql_node_mk_mod(0, e->value);
436             pp = &(*pp)->u.mod.next;
437         }
438     }
439     cql_transform_r (ct, cn, pr, client_data, prefix_ar, 1);
440     cql_node_destroy(prefix_ar[0]);
441     return ct->error;
442 }
443
444
445 int cql_transform_FILE(cql_transform_t ct, struct cql_node *cn, FILE *f)
446 {
447     return cql_transform(ct, cn, cql_fputs, f);
448 }
449
450 int cql_transform_buf(cql_transform_t ct, struct cql_node *cn,
451                       char *out, int max)
452 {
453     struct cql_buf_write_info info;
454     int r;
455
456     info.off = 0;
457     info.max = max;
458     info.buf = out;
459     r = cql_transform(ct, cn, cql_buf_write_handler, &info);
460     if (info.off >= 0)
461         info.buf[info.off] = '\0';
462     return r;
463 }
464
465 int cql_transform_error(cql_transform_t ct, const char **addinfo)
466 {
467     *addinfo = ct->addinfo;
468     return ct->error;
469 }