t/src/dump_gom.c

   1 /* Test program for the Gedcom library.
   2    Copyright (C) 2001, 2002 The Genes Development Team
   3    This file is part of the Gedcom parser library.
   4    Contributed by Peter Verthez <Peter.Verthez@advalvas.be>, 2001.
   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 "dump_gom.h"
  25 #include "output.h"
  26 #include "gom.h"
  27 #include "gedcom.h"
  28
  29 char* make_prefix(int depth)
  30 {
  31   char* prefix = (char*)calloc(depth+1, sizeof(char));
  32   memset(prefix, ' ', depth);
  33   return prefix;
  34 }
  35
  36 void dump_xref(int st, int prefix_depth, struct xref_value* xr);
  37
  38 void dump_user_data(int st, int prefix_depth, struct user_data* data)
  39 {
  40   char* prefix = make_prefix(prefix_depth);
  41   if (data) {
  42     output(st, "\n");
  43     for (data; data; data = data->next) {
  44       output(st, "%sData: \n", prefix);
  45       output(st, "%s  %d, %s, %s\n", prefix, data->level, data->tag, data->str_value);
  46       output(st, "%s  reference: ", prefix);
  47       dump_xref(st, prefix_depth + 4, data->xref_value);
  48     }
  49   }
  50   else {
  51     output(st, "%p\n", data);
  52   }
  53   free(prefix);
  54 }
  55
  56 void dump_address(int st, int prefix_depth, struct address* addr)
  57 {
  58   char* prefix = make_prefix(prefix_depth);
  59   if (addr) {
  60     output(st, "\n");
  61     output(st, "%sFull label: %s\n", prefix, addr->full_label);
  62     output(st, "%sLine 1: %s\n", prefix, addr->line1);
  63     output(st, "%sLine 2: %s\n", prefix, addr->line2);
  64     output(st, "%sCity: %s\n", prefix, addr->city);
  65     output(st, "%sState: %s\n", prefix, addr->state);
  66     output(st, "%sPostal: %s\n", prefix, addr->postal);
  67     output(st, "%sCountry: %s\n", prefix, addr->country);
  68     output(st, "%sUser data:", prefix);
  69     dump_user_data(st, prefix_depth + 2, addr->extra);
  70   }
  71   else {
  72     output(st, "%p\n", addr);
  73   }
  74   free(prefix);
  75 }
  76
  77 void dump_date(int st, int prefix_depth, struct date_value* dv)
  78 {
  79   char* prefix = make_prefix(prefix_depth);
  80   if (dv) {
  81     output(st, "\n");
  82     output(st, "%stype: %d\n", prefix, dv->type);
  83     output(st, "%sdate1:\n", prefix);
  84     output(st, "%s  calendar type: %d\n", prefix, dv->date1.cal);
  85     output(st, "%s  day: %s\n", prefix, dv->date1.day_str);
  86     output(st, "%s  month: %s\n", prefix, dv->date1.month_str);
  87     output(st, "%s  year: %s\n", prefix, dv->date1.year_str);
  88     output(st, "%s  date type: %d\n", prefix, dv->date1.type);
  89     output(st, "%s  sdn1: %ld\n", prefix, dv->date1.sdn1);
  90     output(st, "%s  sdn2: %ld\n", prefix, dv->date1.sdn2);
  91     output(st, "%sdate2:\n", prefix);
  92     output(st, "%s  calendar type: %d\n", prefix, dv->date2.cal);
  93     output(st, "%s  day: %s\n", prefix, dv->date2.day_str);
  94     output(st, "%s  month: %s\n", prefix, dv->date2.month_str);
  95     output(st, "%s  year: %s\n", prefix, dv->date2.year_str);
  96     output(st, "%s  date type: %d\n", prefix, dv->date2.type);
  97     output(st, "%s  sdn1: %ld\n", prefix, dv->date2.sdn1);
  98     output(st, "%s  sdn2: %ld\n", prefix, dv->date2.sdn2);
  99     output(st, "%sphrase: %s\n", prefix, dv->phrase);
 100   }
 101   else {
 102     output(st, "%p\n", dv);
 103   }
 104   free(prefix);
 105 }
 106
 107 void dump_age(int st, int prefix_depth, struct age_value* age)
 108 {
 109   char* prefix = make_prefix(prefix_depth);
 110   if (age) {
 111     output(st, "\n");
 112     output(st, "%stype: %d\n", prefix, age->type);
 113     output(st, "%smodifier: %d\n", prefix, age->mod);
 114     output(st, "%syears: %d\n", prefix, age->years);
 115     output(st, "%smonths: %d\n", prefix, age->months);
 116     output(st, "%sdays: %d\n", prefix, age->days);
 117     output(st, "%sphrase: %s\n", prefix, age->phrase);
 118   }
 119   else {
 120     output(st, "%p\n", age);
 121   }
 122   free(prefix);
 123 }
 124
 125 void dump_xref(int st, int prefix_depth, struct xref_value* xr)
 126 {
 127   char* prefix = make_prefix(prefix_depth);
 128   if (xr) {
 129     output(st, "\n");
 130     output(st, "%stype: %d\n", prefix, xr->type);
 131     output(st, "%sxref: %s\n", prefix, xr->string);
 132     output(st, "%sobject: %p\n", prefix, xr->object);
 133   }
 134   else {
 135     output(st, "%p\n", xr);
 136   }
 137   free(prefix);
 138 }
 139
 140 void dump_xref_list(int st, int prefix_depth, struct xref_list* xr)
 141 {
 142   char* prefix = make_prefix(prefix_depth);
 143   if (xr) {
 144     output(st, "\n");
 145     for (xr; xr; xr = xr->next) {
 146       output(st, "%sreference: ", prefix);
 147       dump_xref(st, prefix_depth + 2, xr->xref);
 148       output(st, "%sUser data:", prefix);
 149       dump_user_data(st, prefix_depth + 2, xr->extra);
 150     }
 151   }
 152   else {
 153     output(st, "%p\n", xr);
 154   }
 155   free(prefix);
 156 }
 157
 158 void dump_texts(int st, int prefix_depth, struct text* t)
 159 {
 160   char* prefix = make_prefix(prefix_depth);
 161   if (t) {
 162     output(st, "\n");
 163     for (t; t; t = t->next) {
 164       output(st, "%sText: %s\n", prefix, t->text);
 165       output(st, "%sUser data:", prefix);
 166       dump_user_data(st, prefix_depth + 2, t->extra);
 167     }
 168   }
 169   else {
 170     output(st, "%p\n", t);
 171   }
 172   free(prefix);
 173 }
 174
 175 void dump_user_ref(int st, int prefix_depth, struct user_ref_number* ref)
 176 {
 177   char* prefix = make_prefix(prefix_depth);
 178   if (ref) {
 179     output(st, "\n");
 180     for (ref; ref; ref = ref->next) {
 181       output(st, "%sValue: %s\n", prefix, ref->value);
 182       output(st, "%sType: %s\n", prefix, ref->type);
 183       output(st, "%sUser data:", prefix);
 184       dump_user_data(st, prefix_depth + 2, ref->extra);
 185     }
 186   }
 187   else {
 188     output(st, "%p\n", ref);
 189   }
 190   free(prefix);
 191 }
 192
 193 void dump_citations(int st, int prefix_depth, struct source_citation* cit);
 194
 195 void dump_note_sub(int st, int prefix_depth, struct note_sub* note)
 196 {
 197   char* prefix = make_prefix(prefix_depth);
 198   if (note) {
 199     output(st, "\n");
 200     for (note; note; note = note->next) {
 201       output(st, "%sNote: \n", prefix);
 202       output(st, "%s  text: %s\n", prefix, note->text);
 203       output(st, "%s  reference: ", prefix);
 204       dump_xref(st, prefix_depth + 4, note->reference);
 205       output(st, "%s  citations: ", prefix);
 206       dump_citations(st, prefix_depth + 4, note->citation);
 207       output(st, "%s  User data:", prefix);
 208       dump_user_data(st, prefix_depth + 4, note->extra);
 209     }
 210   }
 211   else {
 212     output(st, "%p\n", note);
 213   }
 214   free(prefix);
 215 }
 216
 217 void dump_mm_links(int st, int prefix_depth, struct multimedia_link* link)
 218 {
 219   char* prefix = make_prefix(prefix_depth);
 220   if (link) {
 221     output(st, "\n");
 222     for (link; link; link = link->next) {
 223       output(st, "%slink: \n", prefix);
 224       output(st, "%s  reference: ", prefix);
 225       dump_xref(st, prefix_depth + 4, link->reference);
 226       output(st, "%s  Form: %s\n", prefix, link->form);
 227       output(st, "%s  Title: %s\n", prefix, link->title);
 228       output(st, "%s  File: %s\n", prefix, link->file);
 229       output(st, "%s  notes: ", prefix);
 230       dump_note_sub(st, prefix_depth + 4, link->note);
 231       output(st, "%s  User data:", prefix);
 232       dump_user_data(st, prefix_depth + 4, link->extra);
 233     }
 234   }
 235   else {
 236     output(st, "%p\n", link);
 237   }
 238   free(prefix);
 239 }
 240
 241 void dump_citations(int st, int prefix_depth, struct source_citation* cit)
 242 {
 243   char* prefix = make_prefix(prefix_depth);
 244   if (cit) {
 245     output(st, "\n");
 246     for (cit; cit; cit = cit->next) {
 247       output(st, "%sCitation: \n", prefix);
 248       output(st, "%s  description: %s\n", prefix, cit->description);
 249       output(st, "%s  reference: ", prefix);
 250       dump_xref(st, prefix_depth + 4, cit->reference);
 251       output(st, "%s  page: %s\n", prefix, cit->page);
 252       output(st, "%s  event: %s\n", prefix, cit->event);
 253       output(st, "%s  role: %s\n", prefix, cit->role);
 254       output(st, "%s  Date: ", prefix);
 255       dump_date(st, prefix_depth + 4, cit->date);
 256       output(st, "%s  texts: ", prefix, prefix);
 257       dump_texts(st, prefix_depth + 4, cit->text);
 258       output(st, "%s  quality: %s\n", prefix, cit->quality);
 259       output(st, "%s  multimedia links: ", prefix);
 260       dump_mm_links(st, prefix_depth + 4, cit->mm_link);
 261       output(st, "%s  notes: ", prefix);
 262       dump_note_sub(st, prefix_depth + 4, cit->note);
 263       output(st, "%s  User data:", prefix);
 264       dump_user_data(st, prefix_depth + 4, cit->extra);
 265     }
 266   }
 267   else {
 268     output(st, "%p\n", cit);
 269   }
 270   free(prefix);
 271 }
 272
 273 void dump_lds(int st, int prefix_depth, struct lds_event* lds)
 274 {
 275   char* prefix = make_prefix(prefix_depth);
 276   if (lds) {
 277     output(st, "\n");
 278     for (lds; lds; lds = lds->next) {
 279       output(st, "%sDate status: %s\n", prefix, lds->date);
 280       output(st, "%sDate: ", prefix);
 281       dump_date(st, prefix_depth + 2, lds->date);
 282       output(st, "%sTemple code: %s\n", prefix, lds->temple_code);
 283       output(st, "%sPlace living ordinance: %s\n", prefix,
 284              lds->place_living_ordinance);
 285       output(st, "%scitations: ", prefix);
 286       dump_citations(st, prefix_depth + 2, lds->citation);
 287       output(st, "%snotes: ", prefix);
 288       dump_note_sub(st, prefix_depth + 2, lds->note);
 289       output(st, "%sfamily: ", prefix);
 290       dump_xref(st, prefix_depth + 2, lds->family);
 291       output(st, "%sUser data:", prefix);
 292       dump_user_data(st, prefix_depth + 2, lds->extra);
 293     }
 294   }
 295   else {
 296     output(st, "%p\n", lds);
 297   }
 298   free(prefix);
 299 }
 300
 301 void dump_change_date(int st, int prefix_depth, struct change_date* chan)
 302 {
 303   char* prefix = make_prefix(prefix_depth);
 304   if (chan) {
 305     output(st, "\n");
 306     output(st, "%sDate: ", prefix);
 307     dump_date(st, prefix_depth + 2, chan->date);
 308     output(st, "%sTime: %s\n", prefix, chan->time);
 309     output(st, "%snotes: ", prefix);
 310     dump_note_sub(st, prefix_depth + 2, chan->note);
 311     output(st, "%sUser data:", prefix);
 312     dump_user_data(st, prefix_depth + 2, chan->extra);
 313   }
 314   else {
 315     output(st, "%p\n", chan);
 316   }
 317   free(prefix);
 318 }
 319
 320 void dump_personal_name(int st, int prefix_depth, struct personal_name* name)
 321 {
 322   char* prefix = make_prefix(prefix_depth);
 323   if (name) {
 324     output(st, "\n");
 325     for (name; name; name = name->next) {
 326       output(st, "%sName: \n", prefix);
 327       output(st, "%s  Name: %s\n", prefix, name->name);
 328       output(st, "%s  Prefix: %s\n", prefix, name->prefix);
 329       output(st, "%s  Given: %s\n", prefix, name->given);
 330       output(st, "%s  Nickname: %s\n", prefix, name->nickname);
 331       output(st, "%s  Surname prefix: %s\n", prefix, name->surname_prefix);
 332       output(st, "%s  Surname: %s\n", prefix, name->surname);
 333       output(st, "%s  Suffix: %s\n", prefix, name->suffix);
 334       output(st, "%s  citations: ", prefix);
 335       dump_citations(st, prefix_depth + 4, name->citation);
 336       output(st, "%s  notes: ", prefix);
 337       dump_note_sub(st, prefix_depth + 4, name->note);
 338       output(st, "%s  User data:", prefix);
 339       dump_user_data(st, prefix_depth + 4, name->extra);
 340     }
 341   }
 342   else {
 343     output(st, "%p\n", name);
 344   }
 345   free(prefix);
 346 }
 347
 348 void dump_pedigree(int st, int prefix_depth, struct pedigree* p)
 349 {
 350   char* prefix = make_prefix(prefix_depth);
 351   if (p) {
 352     output(st, "\n");
 353     for (p; p; p = p->next) {
 354       output(st, "%sPedigree: %s\n", prefix, p->pedigree);
 355       output(st, "%sUser data:", prefix);
 356       dump_user_data(st, prefix_depth + 2, p->extra);
 357     }
 358   }
 359   else {
 360     output(st, "%p\n", p);
 361   }
 362   free(prefix);
 363 }
 364
 365 void dump_family_link(int st, int prefix_depth, struct family_link *link)
 366 {
 367   char* prefix = make_prefix(prefix_depth);
 368   if (link) {
 369     output(st, "\n");
 370     for (link; link; link = link->next) {
 371       output(st, "%sFamily:\n", prefix);
 372       output(st, "%s  Family: ", prefix);
 373       dump_xref(st, prefix_depth + 4, link->family);
 374       output(st, "%s  pedigrees: ", prefix);
 375       dump_pedigree(st, prefix_depth + 4, link->pedigree);
 376       output(st, "%s  notes: ", prefix);
 377       dump_note_sub(st, prefix_depth + 4, link->note);
 378       output(st, "%s  User data:", prefix);
 379       dump_user_data(st, prefix_depth + 4, link->extra);
 380     }
 381   }
 382   else {
 383     output(st, "%p\n", link);
 384   }
 385   free(prefix);
 386 }
 387
 388 void dump_association(int st, int prefix_depth, struct association *assoc)
 389 {
 390   char* prefix = make_prefix(prefix_depth);
 391   if (assoc) {
 392     output(st, "\n");
 393     for (assoc; assoc; assoc = assoc->next) {
 394       output(st, "%sAssociation:\n", prefix);
 395       output(st, "%s  To:\n", prefix);
 396       dump_xref(st, prefix_depth + 4, assoc->to);
 397       output(st, "%s  Type: %s\n", prefix, assoc->type);
 398       output(st, "%s  Relation: %s\n", assoc->relation);
 399       output(st, "%s  citations: ", prefix);
 400       dump_citations(st, prefix_depth + 4, assoc->citation);
 401       output(st, "%s  notes: ", prefix);
 402       dump_note_sub(st, prefix_depth + 4, assoc->note);
 403       output(st, "%s  User data:", prefix);
 404       dump_user_data(st, prefix_depth + 4, assoc->extra);
 405     }
 406   }
 407   else {
 408     output(st, "%p\n", assoc);
 409   }
 410   free(prefix);
 411 }
 412
 413 void dump_place(int st, int prefix_depth, struct place* place)
 414 {
 415   char* prefix = make_prefix(prefix_depth);
 416   if (place) {
 417     output(st, "\n");
 418     output(st, "%svalue: %s\n", prefix, place->value);
 419     output(st, "%splace_hierarchy: %s\n", prefix, place->place_hierarchy);
 420     output(st, "%scitations: ", prefix);
 421     dump_citations(st, prefix_depth + 2, place->citation);
 422     output(st, "%snotes: ", prefix);
 423     dump_note_sub(st, prefix_depth + 2, place->note);
 424     output(st, "%sUser data:", prefix);
 425     dump_user_data(st, prefix_depth + 2, place->extra);
 426   }
 427   else {
 428     output(st, "%p\n", place);
 429   }
 430   free(prefix);
 431 }
 432
 433 void dump_source_events(int st, int prefix_depth, struct source_event* evt)
 434 {
 435   char* prefix = make_prefix(prefix_depth);
 436   if (evt) {
 437     output(st, "\n");
 438     for (evt; evt; evt = evt->next) {
 439       output(st, "%sEvent:\n", prefix);
 440       output(st, "%s  Recorded events: %s\n", prefix, evt->recorded_events);
 441       output(st, "%s  Date period: ", prefix);
 442       dump_date(st, prefix_depth + 4, evt->date_period);
 443       output(st, "%s  Jurisdiction: %s\n", prefix, evt->jurisdiction);
 444       output(st, "%s  User data:", prefix);
 445       dump_user_data(st, prefix_depth + 4, evt->extra);
 446     }
 447   }
 448   else {
 449     output(st, "%p\n", evt);
 450   }
 451   free(prefix);
 452 }
 453
 454 void dump_source_descriptions(int st, int prefix_depth,
 455                               struct source_description* desc)
 456 {
 457   char* prefix = make_prefix(prefix_depth);
 458   if (desc) {
 459     output(st, "\n");
 460     for (desc; desc; desc = desc->next) {
 461       output(st, "%sSource description:\n", prefix);
 462       output(st, "%s  Call number: %s\n", prefix, desc->call_number);
 463       output(st, "%s  Media: %s\n", prefix, desc->media);
 464       output(st, "%s  User data:", prefix);
 465       dump_user_data(st, prefix_depth + 4, desc->extra);
 466     }
 467   }
 468   else {
 469     output(st, "%p\n", desc);
 470   }
 471   free(prefix);
 472 }
 473
 474 void dump_events(int st, int prefix_depth, struct event *evt)
 475 {
 476   char* prefix = make_prefix(prefix_depth);
 477   if (evt) {
 478     output(st, "\n");
 479     for (evt; evt; evt = evt->next) {
 480       output(st, "%sEvent: %d (%s)\n", prefix, evt->event, evt->event_name);
 481       output(st, "%s  Value: %s\n", prefix, evt->val);
 482       output(st, "%s  Type: %s\n", prefix, evt->type);
 483       output(st, "%s  Date: ", prefix);
 484       dump_date(st, prefix_depth + 4, evt->date);
 485       output(st, "%s  Place: ", prefix);
 486       dump_place(st, prefix_depth + 4, evt->place);
 487       output(st, "%s  Address: ", prefix);
 488       dump_address(st, prefix_depth + 4, evt->address);
 489       output(st, "%s  Phone 1: %s\n", prefix, evt->phone[0]);
 490       output(st, "%s  Phone 2: %s\n", prefix, evt->phone[1]);
 491       output(st, "%s  Phone 3: %s\n", prefix, evt->phone[2]);
 492       output(st, "%s  Age: ", prefix);
 493       dump_age(st, prefix_depth + 4, evt->age);
 494       output(st, "%s  Agency: %s\n", prefix, evt->agency);
 495       output(st, "%s  Cause: %s\n", prefix, evt->cause);
 496       output(st, "%s  citations: ", prefix);
 497       dump_citations(st, prefix_depth + 4, evt->citation);
 498       output(st, "%s  multimedia links: ", prefix);
 499       dump_mm_links(st, prefix_depth + 4, evt->mm_link);
 500       output(st, "%s  notes: ", prefix);
 501       dump_note_sub(st, prefix_depth + 4, evt->note);
 502       output(st, "%s  Age of husband: ", prefix);
 503       dump_age(st, prefix_depth + 4, evt->husband_age);
 504       output(st, "%s  Age of wife: ", prefix);
 505       dump_age(st, prefix_depth + 4, evt->wife_age);
 506       output(st, "%s  Family: ", prefix);
 507       dump_xref(st, prefix_depth + 4, evt->family);
 508       output(st, "%s  Adoption parent: %s\n", prefix, evt->adoption_parent);
 509       output(st, "%s  User data:", prefix);
 510       dump_user_data(st, prefix_depth + 4, evt->extra);
 511     }
 512   }
 513   else {
 514     output(st, "%p\n", evt);
 515   }
 516   free(prefix);
 517 }
 518
 519 void dump_header()
 520 {
 521   struct header* header = gom_get_header();
 522   output(1, "=== HEADER ===\n");
 523   output(0, "Source:\n");
 524   output(0, "  ID: %s\n", header->source.id);
 525   output(0, "  Name: %s\n", header->source.name);
 526   output(0, "  Version: %s\n", header->source.version);
 527   output(0, "  Corporation:\n");
 528   output(0, "    Name: %s\n", header->source.corporation.name);
 529   output(0, "    Address: ");
 530   dump_address(0, 6, header->source.corporation.address);
 531   output(0, "    Phone 1: %s\n", header->source.corporation.phone[0]);
 532   output(0, "    Phone 2: %s\n", header->source.corporation.phone[1]);
 533   output(0, "    Phone 3: %s\n", header->source.corporation.phone[2]);
 534   output(0, "  Data:\n");
 535   output(0, "    Name: %s\n", header->source.data.name);
 536   output(0, "    Date: ");
 537   dump_date(0, 6, header->source.data.date);
 538   output(0, "    Copyright: %s\n", header->source.data.copyright);
 539   output(0, "Destination: %s\n", header->destination);
 540   output(0, "Date: ");
 541   dump_date(0, 2, header->date);
 542   output(0, "Time: %s\n", header->time);
 543   output(0, "Submitter: ");
 544   dump_xref(0, 2, header->submitter);
 545   output(0, "Submission: ");
 546   dump_xref(0, 2, header->submission);
 547   output(0, "File name: %s\n", header->filename);
 548   output(0, "Copyright: %s\n", header->copyright);
 549   output(0, "Gedcom:\n");
 550   output(0, "  Version: %s\n", header->gedcom.version);
 551   output(0, "  Form: %s\n", header->gedcom.form);
 552   output(0, "Character set:\n");
 553   output(0, "  Name: %s\n", header->charset.name);
 554   output(0, "  Version: %s\n", header->charset.version);
 555   output(0, "Language: %s\n", header->language);
 556   output(0, "Place hierarchy: %s\n", header->place_hierarchy);
 557   output(0, "Note:\n");
 558   output(0, "====\n");
 559   output(0, "%s\n", header->note);
 560   output(0, "====\n");
 561   output(0, "User data:");
 562   dump_user_data(0, 2, header->extra);
 563 }
 564
 565 void dump_submission()
 566 {
 567   struct submission* subn = gom_get_submission();
 568   if (subn) {
 569     output(1, "=== SUBMISSION (%s) ===\n", subn->xrefstr);
 570     output(0, "Submitter: ");
 571     dump_xref(0, 2, subn->submitter);
 572     output(0, "Family file: %s\n", subn->family_file);
 573     output(0, "Temple code: %s\n", subn->temple_code);
 574     output(0, "Nr of ancestor generations: %s\n", subn->nr_of_ancestor_gens);
 575     output(0, "Nr of descendant generations: %s\n",
 576            subn->nr_of_descendant_gens);
 577     output(0, "Ordinance process flag: %s\n", subn->ordinance_process_flag);
 578     output(0, "Record id: %s\n", subn->record_id);
 579     output(0, "User data:");
 580     dump_user_data(0, 2, subn->extra);
 581   }
 582 }
 583
 584 void dump_families()
 585 {
 586   struct family* fam = gom_get_first_family();
 587   for (fam; fam; fam = fam->next) {
 588     output(1, "=== FAMILY (%s) ===\n", fam->xrefstr);
 589     output(0, "Family events: ");
 590     dump_events(0, 2, fam->event);
 591     output(0, "Husband: ");
 592     dump_xref(0, 2, fam->husband);
 593     output(0, "Wife: ");
 594     dump_xref(0, 2, fam->wife);
 595     output(0, "Children: ");
 596     dump_xref_list(0, 2, fam->children);
 597     output(0, "Number of children: %s\n", fam->nr_of_children);
 598     output(0, "Submitters: ");
 599     dump_xref_list(0, 2, fam->submitters);
 600     output(0, "LDS spouse sealings: ");
 601     dump_lds(0, 2, fam->lds_spouse_sealing);
 602     output(0, "citations: ");
 603     dump_citations(0, 2, fam->citation);
 604     output(0, "multimedia links: ");
 605     dump_mm_links(0, 2, fam->mm_link);
 606     output(0, "notes: ");
 607     dump_note_sub(0, 2, fam->note);
 608     output(0, "user refs: ");
 609     dump_user_ref(0, 2, fam->ref);
 610     output(0, "Record ID: %s\n", fam->record_id);
 611     output(0, "change date: ");
 612     dump_change_date(0, 2, fam->change_date);
 613     output(0, "User data:");
 614     dump_user_data(0, 2, fam->extra);
 615   }
 616 }
 617
 618 void dump_individuals()
 619 {
 620   struct individual* indiv = gom_get_first_individual();
 621   for (indiv; indiv; indiv = indiv->next) {
 622     output(1, "=== INDIVIDUAL (%s) ===\n", indiv->xrefstr);
 623     output(0, "Restriction notice: %s\n", indiv->restriction_notice);
 624     output(0, "names: ");
 625     dump_personal_name(0, 2, indiv->name);
 626     output(0, "Sex: %s\n", indiv->sex);
 627     output(0, "Individual events: ");
 628     dump_events(0, 2, indiv->event);
 629     output(0, "Individual attributes: ");
 630     dump_events(0, 2, indiv->attribute);
 631     output(0, "LDS individual ordinance: ");
 632     dump_lds(0, 2, indiv->lds_individual_ordinance);
 633     output(0, "Child to family links: ");
 634     dump_family_link(0, 2, indiv->child_to_family);
 635     output(0, "Spouse to family links: ");
 636     dump_family_link(0, 2, indiv->spouse_to_family);
 637     output(0, "Submitters: ");
 638     dump_xref_list(0, 2, indiv->submitters);
 639     output(0, "Associations: ");
 640     dump_association(0, 2, indiv->association);
 641     output(0, "Aliases: ");
 642     dump_xref_list(0, 2, indiv->alias);
 643     output(0, "Ancestor interest: ");
 644     dump_xref_list(0, 2, indiv->ancestor_interest);
 645     output(0, "Descendant interest: ");
 646     dump_xref_list(0, 2, indiv->descendant_interest);
 647     output(0, "citations: ");
 648     dump_citations(0, 2, indiv->citation);
 649     output(0, "multimedia links: ");
 650     dump_mm_links(0, 2, indiv->mm_link);
 651     output(0, "notes: ");
 652     dump_note_sub(0, 2, indiv->note);
 653     output(0, "Record file nr: %s\n", indiv->record_file_nr);
 654     output(0, "Ancestral file nr: %s\n", indiv->ancestral_file_nr);
 655     output(0, "user refs: ");
 656     dump_user_ref(0, 2, indiv->ref);
 657     output(0, "Record ID: %s\n", indiv->record_id);
 658     output(0, "change date: ");
 659     dump_change_date(0, 2, indiv->change_date);
 660     output(0, "User data:");
 661     dump_user_data(0, 2, indiv->extra);
 662   }
 663 }
 664
 665 void dump_multimedia()
 666 {
 667   struct multimedia* obj = gom_get_first_multimedia();
 668   for (obj; obj; obj = obj->next) {
 669     output(1, "=== MULTIMEDIA (%s) ===\n", obj->xrefstr);
 670     output(0, "Form: %s\n", obj->form);
 671     output(0, "Title: %s\n", obj->title);
 672     output(0, "notes: ");
 673     dump_note_sub(0, 2, obj->note);
 674     output(0, "Data: %s\n", obj->data);
 675     output(0, "Continued: ");
 676     dump_xref(0, 2, obj->continued);
 677     output(0, "user refs: ");
 678     dump_user_ref(0, 2, obj->ref);
 679     output(0, "Record ID: %s\n", obj->record_id);
 680     output(0, "change date: ");
 681     dump_change_date(0, 2, obj->change_date);
 682     output(0, "User data:");
 683     dump_user_data(0, 2, obj->extra);
 684   }
 685 }
 686
 687 void dump_notes()
 688 {
 689   struct note* note = gom_get_first_note();
 690   for (note; note; note = note->next) {
 691     output(1, "=== NOTE (%s) ===\n", note->xrefstr);
 692     output(0, "Text: %s\n", note->text);
 693     output(0, "citations: ");
 694     dump_citations(0, 2, note->citation);
 695     output(0, "user refs: ");
 696     dump_user_ref(0, 2, note->ref);
 697     output(0, "Record ID: %s\n", note->record_id);
 698     output(0, "change date: ");
 699     dump_change_date(0, 2, note->change_date);
 700     output(0, "User data:");
 701     dump_user_data(0, 2, note->extra);
 702   }
 703 }
 704
 705 void dump_repositories()
 706 {
 707   struct repository* repo = gom_get_first_repository();
 708   for (repo; repo; repo = repo->next) {
 709     output(1, "=== REPOSITORY (%s) ===\n", repo->xrefstr);
 710     output(0, "Name: %s\n", repo->name);
 711     output(0, "Address: ");
 712     dump_address(0, 2, repo->address);
 713     output(0, "Phone 1: %s\n", repo->phone[0]);
 714     output(0, "Phone 2: %s\n", repo->phone[1]);
 715     output(0, "Phone 3: %s\n", repo->phone[2]);
 716     output(0, "notes: ");
 717     dump_note_sub(0, 2, repo->note);
 718     output(0, "user refs: ");
 719     dump_user_ref(0, 2, repo->ref);
 720     output(0, "Record ID: %s\n", repo->record_id);
 721     output(0, "change date: ");
 722     dump_change_date(0, 2, repo->change_date);
 723     output(0, "User data:");
 724     dump_user_data(0, 2, repo->extra);
 725   }
 726 }
 727
 728 void dump_sources()
 729 {
 730   struct source* sour = gom_get_first_source();
 731   for (sour; sour; sour = sour->next) {
 732     output(1, "=== SOURCE (%s) ===\n", sour->xrefstr);
 733     output(0, "Data: \n");
 734     output(0, "  events: ");
 735     dump_source_events(0, 4, sour->data.event);
 736     output(0, "  Agency: %s\n", sour->data.agency);
 737     output(0, "  notes: ");
 738     dump_note_sub(0, 4, sour->data.note);
 739     output(0, "Author: %s\n", sour->author);
 740     output(0, "Title: %s\n", sour->title);
 741     output(0, "Abbreviation: %s\n", sour->abbreviation);
 742     output(0, "Publication: %s\n", sour->publication);
 743     output(0, "Text: %s\n", sour->text);
 744     output(0, "Repository:\n");
 745     output(0, "  Link: ");
 746     dump_xref(0, 4, sour->repository.link);
 747     output(0, "  notes: ");
 748     dump_note_sub(0, 4, sour->repository.note);
 749     output(0, "  source descriptions: ");
 750     dump_source_descriptions(0, 4, sour->repository.description);
 751     output(0, "multimedia links: ");
 752     dump_mm_links(0, 2, sour->mm_link);
 753     output(0, "notes: ");
 754     dump_note_sub(0, 2, sour->note);
 755     output(0, "user refs: ");
 756     dump_user_ref(0, 2, sour->ref);
 757     output(0, "Record ID: %s\n", sour->record_id);
 758     output(0, "change date: ");
 759     dump_change_date(0, 2, sour->change_date);
 760     output(0, "User data:");
 761     dump_user_data(0, 2, sour->extra);
 762   }
 763 }
 764
 765 void dump_submitters()
 766 {
 767   struct submitter* subm = gom_get_first_submitter();
 768   for (subm; subm; subm = subm->next) {
 769     output(1, "=== SUBMITTER (%s) ===\n", subm->xrefstr);
 770     output(0, "Name: %s\n", subm->name);
 771     output(0, "Address: ");
 772     dump_address(0, 2, subm->address);
 773     output(0, "Phone 1: %s\n", subm->phone[0]);
 774     output(0, "Phone 2: %s\n", subm->phone[1]);
 775     output(0, "Phone 3: %s\n", subm->phone[2]);
 776     output(0, "multimedia links: ");
 777     dump_mm_links(0, 2, subm->mm_link);
 778     output(0, "Language 1: %s\n", subm->language[0]);
 779     output(0, "Language 2: %s\n", subm->language[1]);
 780     output(0, "Language 3: %s\n", subm->language[2]);
 781     output(0, "Record file nr: %s\n", subm->record_file_nr);
 782     output(0, "Record ID: %s\n", subm->record_id);
 783     output(0, "change date: ");
 784     dump_change_date(0, 2, subm->change_date);
 785     output(0, "User data:");
 786     dump_user_data(0, 2, subm->extra);
 787   }
 788 }
 789
 790 void dump_user_records()
 791 {
 792   struct user_rec* rec = gom_get_first_user_rec();
 793   for (rec; rec; rec = rec->next) {
 794     output(1, "=== USER RECORD (%s) ===\n", rec->xrefstr);
 795     output(0, "Tag: %s\n", rec->tag);
 796     output(0, "String value: %s\n", rec->str_value);
 797     output(0, "Xref value: ");
 798     dump_xref(0, 2, rec->xref_value);
 799     output(0, "User data:");
 800     dump_user_data(0, 2, rec->extra);
 801   }
 802 }
 803
 804 void show_data()
 805 {
 806   dump_header();
 807   dump_submission();
 808   dump_families();
 809   dump_individuals();
 810   dump_multimedia();
 811   dump_notes();
 812   dump_repositories();
 813   dump_sources();
 814   dump_submitters();
 815   dump_user_records();
 816 }