Put local variables footer in all c, h files.
[idzebra-moved-to-github.git] / recctrl / rectext.c
1 /* $Id: rectext.c,v 1.31 2006-05-10 08:13:30 adam Exp $
2    Copyright (C) 1995-2005
3    Index Data ApS
4
5 This file is part of the Zebra server.
6
7 Zebra is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
10 version.
11
12 Zebra is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
15 for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with Zebra; see the file LICENSE.zebra.  If not, write to the
19 Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
20 02111-1307, USA.
21 */
22
23
24 #include <stdio.h>
25 #include <assert.h>
26 #include <ctype.h>
27
28 #include <idzebra/util.h>
29 #include <idzebra/recctrl.h>
30
31 struct filter_info {
32     char *sep;
33 };
34
35 static void *filter_init (Res res, RecType recType)
36 {
37     struct filter_info *tinfo = (struct filter_info *) xmalloc(sizeof(*tinfo));
38     tinfo->sep = 0;
39     return tinfo;
40 }
41
42 static ZEBRA_RES filter_config(void *clientData, Res res, const char *args)
43 {
44     struct filter_info *tinfo = (struct filter_info*) clientData;
45     xfree(tinfo->sep);
46     tinfo->sep = 0;
47     if (args && *args)
48         tinfo->sep = xstrdup(args);
49     return ZEBRA_OK;
50 }
51
52 static void filter_destroy (void *clientData)
53 {
54     struct filter_info *tinfo = clientData;
55     xfree (tinfo->sep);
56     xfree (tinfo);
57 }
58
59 struct buf_info {
60     struct recExtractCtrl *p;
61     char *buf;
62     int offset;
63     int max;
64 };
65
66 static struct buf_info *buf_open (struct recExtractCtrl *p)
67 {
68     struct buf_info *fi = (struct buf_info *) xmalloc (sizeof(*fi));
69
70     fi->p = p;
71     fi->buf = (char *) xmalloc (4096);
72     fi->offset = 1;
73     fi->max = 1;
74     return fi;
75 }
76
77 static int buf_getchar (struct filter_info *tinfo, struct buf_info *fi, char *dst)
78 {
79     if (fi->offset >= fi->max)
80     {
81         if (fi->max <= 0)
82             return 0;
83         fi->max = (*fi->p->readf)(fi->p->fh, fi->buf, 4096);
84         fi->offset = 0;
85         if (fi->max <= 0)
86             return 0;
87     }
88     *dst = fi->buf[(fi->offset)++];
89     if (tinfo->sep && *dst == *tinfo->sep)
90     {
91         off_t off = (*fi->p->tellf)(fi->p->fh);
92         (*fi->p->endf)(fi->p->fh, off - (fi->max - fi->offset));
93         return 0;
94     }
95     return 1;
96 }
97
98 static void buf_close (struct buf_info *fi)
99 {
100     xfree (fi->buf);
101     xfree (fi);
102 }
103
104 static int filter_extract (void *clientData, struct recExtractCtrl *p)
105 {
106     struct filter_info *tinfo = clientData;
107     char w[512];
108     RecWord recWord;
109     int r;
110     struct buf_info *fi = buf_open (p);
111     int no_read = 0;
112
113 #if 0
114     yaz_log(YLOG_LOG, "filter_extract off=%ld",
115             (long) (*fi->p->tellf)(fi->p->fh));
116 #endif
117     (*p->init)(p, &recWord);
118     do
119     {
120         int i = 0;
121             
122         r = buf_getchar (tinfo, fi, w);
123         while (r > 0 && i < 511 && w[i] != '\n' && w[i] != '\r')
124         {
125             i++;
126             r = buf_getchar (tinfo, fi, w + i); 
127         }
128         if (i)
129         {
130             no_read += i;
131             recWord.term_buf = w;
132             recWord.term_len = i;
133             (*p->tokenAdd)(&recWord);
134         }
135     } while (r > 0);
136     buf_close (fi);
137     if (no_read == 0)
138         return RECCTRL_EXTRACT_EOF;
139     return RECCTRL_EXTRACT_OK;
140 }
141
142 static int filter_retrieve (void *clientData, struct recRetrieveCtrl *p)
143 {
144     int r, filter_ptr = 0;
145     static char *filter_buf = NULL;
146     static int filter_size = 0;
147     int make_header = 1;
148     int make_body = 1;
149     const char *elementSetName = NULL;
150     int no_lines = 0;
151
152     if (p->comp && p->comp->which == Z_RecordComp_simple &&
153         p->comp->u.simple->which == Z_ElementSetNames_generic)
154         elementSetName = p->comp->u.simple->u.generic;
155
156     if (elementSetName)
157     {
158         /* don't make header for the R(aw) element set name */
159         if (!strcmp(elementSetName, "R"))
160         {
161             make_header = 0;
162             make_body = 1;
163         }
164         /* only make header for the H(eader) element set name */
165         else if (!strcmp(elementSetName, "H"))
166         {
167             make_header = 1;
168             make_body = 0;
169         }
170     }
171     while (1)
172     {
173         if (filter_ptr + 4096 >= filter_size)
174         {
175             char *nb;
176
177             filter_size = 2*filter_size + 8192;
178             nb = (char *) xmalloc (filter_size);
179             if (filter_buf)
180             {
181                 memcpy (nb, filter_buf, filter_ptr);
182                 xfree (filter_buf);
183             }
184             filter_buf = nb;
185         }
186         if (make_header && filter_ptr == 0)
187         {
188             if (p->score >= 0)
189             {
190                 sprintf (filter_buf, "Rank: %d\n", p->score);
191                 filter_ptr = strlen(filter_buf);
192             }
193             sprintf (filter_buf + filter_ptr, "Local Number: " ZINT_FORMAT "\n",
194                      p->localno);
195             filter_ptr = strlen(filter_buf);
196             if (p->fname)
197             {
198                 sprintf (filter_buf + filter_ptr, "Filename: %s\n", p->fname);
199                 filter_ptr = strlen(filter_buf);
200             }
201             strcpy(filter_buf+filter_ptr++, "\n");
202         }
203         if (!make_body)
204             break;
205         r = (*p->readf)(p->fh, filter_buf + filter_ptr, 4096);
206         if (r <= 0)
207             break;
208         filter_ptr += r;
209     }
210     filter_buf[filter_ptr] = '\0';
211     if (elementSetName)
212     {
213         if (!strcmp (elementSetName, "B"))
214             no_lines = 4;
215         if (!strcmp (elementSetName, "M"))
216             no_lines = 20;
217     }
218     if (no_lines)
219     {
220         char *p = filter_buf;
221         int i = 0;
222
223         while (++i <= no_lines && (p = strchr (p, '\n')))
224             p++;
225         if (p)
226         {
227             p[1] = '\0';
228             filter_ptr = p-filter_buf;
229         }
230     }
231     p->output_format = VAL_SUTRS;
232     p->rec_buf = filter_buf;
233     p->rec_len = filter_ptr; 
234     return 0;
235 }
236
237 static struct recType filter_type = {
238     0,
239     "text",
240     filter_init,
241     filter_config,
242     filter_destroy,
243     filter_extract,
244     filter_retrieve
245 };
246
247 RecType
248 #ifdef IDZEBRA_STATIC_TEXT
249 idzebra_filter_text
250 #else
251 idzebra_filter
252 #endif
253
254 [] = {
255     &filter_type,
256     0,
257 };
258 /*
259  * Local variables:
260  * c-basic-offset: 4
261  * indent-tabs-mode: nil
262  * End:
263  * vim: shiftwidth=4 tabstop=8 expandtab
264  */
265