gom/gom.c

   1 /* Main file for building the gedcom object model.
   2    Copyright (C) 2002 The Genes Development Team
   3    This file is part of the Gedcom parser library.
   4    Contributed by Peter Verthez <Peter.Verthez@advalvas.be>, 2002.
   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 <stdlib.h>
  25 #include <string.h>
  26 #include <stdio.h>
  27 #include "gedcom.h"
  28 #include "header.h"
  29 #include "submitter.h"
  30 #include "submission.h"
  31 #include "family.h"
  32 #include "individual.h"
  33 #include "multimedia.h"
  34 #include "note.h"
  35 #include "repository.h"
  36 #include "source.h"
  37 #include "user_rec.h"
  38 #include "address.h"
  39 #include "event.h"
  40 #include "place.h"
  41 #include "source_citation.h"
  42 #include "multimedia_link.h"
  43 #include "note_sub.h"
  44 #include "lds_event.h"
  45 #include "user_ref.h"
  46 #include "change_date.h"
  47 #include "personal_name.h"
  48 #include "family_link.h"
  49 #include "association.h"
  50 #include "source_event.h"
  51 #include "source_description.h"
  52 #include "gom.h"
  53 #include "gom_internal.h"
  54
  55 void gom_default_callback (Gedcom_elt elt, Gedcom_ctxt parent, int level,
  56                            char* tag, char* raw_value, int parsed_tag);
  57
  58 void gom_cleanup()
  59 {
  60   header_cleanup();
  61   submission_cleanup();
  62   families_cleanup();
  63   individuals_cleanup();
  64   multimedias_cleanup();
  65   notes_cleanup();
  66   repositories_cleanup();
  67   sources_cleanup();
  68   submitters_cleanup();
  69   user_recs_cleanup();
  70 }
  71
  72 void subscribe_all()
  73 {
  74   gedcom_set_default_callback(gom_default_callback);
  75   header_subscribe();
  76   submission_subscribe();
  77   family_subscribe();
  78   individual_subscribe();
  79   multimedia_subscribe();
  80   note_subscribe();
  81   repository_subscribe();
  82   source_subscribe();
  83   submitter_subscribe();
  84   user_rec_subscribe();
  85
  86   address_subscribe();
  87   event_subscribe();
  88   place_subscribe();
  89   citation_subscribe();
  90   note_sub_subscribe();
  91   multimedia_link_subscribe();
  92   lds_event_subscribe();
  93   user_ref_subscribe();
  94   change_date_subscribe();
  95   name_subscribe();
  96   family_link_subscribe();
  97   association_subscribe();
  98   source_event_subscribe();
  99   source_description_subscribe();
 100
 101   if (atexit(gom_cleanup) != 0) {
 102     gedcom_warning(_("Could not register gom cleanup function"));
 103   }
 104 }
 105
 106 int gom_active = 0;
 107
 108 int gom_parse_file(const char* file_name)
 109 {
 110   if (gom_active) {
 111     gom_cleanup();
 112   }
 113   else {
 114     subscribe_all();
 115   }
 116   gom_active = 1;
 117   return gedcom_parse_file(file_name);
 118 }
 119
 120 int gom_new_model()
 121 {
 122   if (gom_active) {
 123     gom_cleanup();
 124   }
 125   else {
 126     subscribe_all();
 127   }
 128   gom_active = 1;
 129   return gedcom_new_model();
 130 }
 131
 132 int gom_write_file(const char* file_name, int *total_conv_fails)
 133 {
 134   Gedcom_write_hndl hndl;
 135   int result = 1;
 136
 137   hndl = gedcom_write_open(file_name);
 138   if (hndl) {
 139     result = write_header(hndl);
 140     result |= write_submission(hndl);
 141     result |= write_submitters(hndl);
 142     result |= write_individuals(hndl);
 143     result |= write_families(hndl);
 144     result |= write_multimedia_recs(hndl);
 145     result |= write_notes(hndl);
 146     result |= write_repositories(hndl);
 147     result |= write_sources(hndl);
 148     result |= write_user_recs(hndl);
 149     result |= gedcom_write_close(hndl, total_conv_fails);
 150   }
 151
 152   return result;
 153 }
 154
 155 int gom_write_xref_list(Gedcom_write_hndl hndl,
 156                         Gedcom_elt elt, int tag, int parent_rec_or_elt,
 157                         struct xref_list* val)
 158 {
 159   int result = 0;
 160   struct xref_list* xrl;
 161   for (xrl = val; xrl; xrl = xrl->next) {
 162     result |= gedcom_write_element_xref(hndl, elt, tag, parent_rec_or_elt,
 163                                         xrl->xref);
 164   }
 165   return result;
 166 }
 167
 168 Gom_ctxt make_gom_ctxt(int ctxt_type, OBJ_TYPE obj_type, void *ctxt_ptr)
 169 {
 170   Gom_ctxt ctxt   = (Gom_ctxt)malloc(sizeof(struct Gom_ctxt_struct));
 171   if (! ctxt)
 172     MEMORY_ERROR;
 173   else {
 174     ctxt->ctxt_type = ctxt_type;
 175     ctxt->obj_type  = obj_type;
 176     ctxt->ctxt_ptr  = ctxt_ptr;
 177   }
 178   return ctxt;
 179 }
 180
 181 void NULL_DESTROY(void* anything UNUSED)
 182 {
 183 }
 184
 185 void destroy_gom_ctxt(Gom_ctxt ctxt)
 186 {
 187   SAFE_FREE(ctxt);
 188 }
 189
 190 void gom_cast_error(const char* file, int line,
 191                     OBJ_TYPE expected, OBJ_TYPE found)
 192 {
 193   fprintf(stderr,
 194           "Wrong gom ctxt cast at %s, line %d: expected %d, found %d\n",
 195           file, line, expected, found);
 196   abort();
 197 }
 198
 199 void gom_mem_error(const char *filename, int line)
 200 {
 201   gedcom_error(_("Could not allocate memory at %s, %d"), filename, line);
 202 }
 203
 204 void gom_xref_already_in_use(const char *xrefstr)
 205 {
 206   gedcom_error(_("Cross-reference key '%s' is already in use"), xrefstr);
 207 }
 208
 209 void gom_unexpected_context(const char* file, int line, OBJ_TYPE found)
 210 {
 211   gedcom_warning(_("Internal error: Unexpected context at %s, line %d: %d"),
 212                  file, line, found);
 213 }
 214
 215 void gom_no_context(const char* file, int line)
 216 {
 217   gedcom_warning(_("Internal error: No context at %s, line %d"),
 218                  file, line);
 219 }
 220
 221 void gom_move_error(const char* type)
 222 {
 223   gedcom_warning(_("Could not move struct of type %s"), type);
 224 }
 225
 226 void gom_find_error(const char* type)
 227 {
 228   gedcom_warning(_("Could not find struct of type %s in chain"), type);
 229 }
 230
 231 void gom_default_callback (Gedcom_elt elt UNUSED, Gedcom_ctxt parent UNUSED,
 232                            int level, char* tag, char* raw_value,
 233                            int parsed_tag UNUSED)
 234 {
 235   gedcom_warning(_("Data loss in import: \"%d %s %s\""),
 236                  level, tag, raw_value);
 237 }
 238
 239 void def_rec_end(Gedcom_rec rec UNUSED, Gedcom_ctxt self,
 240                  Gedcom_val parsed_value UNUSED)
 241 {
 242   Gom_ctxt ctxt = (Gom_ctxt)self;
 243   destroy_gom_ctxt(ctxt);
 244 }
 245
 246 void def_elt_end(Gedcom_elt elt UNUSED, Gedcom_ctxt parent UNUSED,
 247                  Gedcom_ctxt self, Gedcom_val parsed_value UNUSED)
 248 {
 249   Gom_ctxt ctxt = (Gom_ctxt)self;
 250   destroy_gom_ctxt(ctxt);
 251 }
 252
 253 void set_xref_type(struct xref_value* xr, const char *str)
 254 {
 255   if (!strcasecmp(str, "FAM"))
 256     xr->type = XREF_FAM;
 257   else if (!strcasecmp(str, "INDI"))
 258     xr->type = XREF_INDI;
 259   else if (!strcasecmp(str, "NOTE"))
 260     xr->type = XREF_NOTE;
 261   else if (!strcasecmp(str, "OBJE"))
 262     xr->type = XREF_OBJE;
 263   else if (!strcasecmp(str, "REPO"))
 264     xr->type = XREF_REPO;
 265   else if (!strcasecmp(str, "SOUR"))
 266     xr->type = XREF_SOUR;
 267   else if (!strcasecmp(str, "SUBM"))
 268     xr->type = XREF_SUBM;
 269   else if (!strcasecmp(str, "SUBN"))
 270     xr->type = XREF_SUBN;
 271   else
 272     xr->type = XREF_ANY;
 273 }