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