data1/d1_read.c

   1 /* $Id: d1_read.c,v 1.14 2005-01-15 19:38:18 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 /*
  25  * This module reads "loose" SGML and converts it to data1 tree
  26  */
  27
  28 #include <assert.h>
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31
  32 #include <yaz/yaz-util.h>
  33 #include <d1_absyn.h>
  34
  35 data1_node *data1_get_root_tag (data1_handle dh, data1_node *n)
  36 {
  37     if (!n)
  38         return 0;
  39     if (data1_is_xmlmode(dh))
  40     {
  41         n = n->child;
  42         while (n && n->which != DATA1N_tag)
  43             n = n->next;
  44     }
  45     return n;
  46 }
  47
  48 /*
  49  * get the tag which is the immediate parent of this node (this may mean
  50  * traversing intermediate things like variants and stuff.
  51  */
  52 data1_node *get_parent_tag (data1_handle dh, data1_node *n)
  53 {
  54     if (data1_is_xmlmode(dh))
  55     {
  56         for (; n && n->which != DATA1N_root; n = n->parent)
  57             if (n->which == DATA1N_tag && n->parent &&
  58                 n->parent->which != DATA1N_root)
  59                 return n;
  60     }
  61     else
  62     {
  63         for (; n && n->which != DATA1N_root; n = n->parent)
  64             if (n->which == DATA1N_tag)
  65                 return n;
  66     }
  67     return 0;
  68 }
  69
  70 data1_node *data1_mk_node (data1_handle dh, NMEM m)
  71 {
  72     return data1_mk_node2 (dh, m, DATA1N_root, 0);
  73 }
  74
  75 data1_node *data1_mk_node_type (data1_handle dh, NMEM m, int type)
  76 {
  77     return data1_mk_node2 (dh, m, type, 0);
  78 }
  79
  80 static void data1_init_node (data1_handle dh, data1_node *r, int type)
  81 {
  82     r->which = type;
  83     switch(type)
  84     {
  85     case DATA1N_tag:
  86         r->u.tag.tag = 0;
  87         r->u.tag.element = 0;
  88         r->u.tag.no_data_requested = 0;
  89         r->u.tag.node_selected = 0;
  90         r->u.tag.make_variantlist = 0;
  91         r->u.tag.get_bytes = -1;
  92         r->u.tag.attributes = 0;
  93         break;
  94     case DATA1N_root:
  95         r->u.root.type = 0;
  96         r->u.root.absyn = 0;
  97         break;
  98     case DATA1N_data:
  99         r->u.data.data = 0;
 100         r->u.data.len = 0;
 101         r->u.data.what = 0;
 102         r->u.data.formatted_text = 0;
 103         break;
 104     case DATA1N_comment:
 105         r->u.data.data = 0;
 106         r->u.data.len = 0;
 107         r->u.data.what = 0;
 108         r->u.data.formatted_text = 1;
 109         break;
 110     case DATA1N_variant:
 111         r->u.variant.type = 0;
 112         r->u.variant.value = 0;
 113         break;
 114     case DATA1N_preprocess:
 115         r->u.preprocess.target = 0;
 116         r->u.preprocess.attributes = 0;
 117         break;
 118     default:
 119         yaz_log (YLOG_WARN, "data_mk_node_type. bad type = %d\n", type);
 120     }
 121 }
 122
 123 data1_node *data1_append_node (data1_handle dh, NMEM m, int type,
 124                                data1_node *parent)
 125 {
 126     data1_node *r = (data1_node *)nmem_malloc(m, sizeof(*r));
 127     r->next = r->child = r->last_child = 0;
 128     r->destroy = 0;
 129
 130     r->parent = parent;
 131     if (!parent)
 132         r->root = r;
 133     else
 134     {
 135         r->root = parent->root;
 136         if (!parent->child)
 137             parent->child = parent->last_child = r;
 138         else
 139             parent->last_child->next = r;
 140         parent->last_child = r;
 141     }
 142     data1_init_node(dh, r, type);
 143     return r;
 144 }
 145
 146 data1_node *data1_mk_node2 (data1_handle dh, NMEM m, int type,
 147                             data1_node *parent)
 148 {
 149     return data1_append_node (dh, m, type, parent);
 150 }
 151
 152 data1_node *data1_insert_node (data1_handle dh, NMEM m, int type,
 153                                data1_node *parent)
 154 {
 155     data1_node *r = (data1_node *)nmem_malloc(m, sizeof(*r));
 156     r->next = r->child = r->last_child = 0;
 157     r->destroy = 0;
 158
 159     if (!parent)
 160         r->root = r;
 161     else
 162     {
 163         r->root = parent->root;
 164         r->parent = parent;
 165         if (!parent->child)
 166             parent->last_child = r;
 167         else
 168             r->next = parent->child;
 169         parent->child = r;
 170     }
 171     data1_init_node(dh, r, type);
 172     return r;
 173 }
 174
 175 void data1_free_tree (data1_handle dh, data1_node *t)
 176 {
 177     data1_node *p = t->child, *pn;
 178
 179     while (p)
 180     {
 181         pn = p->next;
 182         data1_free_tree (dh, p);
 183         p = pn;
 184     }
 185     if (t->destroy)
 186         (*t->destroy)(t);
 187 }
 188
 189 data1_node *data1_mk_root (data1_handle dh, NMEM nmem, const char *name)
 190 {
 191     data1_absyn *absyn = data1_get_absyn (dh, name);
 192     data1_node *res;
 193     if (!absyn)
 194     {
 195         yaz_log(YLOG_WARN, "Unable to acquire abstract syntax " "for '%s'",
 196                 name);
 197         /* It's now OK for a record not to have an absyn */
 198     }
 199     res = data1_mk_node2 (dh, nmem, DATA1N_root, 0);
 200     res->u.root.type = data1_insert_string (dh, res, nmem, name);
 201     res->u.root.absyn = absyn;
 202     return res;
 203 }
 204
 205 void data1_set_root(data1_handle dh, data1_node *res,
 206                     NMEM nmem, const char *name)
 207 {
 208     data1_absyn *absyn = data1_get_absyn (dh, name);
 209
 210     res->u.root.type = data1_insert_string (dh, res, nmem, name);
 211     res->u.root.absyn = absyn;
 212 }
 213
 214 void data1_add_attrs(data1_handle dh, NMEM nmem, const char **attr,
 215                      data1_xattr **p)
 216 {
 217     while (*p)
 218         p = &(*p)->next;
 219
 220     while (attr && *attr)
 221     {
 222         *p = (data1_xattr*) nmem_malloc (nmem, sizeof(**p));
 223         (*p)->name = nmem_strdup (nmem, *attr++);
 224         (*p)->value = nmem_strdup (nmem, *attr++);
 225         (*p)->what = DATA1I_text;
 226
 227         p = &(*p)->next;
 228     }
 229     *p = 0;
 230 }
 231
 232 data1_node *data1_mk_preprocess (data1_handle dh, NMEM nmem,
 233                                  const char *target,
 234                                  const char **attr, data1_node *at)
 235 {
 236     return data1_mk_preprocess_n (dh, nmem, target, strlen(target),
 237                                   attr, at);
 238 }
 239
 240 data1_node *data1_mk_preprocess_n (data1_handle dh, NMEM nmem,
 241                                    const char *target, size_t len,
 242                                    const char **attr, data1_node *at)
 243 {
 244     data1_node *res = data1_mk_node2 (dh, nmem, DATA1N_preprocess, at);
 245     res->u.preprocess.target = data1_insert_string_n (dh, res, nmem,
 246                                                       target, len);
 247
 248     data1_add_attrs(dh, nmem, attr, &res->u.preprocess.attributes);
 249     return res;
 250 }
 251
 252 data1_node *data1_insert_preprocess (data1_handle dh, NMEM nmem,
 253                                  const char *target,
 254                                  const char **attr, data1_node *at)
 255 {
 256     return data1_insert_preprocess_n (dh, nmem, target, strlen(target),
 257                                       attr, at);
 258 }
 259
 260 data1_node *data1_insert_preprocess_n (data1_handle dh, NMEM nmem,
 261                                    const char *target, size_t len,
 262                                    const char **attr, data1_node *at)
 263 {
 264     data1_node *res = data1_insert_node (dh, nmem, DATA1N_preprocess, at);
 265     res->u.preprocess.target = data1_insert_string_n (dh, res, nmem,
 266                                                       target, len);
 267
 268     data1_add_attrs(dh, nmem, attr, &res->u.preprocess.attributes);
 269     return res;
 270 }
 271
 272 data1_node *data1_mk_tag_n (data1_handle dh, NMEM nmem,
 273                             const char *tag, size_t len, const char **attr,
 274                             data1_node *at)
 275 {
 276     data1_node *partag = get_parent_tag(dh, at);
 277     data1_node *res = data1_mk_node2 (dh, nmem, DATA1N_tag, at);
 278     data1_element *e = 0;
 279
 280     res->u.tag.tag = data1_insert_string_n (dh, res, nmem, tag, len);
 281
 282     if (!partag)  /* top tag? */
 283         e  = data1_getelementbytagname (dh, at->root->u.root.absyn,
 284                                         0 /* index as local */,
 285                                         res->u.tag.tag);
 286     else
 287     {
 288         /* only set element for known tags */
 289         e = partag->u.tag.element;
 290         if (e)
 291             e = data1_getelementbytagname (dh, at->root->u.root.absyn,
 292                                            e, res->u.tag.tag);
 293     }
 294     res->u.tag.element = e;
 295     data1_add_attrs(dh, nmem, attr, &res->u.tag.attributes);
 296     return res;
 297 }
 298
 299 void data1_tag_add_attr (data1_handle dh, NMEM nmem,
 300                          data1_node *res, const char **attr)
 301 {
 302     if (res->which != DATA1N_tag)
 303         return;
 304
 305     data1_add_attrs(dh, nmem, attr, &res->u.tag.attributes);
 306 }
 307
 308 data1_node *data1_mk_tag (data1_handle dh, NMEM nmem,
 309                           const char *tag, const char **attr, data1_node *at)
 310 {
 311     return data1_mk_tag_n (dh, nmem, tag, strlen(tag), attr, at);
 312 }
 313
 314 data1_node *data1_search_tag (data1_handle dh, data1_node *n,
 315                               const char *tag)
 316 {
 317     if (*tag == '/')
 318     {
 319         n = data1_get_root_tag (dh, n);
 320         if (n)
 321             n = n->child;
 322         tag++;
 323     }
 324     for (; n; n = n->next)
 325         if (n->which == DATA1N_tag && n->u.tag.tag &&
 326             !yaz_matchstr (n->u.tag.tag, tag))
 327         {
 328             return n;
 329         }
 330     return 0;
 331 }
 332
 333 data1_node *data1_mk_tag_uni (data1_handle dh, NMEM nmem,
 334                               const char *tag, data1_node *at)
 335 {
 336     data1_node *node = data1_search_tag (dh, at->child, tag);
 337     if (!node)
 338         node = data1_mk_tag (dh, nmem, tag, 0 /* attr */, at);
 339     else
 340         node->child = node->last_child = 0;
 341     return node;
 342 }
 343
 344 data1_node *data1_mk_text_n (data1_handle dh, NMEM mem,
 345                              const char *buf, size_t len, data1_node *parent)
 346 {
 347     data1_node *res = data1_mk_node2 (dh, mem, DATA1N_data, parent);
 348     res->u.data.what = DATA1I_text;
 349     res->u.data.len = len;
 350
 351     res->u.data.data = data1_insert_string_n (dh, res, mem, buf, len);
 352     return res;
 353 }
 354
 355 data1_node *data1_mk_text_nf (data1_handle dh, NMEM mem,
 356                               const char *buf, size_t len, data1_node *parent)
 357 {
 358     data1_node *res = data1_mk_text_n (dh, mem, buf, len, parent);
 359     res->u.data.formatted_text = 1;
 360     return res;
 361 }
 362
 363 data1_node *data1_mk_text (data1_handle dh, NMEM mem,
 364                            const char *buf, data1_node *parent)
 365 {
 366     return data1_mk_text_n (dh, mem, buf, strlen(buf), parent);
 367 }
 368
 369 data1_node *data1_mk_comment_n (data1_handle dh, NMEM mem,
 370                                 const char *buf, size_t len,
 371                                 data1_node *parent)
 372 {
 373     data1_node *res = data1_mk_node2 (dh, mem, DATA1N_comment, parent);
 374     res->u.data.what = DATA1I_text;
 375     res->u.data.len = len;
 376
 377     res->u.data.data = data1_insert_string_n (dh, res, mem, buf, len);
 378     return res;
 379 }
 380
 381 data1_node *data1_mk_comment (data1_handle dh, NMEM mem,
 382                               const char *buf, data1_node *parent)
 383 {
 384     return data1_mk_comment_n (dh, mem, buf, strlen(buf), parent);
 385 }
 386
 387 char *data1_insert_string_n (data1_handle dh, data1_node *res,
 388                              NMEM m, const char *str, size_t len)
 389 {
 390     char *b;
 391     if (len >= DATA1_LOCALDATA)
 392         b = (char *) nmem_malloc (m, len+1);
 393     else
 394         b = res->lbuf;
 395     memcpy (b, str, len);
 396     b[len] = 0;
 397     return b;
 398 }
 399
 400 char *data1_insert_string (data1_handle dh, data1_node *res,
 401                            NMEM m, const char *str)
 402 {
 403     return data1_insert_string_n (dh, res, m, str, strlen(str));
 404 }
 405
 406 static data1_node *data1_add_insert_taggeddata(data1_handle dh,
 407                                                data1_node *at,
 408                                                const char *tagname, NMEM m,
 409                                                int local_allowed,
 410                                                int insert_mode)
 411 {
 412     data1_node *root = at->root;
 413     data1_node *partag = get_parent_tag (dh, at);
 414     data1_element *e = NULL;
 415     data1_node *datn = 0;
 416     data1_node *tagn = 0;
 417
 418     if (!partag)
 419         e = data1_getelementbytagname (dh, root->u.root.absyn, 0, tagname);
 420     else
 421     {
 422         e = partag->u.tag.element;
 423         if (e)
 424             e = data1_getelementbytagname (dh, root->u.root.absyn, e, tagname);
 425     }
 426     if (local_allowed || e)
 427     {
 428         if (insert_mode)
 429             tagn = data1_insert_node (dh, m, DATA1N_tag, at);
 430         else
 431             tagn = data1_append_node (dh, m, DATA1N_tag, at);
 432         tagn->u.tag.tag = data1_insert_string (dh, tagn, m, tagname);
 433         tagn->u.tag.element = e;
 434         datn = data1_mk_node2 (dh, m, DATA1N_data, tagn);
 435     }
 436     return datn;
 437 }
 438
 439 data1_node *data1_mk_tag_data(data1_handle dh, data1_node *at,
 440                               const char *tagname, NMEM m)
 441 {
 442     return data1_add_insert_taggeddata (dh, at, tagname, m, 1, 0);
 443 }
 444
 445
 446 /*
 447  * Insert a tagged node into the record root as first child of the node at
 448  * which should be root or tag itself). Returns pointer to the data node,
 449  * which can then be modified.
 450  */
 451 data1_node *data1_mk_tag_data_wd(data1_handle dh, data1_node *at,
 452                                  const char *tagname, NMEM m)
 453 {
 454     return data1_add_insert_taggeddata (dh, at, tagname, m, 0, 1);
 455 }
 456
 457 data1_node *data1_insert_taggeddata (data1_handle dh, data1_node *root,
 458                                      data1_node *at, const char *tagname,
 459                                      NMEM m)
 460 {
 461     return data1_add_insert_taggeddata (dh, at, tagname, m, 0, 1);
 462 }
 463
 464 data1_node *data1_add_taggeddata (data1_handle dh, data1_node *root,
 465                                   data1_node *at, const char *tagname,
 466                                   NMEM m)
 467 {
 468     return data1_add_insert_taggeddata (dh, at, tagname, m, 1, 0);
 469 }
 470
 471 data1_node *data1_mk_tag_data_zint (data1_handle dh, data1_node *at,
 472                                    const char *tag, zint num,
 473                                    NMEM nmem)
 474 {
 475     data1_node *node_data;
 476
 477     node_data = data1_mk_tag_data (dh, at, tag, nmem);
 478     if (!node_data)
 479         return 0;
 480     node_data->u.data.what = DATA1I_num;
 481     node_data->u.data.data = node_data->lbuf;
 482     sprintf (node_data->u.data.data, ZINT_FORMAT, num);
 483     node_data->u.data.len = strlen (node_data->u.data.data);
 484     return node_data;
 485 }
 486
 487 data1_node *data1_mk_tag_data_int (data1_handle dh, data1_node *at,
 488                                    const char *tag, int num,
 489                                    NMEM nmem)
 490 {
 491     return data1_mk_tag_data_zint(dh, at, tag, num, nmem);
 492 }
 493
 494 data1_node *data1_mk_tag_data_oid (data1_handle dh, data1_node *at,
 495                                    const char *tag, Odr_oid *oid,
 496                                    NMEM nmem)
 497 {
 498     data1_node *node_data;
 499     char str[128], *p = str;
 500     Odr_oid *ii;
 501
 502     node_data = data1_mk_tag_data (dh, at, tag, nmem);
 503     if (!node_data)
 504         return 0;
 505
 506     for (ii = oid; *ii >= 0; ii++)
 507     {
 508         if (ii != oid)
 509             *p++ = '.';
 510         sprintf (p, "%d", *ii);
 511         p += strlen (p);
 512     }
 513     node_data->u.data.what = DATA1I_oid;
 514     node_data->u.data.len = strlen (str);
 515     node_data->u.data.data = data1_insert_string (dh, node_data, nmem, str);
 516     return node_data;
 517 }
 518
 519
 520 data1_node *data1_mk_tag_data_text (data1_handle dh, data1_node *at,
 521                                     const char *tag, const char *str,
 522                                     NMEM nmem)
 523 {
 524     data1_node *node_data;
 525
 526     node_data = data1_mk_tag_data (dh, at, tag, nmem);
 527     if (!node_data)
 528         return 0;
 529     node_data->u.data.what = DATA1I_text;
 530     node_data->u.data.len = strlen (str);
 531     node_data->u.data.data = data1_insert_string (dh, node_data, nmem, str);
 532     return node_data;
 533 }
 534
 535
 536 data1_node *data1_mk_tag_data_text_uni (data1_handle dh, data1_node *at,
 537                                         const char *tag, const char *str,
 538                                         NMEM nmem)
 539 {
 540     data1_node *node = data1_search_tag (dh, at->child, tag);
 541     if (!node)
 542         return data1_mk_tag_data_text (dh, at, tag, str, nmem);
 543     else
 544     {
 545         data1_node *node_data = node->child;
 546         node_data->u.data.what = DATA1I_text;
 547         node_data->u.data.len = strlen (str);
 548         node_data->u.data.data = data1_insert_string (dh, node_data,
 549                                                       nmem, str);
 550         node_data->child = node_data->last_child = 0;
 551         return node_data;
 552     }
 553 }
 554
 555 static int ampr (int (*get_byte)(void *fh), void *fh, int *amp)
 556 {
 557 #if 1
 558     int c = (*get_byte)(fh);
 559     *amp = 0;
 560     return c;
 561 #else
 562     int c = (*get_byte)(fh);
 563     *amp = 0;
 564     if (c == '&')
 565     {
 566         char ent[20];
 567         int i = 0;
 568
 569         while (1)
 570         {
 571             c = (*get_byte)(fh);
 572             if (c == ';')
 573             {
 574                 ent[i] = 0;
 575
 576                 c = ' ';
 577                 if (!strcmp (ent, "quot"))
 578                     c = '"';
 579                 if (!strcmp (ent, "apos"))
 580                     c = '\'';
 581                 if (!strcmp (ent, "gt"))
 582                     c = '>';
 583                 if (!strcmp (ent, "lt"))
 584                     c = '<';
 585                 if (!strcmp (ent, "amp"))
 586                     c = '&';
 587                 *amp = 1;
 588                 break;
 589             }
 590             else if (c == 0 || d1_isspace(c))
 591                 break;
 592             if (i < 19)
 593                 ent[i++] = c;
 594         }
 595     }
 596     return c;
 597 #endif
 598 }
 599
 600 data1_xattr *data1_read_xattr (data1_handle dh, NMEM m,
 601                                int (*get_byte)(void *fh), void *fh,
 602                                WRBUF wrbuf, int *ch, int *amp)
 603 {
 604     data1_xattr *p_first = 0;
 605     data1_xattr **pp = &p_first;
 606     int c = *ch;
 607     for (;;)
 608     {
 609         data1_xattr *p;
 610         int len;
 611         while (*amp || (c && d1_isspace(c)))
 612             c = ampr (get_byte, fh, amp);
 613         if (*amp == 0 && (c == 0 || c == '>' || c == '/'))
 614             break;
 615         *pp = p = (data1_xattr *) nmem_malloc (m, sizeof(*p));
 616         p->next = 0;
 617         pp = &p->next;
 618         p->value = 0;
 619         p->what = DATA1I_xmltext;
 620
 621         wrbuf_rewind(wrbuf);
 622         while (c && c != '=' && c != '>' && c != '/' && !d1_isspace(c))
 623         {
 624             wrbuf_putc (wrbuf, c);
 625             c = ampr (get_byte, fh, amp);
 626         }
 627         wrbuf_putc (wrbuf, '\0');
 628         len = wrbuf_len(wrbuf);
 629         p->name = (char*) nmem_malloc (m, len);
 630         strcpy (p->name, wrbuf_buf(wrbuf));
 631         if (c == '=')
 632         {
 633             c = ampr (get_byte, fh, amp);
 634             if (*amp == 0 && c == '"')
 635             {
 636                 c = ampr (get_byte, fh, amp);
 637                 wrbuf_rewind(wrbuf);
 638                 while (*amp || (c && c != '"'))
 639                 {
 640                     wrbuf_putc (wrbuf, c);
 641                     c = ampr (get_byte, fh, amp);
 642                 }
 643                 if (c)
 644                     c = ampr (get_byte, fh, amp);
 645             }
 646             else if (*amp == 0 && c == '\'')
 647             {
 648                 c = ampr (get_byte, fh, amp);
 649                 wrbuf_rewind(wrbuf);
 650                 while (*amp || (c && c != '\''))
 651                 {
 652                     wrbuf_putc (wrbuf, c);
 653                     c = ampr (get_byte, fh, amp);
 654                 }
 655                 if (c)
 656                     c = ampr (get_byte, fh, amp);
 657             }
 658             else
 659             {
 660                 wrbuf_rewind(wrbuf);
 661                 while (*amp || (c && c != '>' && c != '/'))
 662                 {
 663                     wrbuf_putc (wrbuf, c);
 664                     c = ampr (get_byte, fh, amp);
 665                 }
 666             }
 667             wrbuf_putc (wrbuf, '\0');
 668             len = wrbuf_len(wrbuf);
 669             p->value = (char*) nmem_malloc (m, len);
 670             strcpy (p->value, wrbuf_buf(wrbuf));
 671         }
 672     }
 673     *ch = c;
 674     return p_first;
 675 }
 676
 677 /*
 678  * Ugh. Sometimes functions just grow and grow on you. This one reads a
 679  * 'node' and its children.
 680  */
 681 data1_node *data1_read_nodex (data1_handle dh, NMEM m,
 682                               int (*get_byte)(void *fh), void *fh, WRBUF wrbuf)
 683 {
 684     data1_node *d1_stack[256];
 685     data1_node *res;
 686     int c, amp;
 687     int level = 0;
 688     int line = 1;
 689
 690     d1_stack[level] = 0;
 691     c = ampr (get_byte, fh, &amp);
 692     while (c != '\0')
 693     {
 694         data1_node *parent = level ? d1_stack[level-1] : 0;
 695
 696         if (amp == 0 && c == '<') /* beginning of tag */
 697         {
 698             data1_xattr *xattr;
 699
 700             char tag[64];
 701             char args[256];
 702             int null_tag = 0;
 703             int end_tag = 0;
 704             size_t i = 0;
 705
 706             c = ampr (get_byte, fh, &amp);
 707             if (amp == 0 && c == '/')
 708             {
 709                 end_tag = 1;
 710                 c = ampr (get_byte, fh, &amp);
 711             }
 712             else if (amp == 0 && c == '!')
 713             {
 714                 int c0, amp0;
 715
 716                 wrbuf_rewind(wrbuf);
 717
 718                 c0 = ampr (get_byte, fh, &amp0);
 719                 if (amp0 == 0 && c0 == '\0')
 720                     break;
 721                 c = ampr (get_byte, fh, &amp);
 722
 723                 if (amp0 == 0 && c0 == '-' && amp == 0 && c == '-')
 724                 {
 725                     /* COMMENT: <!-- ... --> */
 726                     int no_dash = 0;
 727
 728                     c = ampr (get_byte, fh, &amp);
 729                     while (amp || c)
 730                     {
 731                         if (amp == 0 && c == '-')
 732                             no_dash++;
 733                         else if (amp == 0 && c == '>' && no_dash >= 2)
 734                         {
 735                             if (level > 0)
 736                                 d1_stack[level] =
 737                                     data1_mk_comment_n (
 738                                         dh, m,
 739                                         wrbuf_buf(wrbuf), wrbuf_len(wrbuf)-2,
 740                                         d1_stack[level-1]);
 741                             c = ampr (get_byte, fh, &amp); /* skip > */
 742                             break;
 743                         }
 744                         else
 745                             no_dash = 0;
 746                         wrbuf_putc (wrbuf, c);
 747                         c = ampr (get_byte, fh, &amp);
 748                     }
 749                     continue;
 750                 }
 751                 else
 752                 {   /* DIRECTIVE: <! .. > */
 753
 754                     int blevel = 0;
 755                     while (amp || c)
 756                     {
 757                         if (amp == 0 && c == '>' && blevel == 0)
 758                         {
 759                             c = ampr (get_byte, fh, &amp);
 760                             break;
 761                         }
 762                         if (amp == 0 && c == '[')
 763                             blevel++;
 764                         if (amp == 0 && c == ']' && blevel > 0)
 765                             blevel--;
 766                         c = ampr (get_byte, fh, &amp);
 767                     }
 768                     continue;
 769                 }
 770             }
 771             while (amp || (c && c != '>' && c != '/' && !d1_isspace(c)))
 772             {
 773                 if (i < (sizeof(tag)-1))
 774                     tag[i++] = c;
 775                 c = ampr (get_byte, fh, &amp);
 776             }
 777             tag[i] = '\0';
 778             xattr = data1_read_xattr (dh, m, get_byte, fh, wrbuf, &c, &amp);
 779             args[0] = '\0';
 780             if (amp == 0 && c == '/')
 781             {    /* <tag attrs/> or <tag/> */
 782                 null_tag = 1;
 783                 c = ampr (get_byte, fh, &amp);
 784             }
 785             if (amp || c != '>')
 786             {
 787                 yaz_log(YLOG_WARN, "d1: %d: Malformed tag", line);
 788                 return 0;
 789             }
 790             else
 791                 c = ampr (get_byte, fh, &amp);
 792
 793             /* End tag? */
 794             if (end_tag)
 795             {
 796                 if (*tag == '\0')
 797                     --level;        /* </> */
 798                 else
 799                 {                   /* </tag> */
 800                     int i = level;
 801                     while (i > 0)
 802                     {
 803                         parent = d1_stack[--i];
 804                         if ((parent->which == DATA1N_root &&
 805                              !strcmp(tag, parent->u.root.type)) ||
 806                             (parent->which == DATA1N_tag &&
 807                              !strcmp(tag, parent->u.tag.tag)))
 808                         {
 809                             level = i;
 810                             break;
 811                         }
 812                     }
 813                     if (i != level)
 814                     {
 815                         yaz_log (YLOG_WARN, "%d: no begin tag for %s",
 816                                  line, tag);
 817                         break;
 818                     }
 819                 }
 820                 if (data1_is_xmlmode(dh))
 821                 {
 822                     if (level <= 1)
 823                         return d1_stack[0];
 824                 }
 825                 else
 826                 {
 827                     if (level <= 0)
 828                         return d1_stack[0];
 829                 }
 830                 continue;
 831             }
 832             else if (!strcmp(tag, "var"))
 833             {
 834                 char tclass[DATA1_MAX_SYMBOL], type[DATA1_MAX_SYMBOL];
 835                 data1_vartype *tp;
 836                 int val_offset;
 837
 838                 if (sscanf(args, "%s %s %n", tclass, type, &val_offset) != 2)
 839                 {
 840                     yaz_log(YLOG_WARN, "Malformed variant triple at '%s'", tag);
 841                     continue;
 842                 }
 843                 if (!(tp =
 844                       data1_getvartypebyct(dh,
 845                                            parent->root->u.root.absyn->varset,
 846                                            tclass, type)))
 847                     continue;
 848                 /*
 849                  * If we're the first variant in this group, create a parent
 850                  * variant, and insert it before the current variant.
 851                  */
 852                 if (parent->which != DATA1N_variant)
 853                 {
 854                     res = data1_mk_node2 (dh, m, DATA1N_variant, parent);
 855                 }
 856                 else
 857                 {
 858                     /*
 859                      * now determine if one of our ancestor triples is of
 860                      * same type. If so, we break here.
 861                      */
 862                     int i;
 863                     for (i = level-1; d1_stack[i]->which==DATA1N_variant; --i)
 864                         if (d1_stack[i]->u.variant.type == tp)
 865                         {
 866                             level = i;
 867                             break;
 868                         }
 869                     res = data1_mk_node2 (dh, m, DATA1N_variant, parent);
 870                     res->u.variant.type = tp;
 871                     res->u.variant.value =
 872                         data1_insert_string (dh, res, m, args + val_offset);
 873                 }
 874             }
 875             else
 876             {
 877
 878                 /* tag .. acquire our element in the abstract syntax */
 879                 if (level == 0)
 880                 {
 881                     parent = data1_mk_root (dh, m, tag);
 882                     res = d1_stack[level] = parent;
 883
 884                     if (data1_is_xmlmode(dh))
 885                     {
 886                         level++;
 887                         res = data1_mk_tag (dh, m, tag, 0 /* attr */, parent);
 888                         res->u.tag.attributes = xattr;
 889                     }
 890                 }
 891                 else
 892                 {
 893                     res = data1_mk_tag (dh, m, tag, 0 /* attr */, parent);
 894                     res->u.tag.attributes = xattr;
 895                 }
 896             }
 897             d1_stack[level] = res;
 898             d1_stack[level+1] = 0;
 899             if (level < 250 && !null_tag)
 900                 ++level;
 901         }
 902         else /* != '<'... this is a body of text */
 903         {
 904             int len;
 905
 906             if (level == 0)
 907             {
 908                 c = ampr (get_byte, fh, &amp);
 909                 continue;
 910             }
 911             res = data1_mk_node2 (dh, m, DATA1N_data, parent);
 912             res->u.data.what = DATA1I_xmltext;
 913             res->u.data.formatted_text = 0;
 914             d1_stack[level] = res;
 915
 916             wrbuf_rewind(wrbuf);
 917
 918             while (amp || (c && c != '<'))
 919             {
 920                 wrbuf_putc (wrbuf, c);
 921                 c = ampr (get_byte, fh, &amp);
 922             }
 923             len = wrbuf_len(wrbuf);
 924
 925             /* use local buffer of nmem if too large */
 926             if (len >= DATA1_LOCALDATA)
 927                 res->u.data.data = (char*) nmem_malloc (m, len);
 928             else
 929                 res->u.data.data = res->lbuf;
 930
 931             if (len)
 932                 memcpy (res->u.data.data, wrbuf_buf(wrbuf), len);
 933             else
 934                 res->u.data.data = 0;
 935             res->u.data.len = len;
 936         }
 937     }
 938     return 0;
 939 }
 940
 941 int getc_mem (void *fh)
 942 {
 943     const char **p = (const char **) fh;
 944     if (**p)
 945         return *(*p)++;
 946     return 0;
 947 }
 948
 949 data1_node *data1_read_node (data1_handle dh, const char **buf, NMEM m)
 950 {
 951     WRBUF wrbuf = wrbuf_alloc();
 952     data1_node *node;
 953
 954     node = data1_read_nodex(dh, m, getc_mem, (void *) (buf), wrbuf);
 955     wrbuf_free (wrbuf, 1);
 956     return node;
 957 }
 958
 959 /*
 960  * Read a record in the native syntax.
 961  */
 962 data1_node *data1_read_record(data1_handle dh,
 963                               int (*rf)(void *, char *, size_t), void *fh,
 964                               NMEM m)
 965 {
 966     int *size;
 967     char **buf = data1_get_read_buf (dh, &size);
 968     const char *bp;
 969     int rd = 0, res;
 970
 971     if (!*buf)
 972         *buf = (char *)xmalloc(*size = 4096);
 973
 974     for (;;)
 975     {
 976         if (rd + 2048 >= *size && !(*buf =(char *)xrealloc(*buf, *size *= 2)))
 977             abort();
 978         if ((res = (*rf)(fh, *buf + rd, 2048)) <= 0)
 979         {
 980             if (!res)
 981             {
 982                 bp = *buf;
 983                 (*buf)[rd] = '\0';
 984                 return data1_read_node(dh, &bp, m);
 985             }
 986             else
 987                 return 0;
 988         }
 989         rd += res;
 990     }
 991 }
 992
 993 data1_node *data1_read_sgml (data1_handle dh, NMEM m, const char *buf)
 994 {
 995     const char *bp = buf;
 996     return data1_read_node (dh, &bp, m);
 997 }
 998
 999
