gedcom/xref.c

   1 /* Cross-reference manipulation routines.
   2    Copyright (C) 2001,2002 The Genes Development Team
   3    This file is part of the Gedcom parser library.
   4    Contributed by Peter Verthez <Peter.Verthez@advalvas.be>, 2001.
   5
   6    The Gedcom parser library is free software; you can redistribute it
   7    and/or modify it under the terms of the GNU Lesser General Public
   8    License as published by the Free Software Foundation; either
   9    version 2.1 of the License, or (at your option) any later version.
  10
  11    The Gedcom parser library is distributed in the hope that it will be
  12    useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    Lesser General Public License for more details.
  15
  16    You should have received a copy of the GNU Lesser General Public
  17    License along with the Gedcom parser library; if not, write to the
  18    Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19    02111-1307 USA.  */
  20
  21 /* $Id$ */
  22 /* $Name$ */
  23
  24 #include "gedcom_internal.h"
  25 #include "xref.h"
  26 #include "hash.h"
  27
  28 struct xref_value def_xref_val = { XREF_NONE, "<error>", NULL };
  29 static hash_t *xrefs = NULL;
  30
  31 char* xref_type_str[] = { N_("nothing"),
  32                           N_("a family"),
  33                           N_("an individual"),
  34                           N_("a note"),
  35                           N_("a multimedia object"),
  36                           N_("a source repository"),
  37                           N_("a source"),
  38                           N_("a submitter"),
  39                           N_("a submission record"),
  40                           N_("an application-specific record"),
  41                         };
  42
  43 struct xref_node {
  44   struct xref_value xref;
  45   Xref_type defined_type;
  46   Xref_type used_type;
  47   int defined_line;
  48   int used_line;
  49 };
  50
  51 hnode_t *xref_alloc(void *c __attribute__((unused)))
  52 {
  53   return malloc(sizeof *xref_alloc(NULL));
  54 }
  55
  56 void xref_free(hnode_t *n, void *c __attribute__((unused)))
  57 {
  58   struct xref_node *xr = (struct xref_node *)hnode_get(n);
  59   free((void*)hnode_getkey(n));
  60   free(xr->xref.string);
  61   free(xr);
  62   free(n);
  63 }
  64
  65 void clear_xref_node(struct xref_node *xr)
  66 {
  67   xr->xref.type    = XREF_NONE;
  68   /* Make sure that the 'string' member always contains a valid string */
  69   if (!xr->xref.string)
  70     xr->xref.string  = strdup("");
  71   xr->xref.object  = NULL;
  72   xr->defined_type = XREF_NONE;
  73   xr->used_type    = XREF_NONE;
  74   xr->defined_line = -1;
  75   xr->used_line    = -1;
  76 }
  77
  78 struct xref_node *make_xref_node()
  79 {
  80   struct xref_node *xr = (struct xref_node *)malloc(sizeof(struct xref_node));
  81   xr->xref.string = NULL;
  82   clear_xref_node(xr);
  83   return xr;
  84 }
  85
  86 void cleanup_xrefs()
  87 {
  88   hash_free(xrefs);
  89   xrefs = NULL;
  90 }
  91
  92 void make_xref_table()
  93 {
  94   if (xrefs)
  95     cleanup_xrefs();
  96   else
  97     /* Only register initially (if xrefs is still NULL) */
  98     /* So that it is only registered once */
  99     atexit(cleanup_xrefs);
 100   xrefs = hash_create(HASHCOUNT_T_MAX, NULL, NULL);
 101   hash_set_allocator(xrefs, xref_alloc, xref_free, NULL);
 102 }
 103
 104 int check_xref_table()
 105 {
 106   int result = 0;
 107   hscan_t hs;
 108   hnode_t *node;
 109   struct xref_node *xr;
 110
 111   /* Check for undefined and unused xrefs */
 112   hash_scan_begin(&hs, xrefs);
 113   while ((node = hash_scan_next(&hs))) {
 114     xr = (struct xref_node *)hnode_get(node);
 115     if (xr->defined_type == XREF_NONE && xr->used_type != XREF_NONE) {
 116       gedcom_error(_("Cross-reference %s used on line %d is not defined"),
 117                    xr->xref.string, xr->used_line);
 118       result |= 1;
 119     }
 120     if (xr->used_type == XREF_NONE && xr->defined_type != XREF_NONE) {
 121       gedcom_warning(_("Cross-reference %s defined on line %d is never used"),
 122                      xr->xref.string, xr->defined_line);
 123     }
 124   }
 125
 126   return result;
 127 }
 128
 129 struct xref_value *gedcom_parse_xref(char *raw_value,
 130                                      Xref_ctxt ctxt, Xref_type xref_type)
 131 {
 132   struct xref_node *xr = NULL;
 133
 134   hnode_t *node = hash_lookup(xrefs, raw_value);
 135   if (node) {
 136     xr = (struct xref_node *)hnode_get(node);
 137   }
 138   else {
 139     char *key = strdup(raw_value);
 140     xr = make_xref_node();
 141     xr->xref.type = xref_type;
 142     free(xr->xref.string);
 143     xr->xref.string = strdup(raw_value);
 144     hash_alloc_insert(xrefs, key, xr);
 145   }
 146
 147   if (ctxt == XREF_DEFINED && xr->defined_type == XREF_NONE) {
 148     xr->defined_type = xref_type;
 149     xr->defined_line = line_no;
 150   }
 151   else if (ctxt == XREF_USED && xr->used_type == XREF_NONE) {
 152     xr->used_type = xref_type;
 153     xr->used_line = line_no;
 154   }
 155
 156   if ((ctxt == XREF_DEFINED && xr->defined_type != xref_type)
 157       || (ctxt == XREF_USED &&
 158           (xr->defined_type != XREF_NONE && xr->defined_type != xref_type))) {
 159     gedcom_error(_("Cross-reference %s previously defined as pointer to %s, "
 160                    "on line %d"),
 161                  xr->xref.string, xref_type_str[xr->defined_type],
 162                  xr->defined_line);
 163     clear_xref_node(xr);
 164   }
 165   else if ((ctxt == XREF_USED && xr->used_type != xref_type)
 166            || (ctxt == XREF_DEFINED &&
 167                (xr->used_type != XREF_NONE && xr->used_type != xref_type))) {
 168     gedcom_error(_("Cross-reference %s previously used as pointer to %s, "
 169                    "on line %d"),
 170                  xr->xref.string, xref_type_str[xr->used_type], xr->used_line);
 171     clear_xref_node(xr);
 172   }
 173
 174   return &(xr->xref);
 175 }