data1/d1_read.c

   1 /* $Id: d1_read.c,v 1.17 2005-04-28 08:12:28 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[256];
 701             int null_tag = 0;
 702             int end_tag = 0;
 703             size_t i = 0;
 704
 705             c = ampr (get_byte, fh, &amp);
 706             if (amp == 0 && c == '/')
 707             {
 708                 end_tag = 1;
 709                 c = ampr (get_byte, fh, &amp);
 710             }
 711             else if (amp == 0 && c == '?')
 712             {
 713                 int quote_mode = 0;
 714                 while ((c = ampr(get_byte, fh, &amp)))
 715                 {
 716                     if (amp)
 717                         continue;
 718                     if (quote_mode == 0)
 719                     {
 720                         if (c == '"')
 721                             quote_mode = c;
 722                         else if (c == '\'')
 723                             quote_mode = c;
 724                         else if (c == '>')
 725                         {
 726                             c = ampr(get_byte, fh, &amp);
 727                             break;
 728                         }
 729                     }
 730                     else
 731                     {
 732                         if (amp == 0 && c == quote_mode)
 733                             quote_mode = 0;
 734                     }
 735                 }
 736                 continue;
 737             }
 738             else if (amp == 0 && c == '!')
 739             {
 740                 int c0, amp0;
 741
 742                 wrbuf_rewind(wrbuf);
 743
 744                 c0 = ampr (get_byte, fh, &amp0);
 745                 if (amp0 == 0 && c0 == '\0')
 746                     break;
 747                 c = ampr (get_byte, fh, &amp);
 748
 749                 if (amp0 == 0 && c0 == '-' && amp == 0 && c == '-')
 750                 {
 751                     /* COMMENT: <!-- ... --> */
 752                     int no_dash = 0;
 753
 754                     c = ampr (get_byte, fh, &amp);
 755                     while (amp || c)
 756                     {
 757                         if (amp == 0 && c == '-')
 758                             no_dash++;
 759                         else if (amp == 0 && c == '>' && no_dash >= 2)
 760                         {
 761                             if (level > 0)
 762                                 d1_stack[level] =
 763                                     data1_mk_comment_n (
 764                                         dh, m,
 765                                         wrbuf_buf(wrbuf), wrbuf_len(wrbuf)-2,
 766                                         d1_stack[level-1]);
 767                             c = ampr (get_byte, fh, &amp); /* skip > */
 768                             break;
 769                         }
 770                         else
 771                             no_dash = 0;
 772                         wrbuf_putc (wrbuf, c);
 773                         c = ampr (get_byte, fh, &amp);
 774                     }
 775                     continue;
 776                 }
 777                 else
 778                 {   /* DIRECTIVE: <! .. > */
 779
 780                     int blevel = 0;
 781                     while (amp || c)
 782                     {
 783                         if (amp == 0 && c == '>' && blevel == 0)
 784                         {
 785                             c = ampr (get_byte, fh, &amp);
 786                             break;
 787                         }
 788                         if (amp == 0 && c == '[')
 789                             blevel++;
 790                         if (amp == 0 && c == ']' && blevel > 0)
 791                             blevel--;
 792                         c = ampr (get_byte, fh, &amp);
 793                     }
 794                     continue;
 795                 }
 796             }
 797             while (amp || (c && c != '>' && c != '/' && !d1_isspace(c)))
 798             {
 799                 if (i < (sizeof(tag)-1))
 800                     tag[i++] = c;
 801                 c = ampr (get_byte, fh, &amp);
 802             }
 803             tag[i] = '\0';
 804             xattr = data1_read_xattr (dh, m, get_byte, fh, wrbuf, &c, &amp);
 805             if (amp == 0 && c == '/')
 806             {    /* <tag attrs/> or <tag/> */
 807                 null_tag = 1;
 808                 c = ampr (get_byte, fh, &amp);
 809             }
 810             if (amp || c != '>')
 811             {
 812                 yaz_log(YLOG_WARN, "d1: %d: Malformed tag", line);
 813                 return 0;
 814             }
 815             else
 816                 c = ampr (get_byte, fh, &amp);
 817
 818             /* End tag? */
 819             if (end_tag)
 820             {
 821                 if (*tag == '\0')
 822                     --level;        /* </> */
 823                 else
 824                 {                   /* </tag> */
 825                     int i = level;
 826                     while (i > 0)
 827                     {
 828                         parent = d1_stack[--i];
 829                         if ((parent->which == DATA1N_root &&
 830                              !strcmp(tag, parent->u.root.type)) ||
 831                             (parent->which == DATA1N_tag &&
 832                              !strcmp(tag, parent->u.tag.tag)))
 833                         {
 834                             level = i;
 835                             break;
 836                         }
 837                     }
 838                     if (i != level)
 839                     {
 840                         yaz_log (YLOG_WARN, "%d: no begin tag for %s",
 841                                  line, tag);
 842                         break;
 843                     }
 844                 }
 845                 if (data1_is_xmlmode(dh))
 846                 {
 847                     if (level <= 1)
 848                         return d1_stack[0];
 849                 }
 850                 else
 851                 {
 852                     if (level <= 0)
 853                         return d1_stack[0];
 854                 }
 855                 continue;
 856             }
 857             else if (!strcmp(tag, "var")
 858                      && xattr && xattr->next && xattr->next->next
 859                      && xattr->value == 0
 860                      && xattr->next->value == 0
 861                      && xattr->next->next->value == 0)
 862             {
 863                 /* <var class type value> */
 864                 const char *tclass = xattr->name;
 865                 const char *type = xattr->next->name;
 866                 const char *value = xattr->next->name;
 867                 data1_vartype *tp;
 868
 869                 yaz_log(YLOG_LOG, "Variant class=%s type=%s value=%s",
 870                         tclass, type, value);
 871                 if (!(tp =
 872                       data1_getvartypebyct(dh,
 873                                            parent->root->u.root.absyn->varset,
 874                                            tclass, type)))
 875                     continue;
 876                 /*
 877                  * If we're the first variant in this group, create a parent
 878                  * variant, and insert it before the current variant.
 879                  */
 880                 if (parent->which != DATA1N_variant)
 881                 {
 882                     res = data1_mk_node2 (dh, m, DATA1N_variant, parent);
 883                 }
 884                 else
 885                 {
 886                     /*
 887                      * now determine if one of our ancestor triples is of
 888                      * same type. If so, we break here.
 889                      */
 890                     int i;
 891                     for (i = level-1; d1_stack[i]->which==DATA1N_variant; --i)
 892                         if (d1_stack[i]->u.variant.type == tp)
 893                         {
 894                             level = i;
 895                             break;
 896                         }
 897                     res = data1_mk_node2 (dh, m, DATA1N_variant, parent);
 898                     res->u.variant.type = tp;
 899                     res->u.variant.value =
 900                         data1_insert_string (dh, res, m, value);
 901                 }
 902             }
 903             else
 904             {
 905
 906                 /* tag .. acquire our element in the abstract syntax */
 907                 if (level == 0)
 908                 {
 909                     parent = data1_mk_root (dh, m, tag);
 910                     res = d1_stack[level] = parent;
 911
 912                     if (data1_is_xmlmode(dh))
 913                     {
 914                         level++;
 915                         res = data1_mk_tag (dh, m, tag, 0 /* attr */, parent);
 916                         res->u.tag.attributes = xattr;
 917                     }
 918                 }
 919                 else
 920                 {
 921                     res = data1_mk_tag (dh, m, tag, 0 /* attr */, parent);
 922                     res->u.tag.attributes = xattr;
 923                 }
 924             }
 925             d1_stack[level] = res;
 926             d1_stack[level+1] = 0;
 927             if (level < 250 && !null_tag)
 928                 ++level;
 929         }
 930         else /* != '<'... this is a body of text */
 931         {
 932             int len;
 933
 934             if (level == 0)
 935             {
 936                 c = ampr (get_byte, fh, &amp);
 937                 continue;
 938             }
 939             res = data1_mk_node2 (dh, m, DATA1N_data, parent);
 940             res->u.data.what = DATA1I_xmltext;
 941             res->u.data.formatted_text = 0;
 942             d1_stack[level] = res;
 943
 944             wrbuf_rewind(wrbuf);
 945
 946             while (amp || (c && c != '<'))
 947             {
 948                 wrbuf_putc (wrbuf, c);
 949                 c = ampr (get_byte, fh, &amp);
 950             }
 951             len = wrbuf_len(wrbuf);
 952
 953             /* use local buffer of nmem if too large */
 954             if (len >= DATA1_LOCALDATA)
 955                 res->u.data.data = (char*) nmem_malloc (m, len);
 956             else
 957                 res->u.data.data = res->lbuf;
 958
 959             if (len)
 960                 memcpy (res->u.data.data, wrbuf_buf(wrbuf), len);
 961             else
 962                 res->u.data.data = 0;
 963             res->u.data.len = len;
 964         }
 965     }
 966     return 0;
 967 }
 968
 969 int getc_mem (void *fh)
 970 {
 971     const char **p = (const char **) fh;
 972     if (**p)
 973         return *(*p)++;
 974     return 0;
 975 }
 976
 977 data1_node *data1_read_node (data1_handle dh, const char **buf, NMEM m)
 978 {
 979     WRBUF wrbuf = wrbuf_alloc();
 980     data1_node *node;
 981
 982     node = data1_read_nodex(dh, m, getc_mem, (void *) (buf), wrbuf);
 983     wrbuf_free (wrbuf, 1);
 984     return node;
 985 }
 986
 987 /*
 988  * Read a record in the native syntax.
 989  */
 990 data1_node *data1_read_record(data1_handle dh,
 991                               int (*rf)(void *, char *, size_t), void *fh,
 992                               NMEM m)
 993 {
 994     int *size;
 995     char **buf = data1_get_read_buf (dh, &size);
 996     const char *bp;
 997     int rd = 0, res;
 998
 999     if (!*buf)
1000         *buf = (char *)xmalloc(*size = 4096);
1001
1002     for (;;)
1003     {
1004         if (rd + 2048 >= *size && !(*buf =(char *)xrealloc(*buf, *size *= 2)))
1005             abort();
1006         if ((res = (*rf)(fh, *buf + rd, 2048)) <= 0)
1007         {
1008             if (!res)
1009             {
1010                 bp = *buf;
1011                 (*buf)[rd] = '\0';
1012                 return data1_read_node(dh, &bp, m);
1013             }
1014             else
1015                 return 0;
1016         }
1017         rd += res;
1018     }
1019 }
1020
1021 data1_node *data1_read_sgml (data1_handle dh, NMEM m, const char *buf)
1022 {
1023     const char *bp = buf;
1024     return data1_read_node (dh, &bp, m);
1025 }
1026
1027
1028 static int conv_item (NMEM m, yaz_iconv_t t,
1029                       WRBUF wrbuf, char *inbuf, size_t inlen)
1030 {
1031     wrbuf_rewind (wrbuf);
1032     if (wrbuf->size < 10)
1033         wrbuf_grow (wrbuf, 10);
1034     for (;;)
1035     {
1036         char *outbuf = wrbuf->buf + wrbuf->pos;
1037         size_t outlen = wrbuf->size - wrbuf->pos;
1038         if (yaz_iconv (t, &inbuf, &inlen, &outbuf, &outlen) ==
1039             (size_t)(-1) && yaz_iconv_error(t) != YAZ_ICONV_E2BIG)
1040         {
1041             /* bad data. stop and skip conversion entirely */
1042             return -1;
1043         }
1044         else if (inlen == 0)
1045         {   /* finished converting */
1046             wrbuf->pos = wrbuf->size - outlen;
1047             break;
1048         }
1049         else
1050         {
1051             /* buffer too small: make sure we expand buffer */
1052             wrbuf->pos = wrbuf->size - outlen;
1053             wrbuf_grow(wrbuf, 20);
1054         }
1055     }
1056     return 0;
1057 }
1058
1059 static void data1_iconv_s (data1_handle dh, NMEM m, data1_node *n,
1060                            yaz_iconv_t t, WRBUF wrbuf, const char *tocode)
1061 {
1062     for (; n; n = n->next)
1063     {
1064         switch (n->which)
1065         {
1066         case DATA1N_data:
1067         case DATA1N_comment:
1068             if (conv_item (m, t, wrbuf, n->u.data.data, n->u.data.len) == 0)
1069             {
1070                 n->u.data.data =
1071                     data1_insert_string_n (dh, n, m, wrbuf->buf,
1072                                            wrbuf->pos);
1073                 n->u.data.len = wrbuf->pos;
1074             }
1075             break;
1076         case DATA1N_tag:
1077             if (conv_item (m, t, wrbuf, n->u.tag.tag, strlen(n->u.tag.tag))
1078                 == 0)
1079             {
1080                 n->u.tag.tag =
1081                     data1_insert_string_n (dh, n, m,
1082                                            wrbuf->buf, wrbuf->pos);
1083             }
1084             if (n->u.tag.attributes)
1085             {
1086                 data1_xattr *p;
1087                 for (p = n->u.tag.attributes; p; p = p->next)
1088                 {
1089                     if (p->value &&
1090                         conv_item(m, t, wrbuf, p->value, strlen(p->value))
1091                         == 0)
1092                     {
1093                         wrbuf_puts (wrbuf, "");
1094                         p->value = nmem_strdup (m, wrbuf->buf);
1095                     }
1096                 }
1097             }
1098             break;
1099         case DATA1N_preprocess:
1100             if (strcmp(n->u.preprocess.target, "xml") == 0)
1101             {
1102                 data1_xattr *p = n->u.preprocess.attributes;
1103                 for (; p; p = p->next)
1104                     if (strcmp (p->name, "encoding") == 0)
1105                         p->value = nmem_strdup (m, tocode);
1106             }
1107             break;
1108         }
1109         data1_iconv_s (dh, m, n->child, t, wrbuf, tocode);
1110     }
1111 }
1112
1113 const char *data1_get_encoding (data1_handle dh, data1_node *n)
1114 {
1115     /* see if we have an xml header that specifies encoding */
1116     if (n && n->child && n->child->which == DATA1N_preprocess &&
1117         strcmp (n->child->u.preprocess.target, "xml") == 0)
1118     {
1119         data1_xattr *xp = n->child->u.preprocess.attributes;
1120         for (; xp; xp = xp->next)
1121             if (!strcmp (xp->name, "encoding") == 0)
1122                 return xp->value;
1123     }
1124     /* no encoding in header, so see if "encoding" was specified for abs */
1125     if (n && n->which == DATA1N_root &&
1126         n->u.root.absyn && n->u.root.absyn->encoding)
1127         return n->u.root.absyn->encoding;
1128     /* none of above, return a hard coded default */
1129     return "ISO-8859-1";
1130 }
1131
1132 int data1_iconv (data1_handle dh, NMEM m, data1_node *n,
1133                   const char *tocode,
1134                   const char *fromcode)
1135 {
1136     if (yaz_matchstr (tocode, fromcode))
1137     {
1138         WRBUF wrbuf = wrbuf_alloc();
1139         yaz_iconv_t t = yaz_iconv_open(tocode, fromcode);
1140         if (!t)
1141         {
1142             wrbuf_free(wrbuf, 1);
1143             return -1;
1144         }
1145         data1_iconv_s(dh, m, n, t, wrbuf, tocode);
1146         yaz_iconv_close(t);
1147         wrbuf_free(wrbuf, 1);
1148     }
1149     return 0;
1150 }
1151
1152 void data1_concat_text(data1_handle dh, NMEM m, data1_node *n)
1153 {
1154     for (; n; n = n->next)
1155     {
1156         if (n->which == DATA1N_data && n->next &&
1157             n->next->which == DATA1N_data)
1158         {
1159             int sz = 0;
1160             int off = 0;
1161             char *ndata;
1162             data1_node *np;
1163             for (np = n; np && np->which == DATA1N_data; np=np->next)
1164                 sz += np->u.data.len;
1165             ndata = nmem_malloc(m, sz);
1166             for (np = n; np && np->which == DATA1N_data; np=np->next)
1167             {
1168                 memcpy(ndata+off, np->u.data.data, np->u.data.len);
1169                 off += np->u.data.len;
1170             }
1171             n->u.data.data = ndata;
1172             n->u.data.len = sz;
1173             n->next = np;
1174             if (!np && n->parent)
1175                 n->parent->last_child = n;
1176
1177         }
1178         data1_concat_text(dh, m, n->child);
1179     }
1180 }