data1/d1_read.c

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