using yaz/log.h again
[idzebra-moved-to-github.git] / data1 / d1_map.c
1 /* $Id: d1_map.c,v 1.7 2004-12-13 20:51:28 adam Exp $
2    Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002
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 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26
27 #include <yaz/log.h>
28 #include <yaz/oid.h>
29 #include <yaz/readconf.h>
30 #include <yaz/tpath.h>
31 #include <d1_absyn.h>
32
33 data1_maptab *data1_read_maptab (data1_handle dh, const char *file)
34 {
35     NMEM mem = data1_nmem_get (dh);
36     data1_maptab *res = (data1_maptab *)nmem_malloc(mem, sizeof(*res));
37     FILE *f;
38     int lineno = 0;
39     int argc;
40     char *argv[50], line[512];
41     data1_mapunit **mapp;
42     int local_numeric = 0;
43
44     if (!(f = data1_path_fopen(dh, file, "r")))
45     {
46         yaz_log(YLOG_WARN|YLOG_ERRNO, "%s", file);
47         return 0;
48     }
49
50     res->name = 0;
51     res->target_absyn_ref = VAL_NONE;
52     res->map = 0;
53     mapp = &res->map;
54     res->next = 0;
55
56     while ((argc = readconf_line(f, &lineno, line, 512, argv, 50)))
57         if (!strcmp(argv[0], "targetref"))
58         {
59             if (argc != 2)
60             {
61                 yaz_log(YLOG_WARN, "%s:%d: Bad # args for targetref",
62                         file, lineno);
63                 continue;
64             }
65             if ((res->target_absyn_ref = oid_getvalbyname(argv[1]))
66                 == VAL_NONE)
67             {
68                 yaz_log(YLOG_WARN, "%s:%d: Unknown reference '%s'",
69                         file, lineno, argv[1]);
70                 continue;
71             }
72         }
73         else if (!strcmp(argv[0], "targetname"))
74         {
75             if (argc != 2)
76             {
77                 yaz_log(YLOG_WARN, "%s:%d: Bad # args for targetname",
78                         file, lineno);
79                 continue;
80             }
81             res->target_absyn_name =
82                 (char *)nmem_malloc(mem, strlen(argv[1])+1);
83             strcpy(res->target_absyn_name, argv[1]);
84         }
85         else if (!yaz_matchstr(argv[0], "localnumeric"))
86             local_numeric = 1;
87         else if (!strcmp(argv[0], "name"))
88         {
89             if (argc != 2)
90             {
91                 yaz_log(YLOG_WARN, "%s:%d: Bad # args for name", file, lineno);
92                 continue;
93             }
94             res->name = (char *)nmem_malloc(mem, strlen(argv[1])+1);
95             strcpy(res->name, argv[1]);
96         }
97         else if (!strcmp(argv[0], "map"))
98         {
99             data1_maptag **mtp;
100             char *ep, *path = argv[2];
101
102             if (argc < 3)
103             {
104                 yaz_log(YLOG_WARN, "%s:%d: Bad # of args for map",
105                         file, lineno);
106                 continue;
107             }
108             *mapp = (data1_mapunit *)nmem_malloc(mem, sizeof(**mapp));
109             (*mapp)->next = 0;
110             if (argc > 3 && !data1_matchstr(argv[3], "nodata"))
111                 (*mapp)->no_data = 1;
112             else
113                 (*mapp)->no_data = 0;
114             (*mapp)->source_element_name =
115                 (char *)nmem_malloc(mem, strlen(argv[1])+1);
116             strcpy((*mapp)->source_element_name, argv[1]);
117             mtp = &(*mapp)->target_path;
118             if (*path == '/')
119                 path++;
120             for (ep = strchr(path, '/'); path; (void)((path = ep) &&
121                 (ep = strchr(path, '/'))))
122             {
123                 int type, np;
124                 char valstr[512], parm[512];
125
126                 if (ep)
127                     ep++;
128                 if ((np = sscanf(path, "(%d,%511[^)]):%511[^/]", &type, valstr,
129                     parm)) < 2)
130                 {
131                     yaz_log(YLOG_WARN, "%s:%d: Syntax error in map "
132                             "directive: %s", file, lineno, argv[2]);
133                     fclose(f);
134                     return 0;
135                 }
136                 *mtp = (data1_maptag *)nmem_malloc(mem, sizeof(**mtp));
137                 (*mtp)->next = 0;
138                 (*mtp)->type = type;
139                 if (np > 2 && !data1_matchstr(parm, "new"))
140                     (*mtp)->new_field = 1;
141                 else
142                     (*mtp)->new_field = 0;
143                 if ((type != 3 || local_numeric) && d1_isdigit(*valstr))
144                 {
145                     (*mtp)->which = D1_MAPTAG_numeric;
146                     (*mtp)->value.numeric = atoi(valstr);
147                 }
148                 else
149                 {
150                     (*mtp)->which = D1_MAPTAG_string;
151                     (*mtp)->value.string =
152                         (char *)nmem_malloc(mem, strlen(valstr)+1);
153                     strcpy((*mtp)->value.string, valstr);
154                 }
155                 mtp = &(*mtp)->next;
156             }
157             mapp = &(*mapp)->next;
158         }
159         else 
160             yaz_log(YLOG_WARN, "%s:%d: Unknown directive '%s'",
161                     file, lineno, argv[0]);
162
163     fclose(f);
164     return res;
165 }
166
167 /*
168  * Locate node with given elementname.
169  * NOTE: This is stupid - we don't find repeats this way.
170  */
171 static data1_node *find_node(data1_node *p, char *elementname)
172 {
173     data1_node *c, *r;
174
175     for (c = p->child; c; c = c->next)
176         if (c->which == DATA1N_tag && c->u.tag.element &&
177             !data1_matchstr(c->u.tag.element->name, elementname))
178             return c;
179         else if ((r = find_node(c, elementname)))
180             return r;
181     return 0;
182 }
183
184 /*
185  * See if the node n is equivalent to the tag t.
186  */
187 static int tagmatch(data1_node *n, data1_maptag *t)
188 {
189     if (n->which != DATA1N_tag)
190         return 0;
191     if (n->u.tag.element)
192     {
193         if (n->u.tag.element->tag->tagset)
194         {
195             if (n->u.tag.element->tag->tagset->type != t->type)
196                 return 0;
197         }
198         else if (t->type != 3)
199             return 0;
200         if (n->u.tag.element->tag->which == DATA1T_numeric)
201         {
202             if (t->which != D1_MAPTAG_numeric)
203                 return 0;
204             if (n->u.tag.element->tag->value.numeric != t->value.numeric)
205                 return 0;
206         }
207         else
208         {
209             if (t->which != D1_MAPTAG_string)
210                 return 0;
211             if (data1_matchstr(n->u.tag.element->tag->value.string,
212                 t->value.string))
213                 return 0;
214         }
215     }
216     else /* local tag */
217     {
218         char str[10];
219
220         if (t->type != 3)
221             return 0;
222         if (t->which == D1_MAPTAG_numeric)
223             sprintf(str, "%d", t->value.numeric);
224         else
225             strcpy(str, t->value.string);
226         if (data1_matchstr(n->u.tag.tag, str))
227             return 0;
228     }
229     return 1;
230 }
231
232 static data1_node *dup_child (data1_handle dh, data1_node *n,
233                               data1_node **last, NMEM mem,
234                               data1_node *parent)
235 {
236     data1_node *first = 0;
237     data1_node **m = &first;
238
239     for (; n; n = n->next)
240     {
241         *last = *m = (data1_node *) nmem_malloc (mem, sizeof(**m));
242         memcpy (*m, n, sizeof(**m));
243         
244         (*m)->parent = parent;
245         (*m)->root = parent->root;
246         (*m)->child = dup_child(dh, n->child, &(*m)->last_child, mem, *m);
247         m = &(*m)->next;
248     }
249     *m = 0;
250     return first;
251 }
252
253 static int map_children(data1_handle dh, data1_node *n, data1_maptab *map,
254                         data1_node *res, NMEM mem)
255 {
256     data1_node *c;
257     data1_mapunit *m;
258     /*
259      * locate each source element in turn.
260      */
261     for (c = n->child; c; c = c->next)
262         if (c->which == DATA1N_tag && c->u.tag.element)
263         {
264             for (m = map->map; m; m = m->next)
265             {
266                 if (!data1_matchstr(m->source_element_name,
267                     c->u.tag.element->name))
268                 {
269                     data1_node *pn = res;
270                     data1_node *cur = pn->last_child;
271                     data1_maptag *mt;
272
273                     /*
274                      * process the target path specification.
275                      */
276                     for (mt = m->target_path; mt; mt = mt->next)
277                     {
278                         if (!cur || mt->new_field || !tagmatch(cur, mt))
279                         {
280                             if (mt->which == D1_MAPTAG_string)
281                             {
282                                 cur = data1_mk_node2 (dh, mem, DATA1N_tag, pn);
283                                 cur->u.tag.tag = mt->value.string;
284                             }
285                             else if (mt->which == D1_MAPTAG_numeric)
286                             {
287                                 data1_tag *tag =
288                                     data1_gettagbynum(
289                                         dh,
290                                         pn->root->u.root.absyn->tagset,
291                                         mt->type,
292                                         mt->value.numeric);
293
294                                 if (tag && tag->names->name)
295                                 {
296                                     cur = data1_mk_tag (
297                                         dh, mem, tag->names->name, 0, pn);
298                                     
299                                 }
300                             }
301                         }
302                         
303                         if (mt->next)
304                             pn = cur;
305                         else if (!m->no_data)
306                         {
307                             cur->child =
308                                 dup_child (dh, c->child,
309                                            &cur->last_child, mem, cur);
310                         }
311                     }
312                 }
313             }
314             if (map_children(dh, c, map, res, mem) < 0)
315                 return -1;
316         }
317     return 0;
318 }
319
320 /*
321  * Create a (possibly lossy) copy of the given record based on the
322  * table. The new copy will refer back to the data of the original record,
323  * which should not be discarded during the lifetime of the copy.
324  */
325 data1_node *data1_map_record (data1_handle dh, data1_node *n,
326                               data1_maptab *map, NMEM m)
327 {
328     data1_node *res1, *res = data1_mk_node2 (dh, m, DATA1N_root, 0);
329
330     res->which = DATA1N_root;
331     res->u.root.type = map->target_absyn_name;
332     if (!(res->u.root.absyn = data1_get_absyn(dh, map->target_absyn_name)))
333     {
334         yaz_log(YLOG_WARN, "%s: Failed to load target absyn '%s'",
335                 map->name, map->target_absyn_name);
336     }
337     if (data1_is_xmlmode(dh))
338     {
339         n = n->child;
340         if (!n)
341             return 0;
342         res1 = data1_mk_tag (dh, m, map->target_absyn_name, 0, res);
343     }
344     else
345         res1 = res;
346
347     if (map_children(dh, n, map, res1, m) < 0)
348     {
349         data1_free_tree(dh, res);
350         return 0;
351     }
352     return res;
353 }
354