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