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_parse_file(const char* file_name)
 107 {
 108   subscribe_all();
 109   return gedcom_parse_file(file_name);
 110 }
 111
 112 int gom_new_model()
 113 {
 114   subscribe_all();
 115   return gedcom_new_model();
 116 }
 117
 118 int gom_write_file(const char* file_name, int *total_conv_fails)
 119 {
 120   Gedcom_write_hndl hndl;
 121   int result = 1;
 122
 123   hndl = gedcom_write_open(file_name);
 124   if (hndl) {
 125     result = write_header(hndl);
 126     result |= write_submission(hndl);
 127     result |= write_submitters(hndl);
 128     result |= write_individuals(hndl);
 129     result |= write_families(hndl);
 130     result |= write_multimedia_recs(hndl);
 131     result |= write_notes(hndl);
 132     result |= write_repositories(hndl);
 133     result |= write_sources(hndl);
 134     result |= write_user_recs(hndl);
 135     result |= gedcom_write_close(hndl, total_conv_fails);
 136   }
 137
 138   return result;
 139 }
 140
 141 int gom_write_xref_list(Gedcom_write_hndl hndl,
 142                         Gedcom_elt elt, int tag, int parent_rec_or_elt,
 143                         struct xref_list* val)
 144 {
 145   int result = 0;
 146   struct xref_list* xrl;
 147   for (xrl = val; xrl; xrl = xrl->next) {
 148     result |= gedcom_write_element_xref(hndl, elt, tag, parent_rec_or_elt,
 149                                         xrl->xref);
 150   }
 151   return result;
 152 }
 153
 154 Gom_ctxt make_gom_ctxt(int ctxt_type, OBJ_TYPE obj_type, void *ctxt_ptr)
 155 {
 156   Gom_ctxt ctxt   = (Gom_ctxt)malloc(sizeof(struct Gom_ctxt_struct));
 157   if (! ctxt)
 158     MEMORY_ERROR;
 159   else {
 160     ctxt->ctxt_type = ctxt_type;
 161     ctxt->obj_type  = obj_type;
 162     ctxt->ctxt_ptr  = ctxt_ptr;
 163   }
 164   return ctxt;
 165 }
 166
 167 void NULL_DESTROY(void* anything UNUSED)
 168 {
 169 }
 170
 171 void destroy_gom_ctxt(Gom_ctxt ctxt)
 172 {
 173   SAFE_FREE(ctxt);
 174 }
 175
 176 void gom_cast_error(const char* file, int line,
 177                     OBJ_TYPE expected, OBJ_TYPE found)
 178 {
 179   fprintf(stderr,
 180           "Wrong gom ctxt cast at %s, line %d: expected %d, found %d\n",
 181           file, line, expected, found);
 182   abort();
 183 }
 184
 185 void gom_mem_error(const char *filename, int line)
 186 {
 187   gedcom_error(_("Could not allocate memory at %s, %d"), filename, line);
 188 }
 189
 190 void gom_unexpected_context(const char* file, int line, OBJ_TYPE found)
 191 {
 192   gedcom_warning(_("Internal error: Unexpected context at %s, line %d: %d"),
 193                  file, line, found);
 194 }
 195
 196 void gom_no_context(const char* file, int line)
 197 {
 198   gedcom_warning(_("Internal error: No context at %s, line %d"),
 199                  file, line);
 200 }
 201
 202 void gom_default_callback (Gedcom_elt elt UNUSED, Gedcom_ctxt parent UNUSED,
 203                            int level, char* tag, char* raw_value,
 204                            int parsed_tag UNUSED)
 205 {
 206   gedcom_warning(_("Data loss in import: \"%d %s %s\""),
 207                  level, tag, raw_value);
 208 }
 209
 210 void def_rec_end(Gedcom_rec rec UNUSED, Gedcom_ctxt self,
 211                  Gedcom_val parsed_value UNUSED)
 212 {
 213   Gom_ctxt ctxt = (Gom_ctxt)self;
 214   destroy_gom_ctxt(ctxt);
 215 }
 216
 217 void def_elt_end(Gedcom_elt elt UNUSED, Gedcom_ctxt parent UNUSED,
 218                  Gedcom_ctxt self, Gedcom_val parsed_value UNUSED)
 219 {
 220   Gom_ctxt ctxt = (Gom_ctxt)self;
 221   destroy_gom_ctxt(ctxt);
 222 }
 223
 224 void set_xref_type(struct xref_value* xr, const char *str)
 225 {
 226   if (!strcasecmp(str, "FAM"))
 227     xr->type = XREF_FAM;
 228   else if (!strcasecmp(str, "INDI"))
 229     xr->type = XREF_INDI;
 230   else if (!strcasecmp(str, "NOTE"))
 231     xr->type = XREF_NOTE;
 232   else if (!strcasecmp(str, "OBJE"))
 233     xr->type = XREF_OBJE;
 234   else if (!strcasecmp(str, "REPO"))
 235     xr->type = XREF_REPO;
 236   else if (!strcasecmp(str, "SOUR"))
 237     xr->type = XREF_SOUR;
 238   else if (!strcasecmp(str, "SUBM"))
 239     xr->type = XREF_SUBM;
 240   else if (!strcasecmp(str, "SUBN"))
 241     xr->type = XREF_SUBN;
 242   else
 243     xr->type = XREF_ANY;
 244 }
 245
 246 struct date_value* dup_date(struct date_value dv)
 247 {
 248   struct date_value* dv_ptr;
 249   dv_ptr = (struct date_value*) malloc(sizeof(struct date_value));
 250   if (! dv_ptr)
 251     MEMORY_ERROR;
 252   else {
 253     memcpy(dv_ptr, &dv, sizeof(struct date_value));
 254   }
 255   return dv_ptr;
 256 }
 257
 258 struct age_value* dup_age(struct age_value age)
 259 {
 260   struct age_value* age_ptr;
 261   age_ptr = (struct age_value*) malloc(sizeof(struct age_value));
 262   if (! age_ptr)
 263     MEMORY_ERROR;
 264   else {
 265     memcpy(age_ptr, &age, sizeof(struct age_value));
 266   }
 267   return age_ptr;
 268 }