gom/note.c

   1 /* Note sub-structure in 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 "header.h"
  27 #include "source_citation.h"
  28 #include "note.h"
  29 #include "note_sub.h"
  30 #include "user_ref.h"
  31 #include "change_date.h"
  32 #include "source.h"
  33 #include "user_rec.h"
  34 #include "gom.h"
  35 #include "gedcom.h"
  36 #include "gom_internal.h"
  37
  38 struct note* gom_first_note = NULL;
  39
  40 Gedcom_ctxt note_start(_REC_PARAMS_)
  41 {
  42   Gom_ctxt result = NULL;
  43   struct xref_value* xr = GEDCOM_XREF_PTR(xref);
  44   struct note* note = (struct note*) xr->object;
  45   if (! note) {
  46     note = make_note_record(xr->string);
  47     xr->object = (Gedcom_ctxt) note;
  48   }
  49   if (note) {
  50     note->text = strdup(GEDCOM_STRING(parsed_value));
  51     if (! note->text)
  52       MEMORY_ERROR;
  53     else
  54       result = MAKE_GOM_CTXT(rec, note, xr->object);
  55   }
  56   return (Gedcom_ctxt)result;
  57 }
  58
  59 GET_REC_BY_XREF(note, XREF_NOTE, gom_get_note_by_xref)
  60
  61 Gedcom_ctxt sub_cont_conc_start(_ELT_PARAMS_)
  62 {
  63   Gom_ctxt ctxt = (Gom_ctxt)parent;
  64   Gom_ctxt result = NULL;
  65
  66   if (! ctxt)
  67     NO_CONTEXT;
  68   else {
  69     char *str = GEDCOM_STRING(parsed_value);
  70     NL_TYPE type = (elt == ELT_SUB_CONT ? WITH_NL : WITHOUT_NL);
  71     switch (ctxt->ctxt_type) {
  72       case ELT_HEAD_NOTE:
  73         header_add_to_note(type, ctxt, str); break;
  74       case ELT_SUB_SOUR:
  75         citation_add_to_desc(type, ctxt, str); break;
  76       case ELT_SUB_SOUR_TEXT:
  77         citation_add_to_text(type, ctxt, str); break;
  78       case ELT_SUB_NOTE:
  79         note_sub_add_to_note(type, ctxt, str); break;
  80       case REC_NOTE:
  81         note_add_to_note(type, ctxt, str); break;
  82       case ELT_SOUR_AUTH:
  83       case ELT_SOUR_TITL:
  84       case ELT_SOUR_PUBL:
  85       case ELT_SOUR_TEXT:
  86         source_add_to_value(type, ctxt, str); break;
  87       default:
  88         UNEXPECTED_CONTEXT(ctxt->ctxt_type);
  89     }
  90     result = make_gom_ctxt(elt, ctxt->obj_type, ctxt->ctxt_ptr);
  91   }
  92   return (Gedcom_ctxt)result;
  93 }
  94
  95 void note_subscribe()
  96 {
  97   gedcom_subscribe_to_record(REC_NOTE, note_start, def_rec_end);
  98   gedcom_subscribe_to_element(ELT_SUB_CONT, sub_cont_conc_start, def_elt_end);
  99   gedcom_subscribe_to_element(ELT_SUB_CONC, sub_cont_conc_start, def_elt_end);
 100 }
 101
 102 void note_add_to_note(NL_TYPE type, Gom_ctxt ctxt, const char* str)
 103 {
 104   struct note *note = SAFE_CTXT_CAST(note, ctxt);
 105   if (note) {
 106     char *newvalue = concat_strings (type, note->text, str);
 107     if (newvalue)
 108       note->text = newvalue;
 109     else
 110       MEMORY_ERROR;
 111   }
 112 }
 113
 114 void note_add_citation(Gom_ctxt ctxt, struct source_citation* cit)
 115 {
 116   struct note *note = SAFE_CTXT_CAST(note, ctxt);
 117   if (note)
 118     LINK_CHAIN_ELT(source_citation, note->citation, cit);
 119 }
 120
 121 void note_add_user_ref(Gom_ctxt ctxt, struct user_ref_number* ref)
 122 {
 123   struct note *note = SAFE_CTXT_CAST(note, ctxt);
 124   if (note)
 125     LINK_CHAIN_ELT(user_ref_number, note->ref, ref);
 126 }
 127
 128 void note_set_record_id(Gom_ctxt ctxt, const char *rin)
 129 {
 130   struct note *note = SAFE_CTXT_CAST(note, ctxt);
 131   if (note) {
 132     note->record_id = strdup(rin);
 133     if (! note->record_id) MEMORY_ERROR;
 134   }
 135 }
 136
 137 void note_set_change_date(Gom_ctxt ctxt, struct change_date* chan)
 138 {
 139   struct note *note = SAFE_CTXT_CAST(note, ctxt);
 140   if (note)
 141     note->change_date = chan;
 142 }
 143
 144 void note_add_user_data(Gom_ctxt ctxt, struct user_data* data)
 145 {
 146   struct note *obj = SAFE_CTXT_CAST(note, ctxt);
 147   if (obj)
 148     LINK_CHAIN_ELT(user_data, obj->extra, data);
 149 }
 150
 151 void note_cleanup(struct note* note)
 152 {
 153   if (note) {
 154     SAFE_FREE(note->xrefstr);
 155     SAFE_FREE(note->text);
 156     DESTROY_CHAIN_ELTS(source_citation, note->citation, citation_cleanup);
 157     DESTROY_CHAIN_ELTS(user_ref_number, note->ref, user_ref_cleanup);
 158     SAFE_FREE(note->record_id);
 159     change_date_cleanup(note->change_date);
 160     DESTROY_CHAIN_ELTS(user_data, note->extra, user_data_cleanup);
 161   }
 162 }
 163
 164 void notes_cleanup()
 165 {
 166   DESTROY_CHAIN_ELTS(note, gom_first_note, note_cleanup);
 167 }
 168
 169 struct note* gom_get_first_note()
 170 {
 171   return gom_first_note;
 172 }
 173
 174 struct note* make_note_record(const char* xrefstr)
 175 {
 176   struct note* note = NULL;
 177   MAKE_CHAIN_ELT(note, gom_first_note, note);
 178   if (note) {
 179     note->xrefstr = strdup(xrefstr);
 180     if (! note->xrefstr) MEMORY_ERROR;
 181   }
 182   return note;
 183 }