Bump copyright year
[pazpar2-moved-to-github.git] / src / charsets.c
1 /* This file is part of Pazpar2.
2    Copyright (C) 2006-2013 Index Data
3
4 Pazpar2 is free software; you can redistribute it and/or modify it under
5 the terms of the GNU General Public License as published by the Free
6 Software Foundation; either version 2, or (at your option) any later
7 version.
8
9 Pazpar2 is distributed in the hope that it will be useful, but WITHOUT ANY
10 WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12 for more details.
13
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
17
18 */
19
20 /** \file charsets.c
21     \brief Pazpar2 Character set facilities
22 */
23
24 #if HAVE_CONFIG_H
25 #include <config.h>
26 #endif
27
28 #include <yaz/xmalloc.h>
29 #include <yaz/wrbuf.h>
30 #include <yaz/log.h>
31 #include <yaz/yaz-version.h>
32 #include <ctype.h>
33 #include <assert.h>
34 #include <string.h>
35
36 #include "charsets.h"
37 #include "normalize7bit.h"
38
39 typedef struct pp2_charset_s *pp2_charset_t;
40 static pp2_charset_t pp2_charset_create_xml(xmlNode *xml_node);
41 static pp2_charset_t pp2_charset_create(void);
42 static pp2_charset_t pp2_charset_create_a_to_z(void);
43 static void pp2_charset_destroy(pp2_charset_t pct);
44 static pp2_charset_token_t pp2_charset_tokenize(pp2_charset_t pct);
45
46 #if YAZ_HAVE_ICU
47 #include <yaz/icu.h>
48 static pp2_charset_t pp2_charset_create_icu(struct icu_chain *icu_chn);
49 #endif
50
51 /* charset handle */
52 struct pp2_charset_s {
53     const char *(*token_next_handler)(pp2_charset_token_t prt);
54     const char *(*get_sort_handler)(pp2_charset_token_t prt);
55     const char *(*get_display_handler)(pp2_charset_token_t prt);
56 #if YAZ_HAVE_ICU
57     struct icu_chain * icu_chn;
58     UErrorCode icu_sts;
59 #endif
60 };
61
62 static const char *pp2_charset_token_null(pp2_charset_token_t prt);
63 static const char *pp2_charset_token_a_to_z(pp2_charset_token_t prt);
64 static const char *pp2_get_sort_ascii(pp2_charset_token_t prt);
65 static const char *pp2_get_display_ascii(pp2_charset_token_t prt);
66
67 #if YAZ_HAVE_ICU
68 static const char *pp2_charset_token_icu(pp2_charset_token_t prt);
69 static const char *pp2_get_sort_icu(pp2_charset_token_t prt);
70 static const char *pp2_get_display_icu(pp2_charset_token_t prt);
71 #endif
72
73 /* tokenzier handle */
74 struct pp2_charset_token_s {
75     const char *cp;     /* unnormalized buffer we're tokenizing */
76     const char *last_cp;  /* pointer to last token we're dealing with */
77     pp2_charset_t pct;  /* our main charset handle (type+config) */
78     WRBUF norm_str;     /* normized string we return (temporarily) */
79     WRBUF sort_str;     /* sort string we return (temporarily) */
80 #if YAZ_HAVE_ICU
81     yaz_icu_iter_t iter;
82 #endif
83 };
84
85 struct pp2_charset_fact_s {
86     struct pp2_charset_entry *list;
87     int ref_count;
88 };
89
90 struct pp2_charset_entry {
91     struct pp2_charset_entry *next;
92     pp2_charset_t pct;
93     char *name;
94 };
95
96
97 static int pp2_charset_fact_add(pp2_charset_fact_t pft,
98                                 pp2_charset_t pct, const char *default_id);
99
100 pp2_charset_fact_t pp2_charset_fact_create(void)
101 {
102     pp2_charset_fact_t pft = xmalloc(sizeof(*pft));
103     pft->list = 0;
104     pft->ref_count = 1;
105
106     pp2_charset_fact_add(pft, pp2_charset_create_a_to_z(), "relevance");
107     pp2_charset_fact_add(pft, pp2_charset_create_a_to_z(), "sort");
108     pp2_charset_fact_add(pft, pp2_charset_create_a_to_z(), "mergekey");
109     pp2_charset_fact_add(pft, pp2_charset_create(), "facet");
110     return pft;
111 }
112
113 void pp2_charset_fact_destroy(pp2_charset_fact_t pft)
114 {
115     if (pft)
116     {
117         assert(pft->ref_count >= 1);
118         --(pft->ref_count);
119         if (pft->ref_count == 0)
120         {
121             struct pp2_charset_entry *pce = pft->list;
122             while (pce)
123             {
124                 struct pp2_charset_entry *next = pce->next;
125                 pp2_charset_destroy(pce->pct);
126                 xfree(pce->name);
127                 xfree(pce);
128                 pce = next;
129             }
130             xfree(pft);
131         }
132     }
133 }
134
135 int pp2_charset_fact_add(pp2_charset_fact_t pft,
136                          pp2_charset_t pct, const char *default_id)
137 {
138     struct pp2_charset_entry *pce;
139
140     for (pce = pft->list; pce; pce = pce->next)
141         if (!strcmp(default_id, pce->name))
142             break;
143
144     if (!pce)
145     {
146         pce = xmalloc(sizeof(*pce));
147         pce->name = xstrdup(default_id);
148         pce->next = pft->list;
149         pft->list = pce;
150     }
151     else
152     {
153         pp2_charset_destroy(pce->pct);
154     }
155     pce->pct = pct;
156     return 0;
157 }
158
159 int pp2_charset_fact_define(pp2_charset_fact_t pft,
160                             xmlNode *xml_node, const char *default_id)
161 {
162     int r;
163     pp2_charset_t pct;
164     xmlChar *id = 0;
165
166     assert(xml_node);
167     pct = pp2_charset_create_xml(xml_node);
168     if (!pct)
169         return -1;
170     if (!default_id)
171     {
172         id = xmlGetProp(xml_node, (xmlChar*) "id");
173         if (!id)
174         {
175             yaz_log(YLOG_WARN, "Missing id for icu_chain");
176             pp2_charset_destroy(pct);
177             return -1;
178         }
179         default_id = (const char *) id;
180     }
181     r = pp2_charset_fact_add(pft, pct, default_id);
182     if (id)
183         xmlFree(id);
184     return r;
185 }
186
187 void pp2_charset_fact_incref(pp2_charset_fact_t pft)
188 {
189     (pft->ref_count)++;
190 }
191
192 pp2_charset_t pp2_charset_create_xml(xmlNode *xml_node)
193 {
194 #if YAZ_HAVE_ICU
195     UErrorCode status = U_ZERO_ERROR;
196     struct icu_chain *chain = 0;
197     while (xml_node && xml_node->type != XML_ELEMENT_NODE)
198         xml_node = xml_node->next;
199     chain = icu_chain_xml_config(xml_node, 1, &status);
200     if (!chain || U_FAILURE(status)){
201         //xmlDocPtr icu_doc = 0;
202         //xmlChar *xmlstr = 0;
203                 //int size = 0;
204                 //xmlDocDumpMemory(icu_doc, size);
205
206         yaz_log(YLOG_FATAL, "Could not parse ICU chain config:\n"
207                 "<%s>\n ... \n</%s>",
208                 xml_node->name, xml_node->name);
209         return 0;
210     }
211     return pp2_charset_create_icu(chain);
212 #else // YAZ_HAVE_ICU
213     yaz_log(YLOG_FATAL, "Error: ICU support requested with element:\n"
214             "<%s>\n ... \n</%s>",
215             xml_node->name, xml_node->name);
216     yaz_log(YLOG_FATAL,
217             "But no ICU support is compiled into the YAZ library.");
218     return 0;
219 #endif // YAZ_HAVE_ICU
220 }
221
222 pp2_charset_t pp2_charset_create(void)
223 {
224     pp2_charset_t pct = xmalloc(sizeof(*pct));
225
226     pct->token_next_handler = pp2_charset_token_null;
227     pct->get_sort_handler  = pp2_get_sort_ascii;
228     pct->get_display_handler  = pp2_get_display_ascii;
229 #if YAZ_HAVE_ICU
230     pct->icu_chn = 0;
231 #endif // YAZ_HAVE_ICU
232     return pct;
233 }
234
235 pp2_charset_t pp2_charset_create_a_to_z(void)
236 {
237     pp2_charset_t pct = pp2_charset_create();
238     pct->token_next_handler = pp2_charset_token_a_to_z;
239     return pct;
240 }
241
242 #if YAZ_HAVE_ICU
243 pp2_charset_t pp2_charset_create_icu(struct icu_chain *icu_chn)
244 {
245     pp2_charset_t pct = pp2_charset_create();
246     if (icu_chn)
247     {
248         pct->icu_chn = icu_chn;
249         pct->icu_sts = U_ZERO_ERROR;
250         pct->token_next_handler = pp2_charset_token_icu;
251         pct->get_sort_handler = pp2_get_sort_icu;
252         pct->get_display_handler = pp2_get_display_icu;
253     }
254     return pct;
255 }
256 #endif // YAZ_HAVE_ICU
257
258 void pp2_charset_destroy(pp2_charset_t pct)
259 {
260 #if YAZ_HAVE_ICU
261     icu_chain_destroy(pct->icu_chn);
262 #endif
263     xfree(pct);
264 }
265
266 pp2_charset_token_t pp2_charset_token_create(pp2_charset_fact_t pft,
267                                                const char *id)
268 {
269     struct pp2_charset_entry *pce;
270     for (pce = pft->list; pce; pce = pce->next)
271         if (!strcmp(id, pce->name))
272             return pp2_charset_tokenize(pce->pct);
273     return 0;
274 }
275
276 pp2_charset_token_t pp2_charset_tokenize(pp2_charset_t pct)
277 {
278     pp2_charset_token_t prt = xmalloc(sizeof(*prt));
279
280     assert(pct);
281
282     prt->norm_str = wrbuf_alloc();
283     prt->sort_str = wrbuf_alloc();
284     prt->cp = 0;
285     prt->last_cp = 0;
286     prt->pct = pct;
287
288 #if YAZ_HAVE_ICU
289     prt->iter = 0;
290     if (pct->icu_chn)
291         prt->iter = icu_iter_create(pct->icu_chn);
292 #endif
293     return prt;
294 }
295
296 void pp2_charset_token_first(pp2_charset_token_t prt,
297                              const char *buf, int skip_article)
298 {
299     if (skip_article)
300     {
301         const char *p = buf;
302         char firstword[64];
303         char *pout = firstword;
304         char articles[] = "the den der die des an a "; // must end in space
305
306         for (; *p && *p != ' ' && pout - firstword < (sizeof(firstword)-2); p++)
307             *pout++ = tolower(*(unsigned char *)p);
308         *pout++ = ' ';
309         *pout++ = '\0';
310         if (strstr(articles, firstword))
311             buf = p;
312     }
313
314     wrbuf_rewind(prt->norm_str);
315     wrbuf_rewind(prt->sort_str);
316     prt->cp = buf;
317     prt->last_cp = 0;
318
319 #if YAZ_HAVE_ICU
320     if (prt->iter)
321     {
322         icu_iter_first(prt->iter, buf);
323     }
324 #endif // YAZ_HAVE_ICU
325 }
326
327 void pp2_charset_token_destroy(pp2_charset_token_t prt)
328 {
329     assert(prt);
330 #if YAZ_HAVE_ICU
331     if (prt->iter)
332         icu_iter_destroy(prt->iter);
333 #endif
334     if(prt->norm_str)
335         wrbuf_destroy(prt->norm_str);
336     if(prt->sort_str)
337         wrbuf_destroy(prt->sort_str);
338     xfree(prt);
339 }
340
341 const char *pp2_charset_token_next(pp2_charset_token_t prt)
342 {
343     assert(prt);
344     return (prt->pct->token_next_handler)(prt);
345 }
346
347 const char *pp2_get_sort(pp2_charset_token_t prt)
348 {
349     return prt->pct->get_sort_handler(prt);
350 }
351
352 const char *pp2_get_display(pp2_charset_token_t prt)
353 {
354     return prt->pct->get_display_handler(prt);
355 }
356
357 #define raw_char(c) (((c) >= 'a' && (c) <= 'z') ? (c) : -1)
358 /* original tokenizer with our tokenize interface, but we
359    add +1 to ensure no '\0' are in our string (except for EOF)
360 */
361 static const char *pp2_charset_token_a_to_z(pp2_charset_token_t prt)
362 {
363     const char *cp = prt->cp;
364     int c;
365
366     /* skip white space */
367     while (*cp && (c = raw_char(tolower(*(const unsigned char *)cp))) < 0)
368         cp++;
369     if (*cp == '\0')
370     {
371         prt->cp = cp;
372         prt->last_cp = 0;
373         return 0;
374     }
375     /* now read the term itself */
376
377     prt->last_cp = cp;
378     wrbuf_rewind(prt->norm_str);
379     while (*cp && (c = raw_char(tolower(*cp))) >= 0)
380     {
381         wrbuf_putc(prt->norm_str, c);
382         cp++;
383     }
384     prt->cp = cp;
385     return wrbuf_cstr(prt->norm_str);
386 }
387
388 static const char *pp2_get_sort_ascii(pp2_charset_token_t prt)
389 {
390     if (prt->last_cp == 0)
391         return 0;
392     else
393     {
394         char *tmp = xstrdup(prt->last_cp);
395         char *result = 0;
396         result = normalize7bit_mergekey(tmp);
397
398         wrbuf_rewind(prt->sort_str);
399         wrbuf_puts(prt->sort_str, result);
400         xfree(tmp);
401         return wrbuf_cstr(prt->sort_str);
402     }
403 }
404
405 static const char *pp2_get_display_ascii(pp2_charset_token_t prt)
406 {
407     if (prt->last_cp == 0)
408         return 0;
409     else
410     {
411         return wrbuf_cstr(prt->norm_str);
412     }
413 }
414
415 static const char *pp2_charset_token_null(pp2_charset_token_t prt)
416 {
417     const char *cp = prt->cp;
418
419     prt->last_cp = *cp ? cp : 0;
420     while (*cp)
421         cp++;
422     prt->cp = cp;
423     return prt->last_cp;
424 }
425
426 #if YAZ_HAVE_ICU
427 static const char *pp2_charset_token_icu(pp2_charset_token_t prt)
428 {
429     if (icu_iter_next(prt->iter))
430     {
431         return icu_iter_get_norm(prt->iter);
432     }
433     return 0;
434 }
435
436 static const char *pp2_get_sort_icu(pp2_charset_token_t prt)
437 {
438     return icu_iter_get_sortkey(prt->iter);
439 }
440
441 static const char *pp2_get_display_icu(pp2_charset_token_t prt)
442 {
443     return icu_iter_get_display(prt->iter);
444 }
445
446 #endif // YAZ_HAVE_ICU
447
448
449 /*
450  * Local variables:
451  * c-basic-offset: 4
452  * c-file-style: "Stroustrup"
453  * indent-tabs-mode: nil
454  * End:
455  * vim: shiftwidth=4 tabstop=8 expandtab
456  */
457