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_get_by_xref(char *key)
 130 {
 131   hnode_t *node = hash_lookup(xrefs, key);
 132   if (node) {
 133     struct xref_node *xr = (struct xref_node *)hnode_get(node);
 134     return &(xr->xref);
 135   }
 136   else
 137     return NULL;
 138 }
 139
 140 struct xref_value *gedcom_parse_xref(char *raw_value,
 141                                      Xref_ctxt ctxt, Xref_type xref_type)
 142 {
 143   struct xref_node *xr = NULL;
 144
 145   hnode_t *node = hash_lookup(xrefs, raw_value);
 146   if (node) {
 147     xr = (struct xref_node *)hnode_get(node);
 148   }
 149   else {
 150     char *key = strdup(raw_value);
 151     xr = make_xref_node();
 152     xr->xref.type = xref_type;
 153     free(xr->xref.string);
 154     xr->xref.string = strdup(raw_value);
 155     hash_alloc_insert(xrefs, key, xr);
 156   }
 157
 158   if (ctxt == XREF_DEFINED && xr->defined_type == XREF_NONE) {
 159     xr->defined_type = xref_type;
 160     xr->defined_line = line_no;
 161   }
 162   else if (ctxt == XREF_USED && xr->used_type == XREF_NONE) {
 163     xr->used_type = xref_type;
 164     xr->used_line = line_no;
 165   }
 166
 167   if ((ctxt == XREF_DEFINED && xr->defined_type != xref_type &&
 168        xr->defined_type != XREF_ANY)
 169       || (ctxt == XREF_USED &&
 170           (xr->defined_type != XREF_NONE && xr->defined_type != xref_type &&
 171            xr->defined_type != XREF_ANY))) {
 172     gedcom_error(_("Cross-reference %s previously defined as pointer to %s, "
 173                    "on line %d"),
 174                  xr->xref.string, xref_type_str[xr->defined_type],
 175                  xr->defined_line);
 176     clear_xref_node(xr);
 177   }
 178   else if ((ctxt == XREF_USED && xr->used_type != xref_type)
 179            || (ctxt == XREF_DEFINED &&
 180                (xr->used_type != XREF_NONE && xr->used_type != xref_type))) {
 181     gedcom_error(_("Cross-reference %s previously used as pointer to %s, "
 182                    "on line %d"),
 183                  xr->xref.string, xref_type_str[xr->used_type], xr->used_line);
 184     clear_xref_node(xr);
 185   }
 186
 187   return &(xr->xref);
 188 }