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