35dd611c2463d8d61964e288f06147f7fc4ed6df
[pazpar2-moved-to-github.git] / src / charsets.c
1 /* This file is part of Pazpar2.
2    Copyright (C) 2006-2008 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 <ctype.h>
32 #include <assert.h>
33
34 #include "charsets.h"
35 #include "normalize7bit.h"
36
37 #ifdef HAVE_ICU
38 #include "icu_I18N.h"
39 #endif // HAVE_ICU
40
41 /* charset handle */
42 struct pp2_charset_s {
43     const char *(*token_next_handler)(pp2_relevance_token_t prt);
44     const char *(*get_sort_handler)(pp2_relevance_token_t prt, int skip);
45 #ifdef HAVE_ICU
46     struct icu_chain * icu_chn;
47     UErrorCode icu_sts;
48 #endif // HAVE_ICU
49 };
50
51 static const char *pp2_relevance_token_a_to_z(pp2_relevance_token_t prt);
52 static const char *pp2_get_sort_ascii(pp2_relevance_token_t prt, int skip_article);
53
54 #ifdef HAVE_ICU
55 static const char *pp2_relevance_token_icu(pp2_relevance_token_t prt);
56 static const char *pp2_get_sort_icu(pp2_relevance_token_t prt, int skip_article);
57 #endif // HAVE_ICU
58
59 /* tokenzier handle */
60 struct pp2_relevance_token_s {
61     const char *cp;     /* unnormalized buffer we're tokenizing */
62     const char *last_cp;  /* pointer to last token we're dealing with */
63     pp2_charset_t pct;  /* our main charset handle (type+config) */
64     WRBUF norm_str;     /* normized string we return (temporarily) */
65     WRBUF sort_str;     /* sort string we return (temporarily) */
66 };
67
68
69 pp2_charset_t pp2_charset_create_xml(xmlNode *xml_node)
70 {
71 #ifdef HAVE_ICU
72     UErrorCode status = U_ZERO_ERROR;
73     struct icu_chain *chain = 0;
74     while (xml_node && xml_node->type != XML_ELEMENT_NODE)
75         xml_node = xml_node->next;
76     chain = icu_chain_xml_config(xml_node, &status);
77     if (!chain || U_FAILURE(status)){
78         //xmlDocPtr icu_doc = 0;
79         //xmlChar *xmlstr = 0;
80                 //int size = 0;
81                 //xmlDocDumpMemory(icu_doc, size);
82         
83         yaz_log(YLOG_FATAL, "Could not parse ICU chain config:\n"
84                 "<%s>\n ... \n</%s>",
85                 xml_node->name, xml_node->name);
86         return 0;
87     }
88     return pp2_charset_create(chain);
89 #else // HAVE_ICU
90     yaz_log(YLOG_FATAL, "Error: ICU support requested with element:\n"
91             "<%s>\n ... \n</%s>",
92             xml_node->name, xml_node->name);
93     yaz_log(YLOG_FATAL, 
94             "But no ICU support compiled into pazpar2 server.");
95     yaz_log(YLOG_FATAL, 
96             "Please install libicu36-dev and icu-doc or similar, "
97             "re-configure and re-compile");            
98     return 0;
99 #endif // HAVE_ICU
100 }
101
102
103 pp2_charset_t pp2_charset_create(struct icu_chain * icu_chn)
104 {
105     pp2_charset_t pct = xmalloc(sizeof(*pct));
106
107     pct->token_next_handler = pp2_relevance_token_a_to_z;
108     pct->get_sort_handler  = pp2_get_sort_ascii;
109 #ifdef HAVE_ICU
110     pct->icu_chn = 0;
111     if (icu_chn)
112     {
113         pct->icu_chn = icu_chn;
114         pct->icu_sts = U_ZERO_ERROR;
115         pct->token_next_handler = pp2_relevance_token_icu;
116         pct->get_sort_handler = pp2_get_sort_icu;
117     }
118 #endif // HAVE_ICU
119     return pct;
120 }
121
122 void pp2_charset_destroy(pp2_charset_t pct)
123 {
124     xfree(pct);
125 }
126
127 pp2_relevance_token_t pp2_relevance_tokenize(pp2_charset_t pct,
128                                              const char *buf)
129 {
130     pp2_relevance_token_t prt = xmalloc(sizeof(*prt));
131
132     assert(pct);
133
134     prt->norm_str = wrbuf_alloc();
135     prt->sort_str = wrbuf_alloc();
136     prt->cp = buf;
137     prt->last_cp = 0;
138     prt->pct = pct;
139
140 #ifdef HAVE_ICU
141     if (pct->icu_chn)
142     {
143         int ok = 0;
144         pct->icu_sts = U_ZERO_ERROR;
145         ok = icu_chain_assign_cstr(pct->icu_chn, buf, &pct->icu_sts);
146         //printf("\nfield ok: %d '%s'\n", ok, buf);
147         prt->pct = pct;
148     }
149 #endif // HAVE_ICU
150     return prt;
151 }
152
153
154 void pp2_relevance_token_destroy(pp2_relevance_token_t prt)
155 {
156     assert(prt);
157     if(prt->norm_str) 
158         wrbuf_destroy(prt->norm_str);
159     if(prt->sort_str) 
160         wrbuf_destroy(prt->sort_str);
161     xfree(prt);
162 }
163
164 const char *pp2_relevance_token_next(pp2_relevance_token_t prt)
165 {
166     assert(prt);
167     return (prt->pct->token_next_handler)(prt);
168 }
169
170 const char *pp2_get_sort(pp2_relevance_token_t prt, int skip)
171 {
172     return prt->pct->get_sort_handler(prt, skip);
173 }
174
175 #define raw_char(c) (((c) >= 'a' && (c) <= 'z') ? (c) : -1)
176 /* original tokenizer with our tokenize interface, but we
177    add +1 to ensure no '\0' are in our string (except for EOF)
178 */
179 static const char *pp2_relevance_token_a_to_z(pp2_relevance_token_t prt)
180 {
181     const char *cp = prt->cp;
182     int c;
183
184     /* skip white space */
185     while (*cp && (c = raw_char(tolower(*(const unsigned char *)cp))) < 0)
186         cp++;
187     if (*cp == '\0')
188     {
189         prt->cp = cp;
190         prt->last_cp = 0;
191         return 0;
192     }
193     /* now read the term itself */
194
195     prt->last_cp = cp;
196     wrbuf_rewind(prt->norm_str);
197     while (*cp && (c = raw_char(tolower(*cp))) >= 0)
198     {
199         wrbuf_putc(prt->norm_str, c);
200         cp++;
201     }
202     prt->cp = cp;
203     return wrbuf_cstr(prt->norm_str);
204 }
205
206 static const char *pp2_get_sort_ascii(pp2_relevance_token_t prt,
207                                     int skip_article)
208 {
209     if (prt->last_cp == 0)
210         return 0;
211     else
212     {
213         char *tmp = xstrdup(prt->last_cp);
214         char *result = 0;
215         result = normalize7bit_mergekey(tmp, skip_article);
216         
217         wrbuf_rewind(prt->sort_str);
218         wrbuf_puts(prt->sort_str, result);
219         xfree(tmp);
220         return wrbuf_cstr(prt->sort_str);
221     }
222 }
223
224
225 #ifdef HAVE_ICU
226 static const char *pp2_relevance_token_icu(pp2_relevance_token_t prt)
227 {
228     if (icu_chain_next_token(prt->pct->icu_chn, &prt->pct->icu_sts))
229     {
230         if (U_FAILURE(prt->pct->icu_sts))
231         {
232             return 0;
233         }
234         return icu_chain_get_norm(prt->pct->icu_chn);
235     }
236     return 0;
237 }
238
239 static const char *pp2_get_sort_icu(pp2_relevance_token_t prt,
240                                     int skip_article)
241 {
242     return icu_chain_get_sort(prt->pct->icu_chn);
243 }
244
245 #endif // HAVE_ICU
246
247
248
249 /*
250  * Local variables:
251  * c-basic-offset: 4
252  * indent-tabs-mode: nil
253  * End:
254  * vim: shiftwidth=4 tabstop=8 expandtab
255  */