Happy new year
[idzebra-moved-to-github.git] / index / marcomp.c
1 /* This file is part of the Zebra server.
2    Copyright (C) 1994-2009 Index Data
3
4 Zebra 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 Zebra 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 #include <stdio.h>
21 #include <stdlib.h>
22 #include <string.h>
23 #include <ctype.h>
24
25 #include <yaz/yaz-util.h>
26
27 #include "marcomp.h"
28
29 static mc_token mc_gettoken(mc_context *c);
30 static void mc_ungettoken(mc_context *c);
31 static int mc_getval(mc_context *c);
32 static int mc_getdata(mc_context *c, char *s, int sz);
33 static void mc_getinterval(mc_context *c, int *start, int *end);
34
35 static mc_subfield *mc_mk_subfield(mc_subfield *parent);
36 static mc_field *mc_mk_field(void);
37
38 static struct mc_errmsg
39 {
40     mc_errcode code;
41     const char *msg;
42 } mc_errmsg[] = {
43 {EMCOK, "OK"},
44 {EMCNOMEM, "NO mem"},
45 {EMCF, "not complete field"},
46 {EMCSF, "not complete subfield"},
47 {EMCSFGROUP, "not closed GROUP"},
48 {EMCSFVAR, "not closed VARIANT"},
49 {EMCSFINLINE, "not closed IN-LINE"},
50 {EMCEND, "not correct errno"}
51 };
52 mc_errcode mc_errno(mc_context *c)
53 {
54     return c->errcode;
55 }
56 const char *mc_error(mc_errcode no)
57 {
58     if (no >= EMCOK && no<EMCEND)
59         return mc_errmsg[no].msg;
60     else
61         return mc_errmsg[EMCEND].msg;
62 }
63 mc_context *mc_mk_context(const char *s)
64 {
65     mc_context *p=0;
66     
67     if (s && strlen(s))
68     {
69         p = (mc_context*) xmalloc(sizeof(*p));
70         
71         if (!p)
72             return 0;
73         
74         memset(p, 0, sizeof(*p));
75         p->errcode = EMCOK;
76         p->data = s;
77         p->len = strlen(s);
78         p->crrtok = NOP;
79     }
80     
81     return p;
82 }
83 void mc_destroy_context(mc_context *c)
84 {
85     if (c) xfree(c);
86 }
87 mc_token mc_gettoken(mc_context *c)
88 {
89     if (c->offset >= c->len)
90         return NOP;
91
92     switch (*(c->data+c->offset))
93     {
94         case '{': c->crrtok = LVARIANT; break;
95         case '}': c->crrtok = RVARIANT; break;
96         case '(': c->crrtok = LGROUP; break;
97         case ')': c->crrtok = RGROUP; break;
98         case '<': c->crrtok = LINLINE; break;
99         case '>': c->crrtok = RINLINE; break;
100         case '$': c->crrtok = SUBFIELD; break;
101         case '[': c->crrtok = LINTERVAL; break;
102         case ']': c->crrtok = RINTERVAL; break;
103         default:
104             if (isspace(*(unsigned char *) (c->data+c->offset)) 
105                             || *(c->data+c->offset) == '\n')
106             {
107                 c->crrtok = NOP;
108             }
109             else
110             {
111                 c->crrtok = REGULAR;
112                 c->crrval = *(c->data+c->offset);
113             }
114     }
115 #ifdef DEBUG
116     fprintf(stderr, "gettoken(): offset: %d", c->offset);
117     if (c->crrtok == REGULAR)
118         fprintf(stderr, "<%c>", c->crrval);
119     fprintf(stderr, "\n");
120 #endif
121     c->offset++;
122     return c->crrtok;
123 }
124 void mc_ungettoken(mc_context *c)
125 {
126     if (c->offset > 0)
127         c->offset--;
128 }
129 int mc_getval(mc_context *c)
130 {
131     return c->crrval;
132 }
133 int mc_getdata(mc_context *c, char *s, int sz)
134 {
135     int i;
136     
137     for (i=0; i<sz; i++)
138     {
139         if (mc_gettoken(c)!=REGULAR)
140         {
141             mc_ungettoken(c);
142             break;
143         }
144         s[i] = mc_getval(c);
145     }
146     s[i] = '\0';
147     
148     return i;
149 }
150 void mc_getinterval(mc_context *c, int *start, int *end)
151 {
152     char buf[6+1];
153     int start_pos, end_pos;
154     
155     start_pos = end_pos = -1;
156        
157     if (mc_gettoken(c) == LINTERVAL)
158     {
159         int i;
160         
161         for (i=0;i<6;i++)
162         {
163             mc_token tok = mc_gettoken(c);
164             
165             if (tok == RINTERVAL || tok == NOP)
166                 break;
167                 
168             buf[i] = mc_getval(c);
169         }
170         
171         buf[i] = '\0';
172         i = sscanf(buf, "%d-%d", &start_pos, &end_pos);
173         
174         if (i == 1)
175             end_pos = start_pos;
176         else if ( i == 0)
177         {
178             start_pos = 0;
179         }
180     }
181     *start = start_pos;
182     *end = end_pos;
183 }
184 mc_field *mc_mk_field(void)
185 {
186     mc_field *p = (mc_field *)xmalloc(sizeof(*p));
187
188     if (p)
189     {
190         memset(p, 0, sizeof(*p));
191         p->name = (char *)xmalloc(SZ_FNAME+1);
192         *p->name = '\0';
193         p->ind1 = (char *)xmalloc(SZ_IND+1);
194         *p->ind1 = '\0';
195         p->ind2 = (char *)xmalloc(SZ_IND+1);
196         *p->ind2 = '\0';
197         p->interval.start = p->interval.end = -1;
198     }
199     return p;
200 }    
201 void mc_destroy_field(mc_field *p)
202 {
203     if (!p)
204         return;
205     if (p->name) xfree(p->name);     
206     if (p->ind1) xfree(p->ind1);     
207     if (p->ind2) xfree(p->ind2);
208     if (p->list) mc_destroy_subfields_recursive(p->list);
209     xfree(p);
210 }
211 mc_field *mc_getfield(mc_context *c)
212 {
213     mc_field *pf;
214
215     pf = mc_mk_field();
216     
217     if (!pf)
218     {
219         c->errcode = EMCNOMEM;
220         return 0;
221     }
222
223     if (mc_getdata(c, pf->name, SZ_FNAME) == SZ_FNAME)
224     {
225         mc_token nexttok = mc_gettoken(c);
226         
227         mc_ungettoken(c);
228         
229         if (nexttok == LINTERVAL)
230         {
231             mc_getinterval(c, &pf->interval.start, &pf->interval.end);
232 #ifdef DEBUG
233             fprintf(stderr, "ineterval (%d)-(%d)\n", pf->interval.start,
234                 pf->interval.end);
235 #endif
236         }
237         
238         if ((mc_getdata(c, pf->ind1, SZ_IND) == SZ_IND) &&
239             (mc_getdata(c, pf->ind2, SZ_IND) == SZ_IND))
240         {
241             pf->list = mc_getsubfields(c, 0);
242         }
243     }
244     else
245     {
246         c->errcode = EMCF;
247         mc_destroy_field(pf);
248         return 0;
249     }
250         
251     return pf;
252 }
253 mc_subfield *mc_mk_subfield(mc_subfield *parent)
254 {
255     mc_subfield *p = (mc_subfield*)xmalloc(sizeof(*p));
256
257     if (p)
258     {
259         memset(p, 0, sizeof(*p));
260         p->which = MC_SF;
261         p->name = (char *)xmalloc(SZ_SFNAME+1);
262         *p->name = '\0';
263         p->prefix = (char *)xmalloc(SZ_PREFIX+1);
264         *p->prefix = '\0';
265         p->suffix = (char *)xmalloc(SZ_SUFFIX+1);
266         *p->suffix = '\0';
267         p->parent = parent;
268         p->interval.start = p->interval.end = -1;
269     }
270     return p;
271 }
272 void mc_destroy_subfield(mc_subfield *p)
273 {
274     if (!p)
275         return;
276     
277     if (p->which == MC_SFGROUP || p->which == MC_SFVARIANT)
278     {
279         if (p->u.child)
280             mc_destroy_subfields_recursive(p->u.child);
281     }
282     else if (p->which == MC_SF)
283     {
284         if (p->u.in_line)
285             mc_destroy_field(p->u.in_line);
286     }
287     if (p->name) xfree(p->name);     
288     if (p->prefix) xfree(p->prefix);     
289     if (p->suffix) xfree(p->suffix);
290     if (p->parent) p->parent->next = p->next;
291     xfree(p);
292 }
293 void mc_destroy_subfields_recursive(mc_subfield *p)
294 {
295     if (!p)
296         return;
297
298     mc_destroy_subfields_recursive(p->next);
299         
300     if (p->which == MC_SFGROUP || p->which == MC_SFVARIANT)
301     {
302         if (p->u.child)
303             mc_destroy_subfields_recursive(p->u.child);
304     }
305     else if (p->which == MC_SF)
306     {
307         if (p->u.in_line)
308             mc_destroy_field(p->u.in_line);
309     }
310         
311     if (p->name) xfree(p->name);
312     if (p->prefix) xfree(p->prefix);
313     if (p->suffix) xfree(p->suffix);
314     if (p->parent) p->parent->next = 0;
315     xfree(p);
316 }
317 mc_subfield *mc_getsubfields(mc_context *c, mc_subfield *parent)
318 {
319     mc_subfield *psf=0;
320     mc_token tok = mc_gettoken(c);
321     
322     if (tok == NOP)
323         return 0;
324         
325     if (tok == LGROUP)
326     {
327         if (!(psf = mc_mk_subfield(parent)))
328         {
329             c->errcode = EMCNOMEM;
330             return 0;
331         }
332
333         psf->which = MC_SFGROUP;
334         psf->u.child = mc_getsubfields(c, psf);
335         
336         if (mc_gettoken(c) == RGROUP)
337             psf->next = mc_getsubfields(c, psf);
338         else
339         {
340             c->errcode = EMCSFGROUP;
341             mc_destroy_subfield(psf);
342             return 0;
343         }
344     }
345     else if (tok == LVARIANT)
346     {
347         if (!(psf = mc_mk_subfield(parent)))
348         {
349             c->errcode = EMCNOMEM;
350             return 0;
351         }
352
353         psf->which = MC_SFVARIANT;
354         psf->u.child = mc_getsubfields(c, psf);
355         
356         if (mc_gettoken(c) == RVARIANT)
357             psf->next = mc_getsubfields(c, psf);
358         else
359         {
360             c->errcode = EMCSFVAR;
361             mc_destroy_subfield(psf);
362             return 0;
363         }
364     }
365     else if (tok == RGROUP || tok == RVARIANT || tok == RINLINE)
366     {
367         mc_ungettoken(c);
368         return 0;
369     }
370     else if (tok == REGULAR)
371     {
372         if (!(psf = mc_mk_subfield(parent)))
373         {
374             c->errcode = EMCNOMEM;
375             return 0;
376         }
377
378         mc_ungettoken(c);
379
380         if((mc_getdata(c, psf->prefix, SZ_PREFIX) == SZ_PREFIX) &&
381             (mc_gettoken(c) == SUBFIELD) &&
382                 (mc_getdata(c, psf->name, SZ_SFNAME) == SZ_SFNAME))
383         {
384             mc_token tok = mc_gettoken(c);
385
386             mc_ungettoken(c);
387             
388             if (tok == LINTERVAL)
389             {
390                 mc_getinterval(c, &psf->interval.start, &psf->interval.end);
391             }
392             else if (tok == LINLINE)
393             {
394                 mc_gettoken(c);
395                 psf->u.in_line = mc_getfield(c);
396                 if (mc_gettoken(c) != RINLINE)
397                 {
398                     c->errcode = EMCSFINLINE;
399                     mc_destroy_subfield(psf);
400                     return 0;
401                 }
402             }
403         
404             if (mc_getdata(c, psf->suffix, SZ_SUFFIX) == SZ_SUFFIX)
405             {
406                 psf->which = MC_SF;
407                 psf->next = mc_getsubfields(c, psf);
408             }
409             else
410             {
411                 c->errcode = EMCSF;
412                 mc_destroy_subfield(psf);
413                 return 0;
414             }
415         }
416     }     
417     return psf;
418 }
419 /*
420  * Local variables:
421  * c-basic-offset: 4
422  * indent-tabs-mode: nil
423  * End:
424  * vim: shiftwidth=4 tabstop=8 expandtab
425  */
426