1000 static int conv_item (NMEM m, yaz_iconv_t t,
1001                       WRBUF wrbuf, char *inbuf, size_t inlen)
1002 {
1003     wrbuf_rewind (wrbuf);
1004     if (wrbuf->size < 10)
1005         wrbuf_grow (wrbuf, 10);
1006     for (;;)
1007     {
1008         char *outbuf = wrbuf->buf + wrbuf->pos;
1009         size_t outlen = wrbuf->size - wrbuf->pos;
1010         if (yaz_iconv (t, &inbuf, &inlen, &outbuf, &outlen) ==
1011             (size_t)(-1) && yaz_iconv_error(t) != YAZ_ICONV_E2BIG)
1012         {
1013             /* bad data. stop and skip conversion entirely */
1014             return -1;
1015         }
1016         else if (inlen == 0)
1017         {   /* finished converting */
1018             wrbuf->pos = wrbuf->size - outlen;
1019             break;
1020         }
1021         else
1022         {
1023             /* buffer too small: make sure we expand buffer */
1024             wrbuf->pos = wrbuf->size - outlen;
1025             wrbuf_grow(wrbuf, 20);
1026         }
1027     }
1028     return 0;
1029 }
1030
1031 static void data1_iconv_s (data1_handle dh, NMEM m, data1_node *n,
1032                            yaz_iconv_t t, WRBUF wrbuf, const char *tocode)
1033 {
1034     for (; n; n = n->next)
1035     {
1036         switch (n->which)
1037         {
1038         case DATA1N_data:
1039         case DATA1N_comment:
1040             if (conv_item (m, t, wrbuf, n->u.data.data, n->u.data.len) == 0)
1041             {
1042                 n->u.data.data =
1043                     data1_insert_string_n (dh, n, m, wrbuf->buf,
1044                                            wrbuf->pos);
1045                 n->u.data.len = wrbuf->pos;
1046             }
1047             break;
1048         case DATA1N_tag:
1049             if (conv_item (m, t, wrbuf, n->u.tag.tag, strlen(n->u.tag.tag))
1050                 == 0)
1051             {
1052                 n->u.tag.tag =
1053                     data1_insert_string_n (dh, n, m,
1054                                            wrbuf->buf, wrbuf->pos);
1055             }
1056             if (n->u.tag.attributes)
1057             {
1058                 data1_xattr *p;
1059                 for (p = n->u.tag.attributes; p; p = p->next)
1060                 {
1061                     if (p->value &&
1062                         conv_item(m, t, wrbuf, p->value, strlen(p->value))
1063                         == 0)
1064                     {
1065                         wrbuf_puts (wrbuf, "");
1066                         p->value = nmem_strdup (m, wrbuf->buf);
1067                     }
1068                 }
1069             }
1070             break;
1071         case DATA1N_preprocess:
1072             if (strcmp(n->u.preprocess.target, "xml") == 0)
1073             {
1074                 data1_xattr *p = n->u.preprocess.attributes;
1075                 for (; p; p = p->next)
1076                     if (strcmp (p->name, "encoding") == 0)
1077                         p->value = nmem_strdup (m, tocode);
1078             }
1079             break;
1080         }
1081         data1_iconv_s (dh, m, n->child, t, wrbuf, tocode);
1082     }
1083 }
1084
1085 const char *data1_get_encoding (data1_handle dh, data1_node *n)
1086 {
1087     /* see if we have an xml header that specifies encoding */
1088     if (n && n->child && n->child->which == DATA1N_preprocess &&
1089         strcmp (n->child->u.preprocess.target, "xml") == 0)
1090     {
1091         data1_xattr *xp = n->child->u.preprocess.attributes;
1092         for (; xp; xp = xp->next)
1093             if (!strcmp (xp->name, "encoding") == 0)
1094                 return xp->value;
1095     }
1096     /* no encoding in header, so see if "encoding" was specified for abs */
1097     if (n && n->which == DATA1N_root &&
1098         n->u.root.absyn && n->u.root.absyn->encoding)
1099         return n->u.root.absyn->encoding;
1100     /* none of above, return a hard coded default */
1101     return "ISO-8859-1";
1102 }
1103
1104 int data1_iconv (data1_handle dh, NMEM m, data1_node *n,
1105                   const char *tocode,
1106                   const char *fromcode)
1107 {
1108     if (yaz_matchstr (tocode, fromcode))
1109     {
1110         WRBUF wrbuf = wrbuf_alloc();
1111         yaz_iconv_t t = yaz_iconv_open (tocode, fromcode);
1112         if (!t)
1113             return -1;
1114         data1_iconv_s (dh, m, n, t, wrbuf, tocode);
1115         yaz_iconv_close (t);
1116         wrbuf_free (wrbuf, 1);
1117     }
1118     return 0;
1119 }
1120
1121 void data1_concat_text(data1_handle dh, NMEM m, data1_node *n)
1122 {
1123     for (; n; n = n->next)
1124     {
1125         if (n->which == DATA1N_data && n->next &&
1126             n->next->which == DATA1N_data)
1127         {
1128             int sz = 0;
1129             int off = 0;
1130             char *ndata;
1131             data1_node *np;
1132             for (np = n; np && np->which == DATA1N_data; np=np->next)
1133                 sz += np->u.data.len;
1134             ndata = nmem_malloc(m, sz);
1135             for (np = n; np && np->which == DATA1N_data; np=np->next)
1136             {
1137                 memcpy(ndata+off, np->u.data.data, np->u.data.len);
1138                 off += np->u.data.len;
1139             }
1140             n->u.data.data = ndata;
1141             n->u.data.len = sz;
1142             n->next = np;
1143             if (!np && n->parent)
1144                 n->parent->last_child = n;
1145
1146         }
1147         data1_concat_text(dh, m, n->child);
1148     }
1149 }