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     gedcom_set_compat_options(COMPAT_ALLOW_OUT_OF_CONTEXT);
 115     subscribe_all();
 116   }
 117   gom_active = 1;
 118   return gedcom_parse_file(file_name);
 119 }
 120
 121 int gom_new_model()
 122 {
 123   if (gom_active) {
 124     gom_cleanup();
 125   }
 126   else {
 127     subscribe_all();
 128   }
 129   gom_active = 1;
 130   return gedcom_new_model();
 131 }
 132
 133 int gom_write_file(const char* file_name, int *total_conv_fails)
 134 {
 135   Gedcom_write_hndl hndl;
 136   int result = 1;
 137
 138   hndl = gedcom_write_open(file_name);
 139   if (hndl) {
 140     result = write_header(hndl);
 141     result |= write_submission(hndl);
 142     result |= write_submitters(hndl);
 143     result |= write_individuals(hndl);
 144     result |= write_families(hndl);
 145     result |= write_multimedia_recs(hndl);
 146     result |= write_notes(hndl);
 147     result |= write_repositories(hndl);
 148     result |= write_sources(hndl);
 149     result |= write_user_recs(hndl);
 150     result |= gedcom_write_close(hndl, total_conv_fails);
 151   }
 152
 153   return result;
 154 }
 155
 156 int gom_write_xref_list(Gedcom_write_hndl hndl,
 157                         Gedcom_elt elt, int tag, int parent_rec_or_elt,
 158                         struct xref_list* val)
 159 {
 160   int result = 0;
 161   struct xref_list* xrl;
 162   for (xrl = val; xrl; xrl = xrl->next) {
 163     result |= gedcom_write_element_xref(hndl, elt, tag, parent_rec_or_elt,
 164                                         xrl->xref);
 165   }
 166   return result;
 167 }
 168
 169 void gom_default_callback (Gedcom_elt elt UNUSED, Gedcom_ctxt parent UNUSED,
 170                            int level, char* tag, char* raw_value,
 171                            int parsed_tag UNUSED)
 172 {
 173   gedcom_warning(_("Data loss in import: \"%d %s %s\""),
 174                  level, tag, raw_value);
 175 }
 176
 177 void gom_mem_error(const char *filename, int line)
 178 {
 179   gedcom_error(_("Could not allocate memory at %s, %d"), filename, line);
 180 }
 181
 182 void gom_xref_already_in_use(const char *xrefstr)
 183 {
 184   gedcom_error(_("Cross-reference key '%s' is already in use"), xrefstr);
 185 }
 186
 187 void gom_move_error(const char* type)
 188 {
 189   gedcom_warning(_("Could not move struct of type %s"), type);
 190 }
 191
 192 void gom_find_error(const char* type)
 193 {
 194   gedcom_warning(_("Could not find struct of type %s in chain"), type);
 195 }
 196
 197 void set_xref_type(struct xref_value* xr, const char *str)
 198 {
 199   if (!strcasecmp(str, "FAM"))
 200     xr->type = XREF_FAM;
 201   else if (!strcasecmp(str, "INDI"))
 202     xr->type = XREF_INDI;
 203   else if (!strcasecmp(str, "NOTE"))
 204     xr->type = XREF_NOTE;
 205   else if (!strcasecmp(str, "OBJE"))
 206     xr->type = XREF_OBJE;
 207   else if (!strcasecmp(str, "REPO"))
 208     xr->type = XREF_REPO;
 209   else if (!strcasecmp(str, "SOUR"))
 210     xr->type = XREF_SOUR;
 211   else if (!strcasecmp(str, "SUBM"))
 212     xr->type = XREF_SUBM;
 213   else if (!strcasecmp(str, "SUBN"))
 214     xr->type = XREF_SUBN;
 215   else
 216     xr->type = XREF_ANY;
 217 }