← Back to branch summary

~ubuntu-branches/ubuntu/trusty/lifelines/trusty

« back to all changes in this revision

Viewing changes to src/hdrs/gedcom.h

  • Committer: Bazaar Package Importer
  • Author(s): Felipe Augusto van de Wiel (faw)
  • Date: 2007-05-23 23:49:53 UTC
  • mfrom: (3.1.3 edgy)
  • Revision ID: james.westby@ubuntu.com-20070523234953-ogno9rnbmth61i7p
Tags: 3.0.50-2etch1
http://bugs.debian.org/418347
http://bugs.debian.org/405500
http://bugs.debian.org/356671
* Changing docs/ll-reportmanual.xml and docs/ll-userguide.xml to fix
  documentation build problems (Closes: #418347).

* lifelines-reports
  - Adding a dependency to lifelines >= 3.0.50 to prevent file conflict.
    (Closes: #405500).

* Updating French translation. Thanks to Bernard Adrian. (Closes: #356671).

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/hdrs/gedcom.h
44
44
#define NAMESEP '/'
45
45
#define MAXGEDNAMELEN 512
46
46
/* keys run up to 9,999,999, eg I9999999 */
 
47
/* These are GEDCOM identifier numbers, eg, for @I510@,
 
48
 the key is 510 */
 
49
/* btree databases use this as part of the database key */
47
50
#define MAXKEYWIDTH 8
 
51
#define MAXKEYNUMBER 9999999
48
52
 
49
53
#define OKAY  1
50
54
#define ERROR 0
66
70
 its NODE tree). (E.g., its parent might be a NODE representing
67
71
 "1 BIRT".)
68
72
*/
 
73
typedef struct tag_cacheel *CACHEEL;
69
74
typedef struct tag_node *NODE;
70
 
typedef struct tag_record *RECORD;
71
75
struct tag_node {
 
76
        /* a NODE is an OBJECT */
 
77
        struct tag_vtable * vtable; /* generic object table (see vtable.h) */
 
78
        int    n_refcnt;    /* refcount for temp nodes */
72
79
        STRING n_xref;      /* cross ref */
73
80
        STRING n_tag;       /* tag */
74
81
        STRING n_val;       /* value */
76
83
        NODE   n_child;     /* first child */
77
84
        NODE   n_sibling;   /* sibling */
78
85
        INT    n_flag;      /* eg, ND_TEMP */
79
 
        int    n_refcnt;    /* refcount for temp nodes */
80
 
        RECORD n_rec;       /* pointer to record, if in a record's node tree */
 
86
        CACHEEL n_cel;      /* pointer to cacheel, if node is inside cache */
81
87
};
82
88
#define nxref(n)    ((n)->n_xref)
83
89
#define ntag(n)     ((n)->n_tag)
89
95
#define nrefcnt(n)  ((n)->n_refcnt)
90
96
enum { ND_TEMP=1 };
91
97
 
92
 
struct tag_nkey { char ntype; INT keynum; STRING key; };
 
98
struct tag_nkey { char ntype; INT keynum; char key[MAXKEYWIDTH+1]; };
93
99
typedef struct tag_nkey NKEY;
94
100
 
95
101
/*=====================================
104
110
 LifeLines is very RECORD-oriented.
105
111
*/
106
112
 
107
 
struct tag_record { /* RECORD */
108
 
        NODE top;
109
 
        NKEY nkey;
110
 
        WAREHOUSE mdwh; /* metadata */
111
 
        struct tag_cacheel * cel; /* cache wrapper */
112
 
};
113
 
NODE nztop(RECORD); /* function so it can handle NULL input */
114
 
#define nzkey(n)    ((n)->nkey.key)
115
 
#define nzkeynum(n) ((n)->nkey.keynum)
116
 
#define nztype(n)   ((n)->nkey.ntype)
 
113
typedef struct tag_record *RECORD;
 
114
 
 
115
NODE nztop(RECORD rec); /* handles NULL, also reloads from cache */
 
116
CNSTRING nzkey(RECORD rec);
 
117
INT nzkeynum(RECORD rec);
 
118
char nztype(RECORD rec);
 
119
CACHEEL nzcel(RECORD rec);
 
120
 
 
121
/*=====================================
 
122
 * LLDATABASE types -- LifeLines database
 
123
 *===================================*/
 
124
 
 
125
typedef struct tag_lldatabase *LLDATABASE;
117
126
 
118
127
/*
119
128
 reformating functions - format date or place for display
178
187
extern BOOLEAN immutable;
179
188
extern STRING editstr;
180
189
extern STRING editfile;
 
190
/* tabtable & placabbvs should be moved into LLDATABASE */
181
191
extern TABLE tagtable;          /* table for GEDCOM tags */
182
192
extern TABLE placabbvs;         /* table for place abbrvs */
 
193
extern LLDATABASE def_lldb;        /* default database */
183
194
 
184
195
 
185
196
/*=====================
193
204
 *===================*/
194
205
 
195
206
STRING addat(STRING);
196
 
void addixref(INT);
197
 
void addexref(INT);
198
 
void addfxref(INT);
199
 
void addsxref(INT);
200
 
void addxxref(INT);
201
 
BOOLEAN add_refn(STRING, STRING);
 
207
void addixref(INT key);
 
208
void addexref(INT key);
 
209
void addfxref(INT key);
 
210
void addref_record(RECORD rec);
 
211
void addsxref(INT key);
 
212
void addxref(CNSTRING key);
 
213
void addxxref(INT key);
 
214
BOOLEAN add_refn(CNSTRING refn, CNSTRING key);
202
215
BOOLEAN are_locales_supported(void);
 
216
void change_node_tag(NODE node, STRING newtag);
203
217
RECORD choose_child(RECORD irec, RECORD frec, STRING msg0, STRING msgn, ASK1Q ask1);
204
218
void choose_and_remove_family(void);
205
219
RECORD choose_father(RECORD irec, RECORD frec, STRING msg0, STRING msgn, ASK1Q ask1);
212
226
void classify_nodes(NODE*, NODE*, NODE*);
213
227
void closexref(void);
214
228
void close_lifelines(void);
215
 
void close_lldb(void);
216
229
NODE convert_first_fp_to_node(FILE*, BOOLEAN, XLAT, STRING*, BOOLEAN*);
217
230
NODE copy_node(NODE);
218
 
NODE copy_nodes(NODE, BOOLEAN, BOOLEAN);
 
231
NODE copy_node_subtree(NODE node);
 
232
NODE copy_nodes(NODE node, BOOLEAN kids, BOOLEAN sibs);
219
233
BOOLEAN create_database(STRING dbused);
220
 
RECORD create_record(NODE node);
221
234
NODE create_node(STRING, STRING, STRING, NODE);
222
235
NODE create_temp_node(STRING, STRING, STRING, NODE);
223
 
void del_in_dbase(STRING key);
224
236
void delete_metarec(STRING key);
225
237
BOOLEAN edit_mapping(INT);
226
 
BOOLEAN edit_valtab_from_db(STRING, TABLE*, INT sep, STRING, STRING (*validator)(TABLE tab));
 
238
BOOLEAN edit_valtab_from_db(STRING, TABLE*, INT sep, STRING, STRING (*validator)(TABLE tab, void * param), void *param);
227
239
BOOLEAN equal_tree(NODE, NODE);
228
240
BOOLEAN equal_node(NODE, NODE);
229
241
BOOLEAN equal_nodes(NODE, NODE, BOOLEAN, BOOLEAN);
241
253
NODE fam_to_last_chil(NODE);
242
254
STRING fam_to_list_string(NODE fam, INT len, STRING delim);
243
255
NODE fam_to_spouse(NODE, NODE);
 
256
int next_spouse(NODE *node, RECORD *spouse);
244
257
RECORD file_to_record(STRING fname, XLAT ttm, STRING *pmsg, BOOLEAN *pemp);
245
258
NODE file_to_node(STRING, XLAT, STRING*, BOOLEAN*);
246
259
INT file_to_line(FILE*, XLAT, INT*, STRING*, STRING*, STRING*, STRING*);
247
260
NODE find_node(NODE, STRING, STRING, NODE*);
248
261
NODE find_tag(NODE, CNSTRING);
249
 
void free_rec(RECORD);
250
262
void free_node(NODE);
251
263
void free_nodes(NODE);
252
264
void free_temp_node_tree(NODE);
255
267
ZSTR get_cache_stats_indi(void);
256
268
STRING get_current_locale_collate(void);
257
269
STRING get_current_locale_msgs(void);
258
 
INT get_dblist(STRING path, LIST * dblist, LIST * dbdesclist);
259
270
INT get_decimal(STRING);
260
271
INT get_hexidecimal(STRING);
261
272
STRING get_lifelines_version(INT maxlen);
268
279
INT getixrefnum(void);
269
280
STRING getsxref(void);
270
281
STRING getxxref(void);
271
 
BOOLEAN getrefnrec(STRING);
 
282
BOOLEAN getrefnrec(CNSTRING refn);
272
283
void growexrefs(void);
273
284
void growfxrefs(void);
274
285
void growixrefs(void);
275
286
void growsxrefs(void);
276
287
void growxxrefs(void);
277
288
INT hexvalue(INT);
278
 
BOOLEAN in_string(INT, STRING);
279
289
void index_by_refn(NODE, STRING);
280
 
void indi_to_cache(RECORD rec);
281
 
void indi_to_cache_old(NODE);
282
290
void indi_to_dbase(NODE);
283
291
STRING indi_to_event(NODE, STRING tag, STRING head, INT len, RFMT);
284
292
NODE indi_to_famc(NODE);
296
304
void init_caches(void);
297
305
void free_caches(void);
298
306
void init_disp_reformat(void);
299
 
BOOLEAN init_lifelines_db(void);
 
307
BOOLEAN init_lifelines_postdb(void);
300
308
BOOLEAN init_lifelines_global(STRING configfile, STRING * pmsg, void (*notify)(STRING db, BOOLEAN opening));
301
309
CNSTRING init_get_config_file(void);
302
 
void init_new_record(RECORD rec, char ntype, INT keynum);
 
310
void init_new_record(RECORD rec, CNSTRING key);
303
311
BOOLEAN init_valtab_from_file(STRING, TABLE, XLAT, INT sep, STRING*);
304
312
BOOLEAN init_valtab_from_rec(CNSTRING, TABLE, INT sep, STRING*);
305
313
BOOLEAN init_valtab_from_string(CNSTRING, TABLE, INT sep, STRING*);
306
 
BOOLEAN is_db_open(void);
307
314
BOOLEAN is_codeset_utf8(CNSTRING codeset);
308
315
BOOLEAN is_iconv_supported(void);
309
316
BOOLEAN is_nls_supported(void);
 
317
BOOLEAN is_record_missing_data_entry(CNSTRING key);
310
318
BOOLEAN is_temp_node(NODE);
311
319
BOOLEAN iso_list(NODE, NODE);
312
320
BOOLEAN iso_nodes(NODE, NODE, BOOLEAN, BOOLEAN);
369
377
NODE node_to_node(NODE, INT*);
370
378
RECORD node_to_record(NODE node);
371
379
STRING node_to_tag(NODE node, STRING tag, INT len);
 
380
void normalize_fam(NODE fam);
 
381
void normalize_irec(RECORD irec);
 
382
void normalize_indi(NODE indi);
 
383
void normalize_rec(RECORD rec);
372
384
INT num_evens(void);
373
385
INT num_fam_xrefs(NODE fam);
374
386
INT num_fams(void);
381
393
STRING other_to_list_string(NODE node, INT len, STRING delim);
382
394
void othr_to_cache(NODE);
383
395
void othr_to_dbase(NODE);
384
 
BOOLEAN place_to_list(STRING, LIST, INT*);
385
396
BOOLEAN pointer_value(STRING);
386
397
NODE qkey_to_even(CNSTRING key);
387
398
RECORD qkey_to_erecord(CNSTRING key);
403
414
NODE refn_to_record(STRING, INT);
404
415
void register_uicodeset_callback(CALLBACK_FNC fncptr, VPTR uparm);
405
416
void register_uilang_callback(CALLBACK_FNC fncptr, VPTR uparm);
406
 
void release_dblist(LIST dblist);
 
417
void release_record(RECORD rec);
407
418
BOOLEAN remove_child(NODE indi, NODE fam);
408
419
BOOLEAN remove_empty_fam(NODE);
409
 
void remove_indi(NODE);
410
 
void remove_indi_cache(STRING);
411
 
void remove_fam_cache(STRING);
 
420
BOOLEAN remove_any_record(RECORD record);
 
421
void remove_indi_by_root(NODE);
 
422
void remove_indi_cache(STRING key);
 
423
void remove_fam_cache(STRING key);
 
424
void remove_from_cache_by_key(CNSTRING key);
 
425
BOOLEAN remove_fam_record(RECORD frec);
412
426
void remove_from_browse_lists(STRING);
413
 
BOOLEAN remove_refn(STRING, STRING);
 
427
BOOLEAN remove_refn(CNSTRING refn, CNSTRING key);
414
428
void rename_from_browse_lists(STRING);
415
429
BOOLEAN remove_spouse(NODE indi, NODE fam);
416
430
void replace_fam(NODE fam1, NODE fam2);
426
440
void save_original_locales(void);
427
441
BOOLEAN save_tt_to_file(INT ttnum, STRING filename);
428
442
void set_displaykeys(BOOLEAN);
429
 
void set_gettext_codeset(CNSTRING domain, CNSTRING codeset);
430
443
void set_temp_node(NODE, BOOLEAN temp);
431
444
STRING shorten_plac(STRING);
432
445
void show_node(NODE node);
438
451
void split_indi_old(NODE, NODE*, NODE*, NODE*, NODE*, NODE*, NODE*);
439
452
void split_othr(NODE node, NODE *prefn, NODE *prest);
440
453
BOOLEAN store_file_to_db(STRING key, STRING file);
441
 
BOOLEAN store_record(STRING key, STRING rec, INT len);
442
 
BOOLEAN store_text_file_to_db(STRING key, CNSTRING file, TRANSLFNC);
 
454
BOOLEAN store_record(CNSTRING key, STRING rec, INT len);
443
455
RECORD string_to_record(STRING str, CNSTRING key, INT len);
444
456
void termlocale(void);
445
 
void traverse_db_key_recs(BOOLEAN(*func)(CNSTRING key, RECORD, void *param), void *param);
446
 
void traverse_db_rec_keys(CNSTRING lo, CNSTRING hi, BOOLEAN(*func)(CNSTRING key, STRING data, INT, void *param), void * param);
447
457
BOOLEAN traverse_nodes(NODE node, BOOLEAN (*func)(NODE, VPTR), VPTR param);
448
458
void traverse_refns(BOOLEAN(*func)(CNSTRING key, CNSTRING refn, BOOLEAN newset, void *param), void *param);
449
459
INT tree_strlen(INT, NODE);
463
473
BOOLEAN valid_even_tree(NODE, STRING*, NODE);
464
474
BOOLEAN valid_othr_tree(NODE, STRING*, NODE);
465
475
INT val_to_sex(NODE);
466
 
BOOLEAN value_to_list(STRING, LIST, INT*, STRING);
467
476
STRING value_to_xref(STRING);
468
477
BOOLEAN writexrefs(void);
469
478
void write_node_to_editfile(NODE); /* used by Ethel */
470
 
INT xref_firste(void);
471
 
INT xref_firstf(void);
472
 
INT xref_firsti(void);
473
 
INT xref_firsts(void);
474
 
INT xref_firstx(void);
475
 
INT xref_laste(void);
476
 
INT xref_lastf(void);
477
 
INT xref_lasti(void);
478
 
INT xref_lasts(void);
479
 
INT xref_lastx(void);
480
 
INT xref_max_any(void);
481
 
INT xref_max_indis(void);
482
 
INT xref_max_evens (void);
483
 
INT xref_max_fams (void);
484
 
INT xref_max_othrs (void);
485
 
INT xref_max_sours (void);
486
 
INT xref_next(char ntype, INT i);
487
 
INT xref_nexte(INT);
488
 
INT xref_nextf(INT);
489
 
INT xref_nexti(INT);
490
 
INT xref_nexts(INT);
491
 
INT xref_nextx(INT);
492
 
INT xref_prev(char ntype, INT i);
493
 
INT xref_preve(INT);
494
 
INT xref_prevf(INT);
495
 
INT xref_previ(INT);
496
 
INT xref_prevs(INT);
497
 
INT xref_prevx(INT);
498
 
INT xrefval(char ntype, STRING str);
 
479
 
 
480
/* dblist.c */
 
481
INT get_dblist(STRING path, LIST * dblist, LIST * dbdesclist);
 
482
void release_dblist(LIST dblist);
 
483
 
 
484
/* interface.c */
 
485
void del_in_dbase(CNSTRING key);
 
486
void delete_record_missing_data_entry(CNSTRING key);
 
487
BOOLEAN mark_deleted_record_as_deleted(CNSTRING key);
 
488
BOOLEAN mark_live_record_as_live(CNSTRING key);
 
489
BOOLEAN store_text_file_to_db(STRING key, CNSTRING file, TRANSLFNC);
 
490
void traverse_db_rec_keys(CNSTRING lo, CNSTRING hi, BOOLEAN(*func)(CNSTRING key, STRING data, INT, void *param), void * param);
 
491
void traverse_db_key_recs(BOOLEAN(*func)(CNSTRING key, RECORD, void *param), void *param);
 
492
 
 
493
/* keytonod.c */
 
494
void add_new_indi_to_cache(RECORD rec);
 
495
RECORD get_record_for_cel(CACHEEL cel);
499
496
 
500
497
/* gstrings.c */
501
498
STRING generic_to_list_string(NODE node, STRING key, INT len, STRING delim, RFMT rfmt, BOOLEAN appkey);
502
499
STRING *get_child_strings(NODE, RFMT, INT*, STRING**);
503
500
STRING indi_to_list_string(NODE indi, NODE fam, INT len, RFMT rfmt, BOOLEAN appkey);
504
501
 
 
502
/* lldatabase.c */
 
503
LLDATABASE lldb_alloc(void);
 
504
void lldb_close(LLDATABASE *plldb);
 
505
void lldb_set_btree(LLDATABASE lldb, void * btree);
 
506
 
 
507
/* llgettext.c */
 
508
void set_gettext_codeset(CNSTRING domain, CNSTRING codeset);
 
509
CNSTRING get_gettext_codeset(void);
 
510
 
 
511
/* misc.c */
 
512
INT xrefval(char ntype, STRING str);
 
513
 
505
514
/* names.c */
506
 
void add_name(STRING, STRING);
507
 
void free_name_list(LIST list);
508
 
void free_string_list(LIST list);
 
515
void add_name(CNSTRING name, CNSTRING key);
509
516
LIST find_indis_by_name(CNSTRING name);
510
517
CNSTRING getasurname(CNSTRING);
511
518
CNSTRING getsxsurname(CNSTRING);
512
519
CNSTRING givens(CNSTRING);
513
520
STRING manip_name(STRING name, SURCAPTYPE captype, SURORDER surorder, INT len);
514
 
BOOLEAN name_to_list(CNSTRING, LIST, INT*, INT*);
 
521
LIST name_to_list(CNSTRING name, INT *plen, INT *psind);
515
522
STRING name_string(STRING);
516
523
int namecmp(STRING, STRING);
517
 
void remove_name(STRING, STRING);
518
 
void traverse_names(BOOLEAN(*func)(STRING key, CNSTRING name, BOOLEAN newset, void *param), void *param);
 
524
void remove_name(STRING name, CNSTRING key);
 
525
void traverse_names(BOOLEAN(*func)(CNSTRING key, CNSTRING name, BOOLEAN newset, void *param), void *param);
519
526
STRING trim_name(STRING, INT);
520
527
 
521
528
/* node.c */
532
539
NODE fam_to_wife_node(NODE);
533
540
NODE next_node_it_ptr(NODE_ITER nodeit);
534
541
 
 
542
/* nodechk.c */
 
543
void nodechk(NODE node, CNSTRING scope);
 
544
void nodechk_enable(BOOLEAN enable);
 
545
 
535
546
/* nodeio.c */
536
547
STRING node_to_string(NODE);
537
548
NODE string_to_node(STRING);
538
549
void write_indi_to_file_for_edit(NODE indi, CNSTRING file, RFMT rfmt);
539
 
void write_fam_to_file(NODE fam, CNSTRING file);
 
550
void write_fam_to_file_for_edit(NODE fam, CNSTRING file, RFMT rfmt);
540
551
void write_nodes(INT, FILE*, XLAT, NODE, BOOLEAN, BOOLEAN, BOOLEAN);
541
552
 
 
553
/* place.c */
 
554
LIST place_to_list(STRING, INT*);
 
555
LIST value_to_list (STRING str, INT *plen, STRING dlm);
 
556
 
542
557
/* refns.c */
543
558
void annotate_with_supplemental(NODE node, RFMT rfmt);
544
559
 
547
562
INT soundex_count(void);
548
563
CNSTRING soundex_get(INT i, CNSTRING name);
549
564
 
550
 
/*******************
551
 
 various Macros
552
 
 *******************/
553
 
 
554
 
#define NAME(indi)  find_tag(nchild(indi),"NAME")
555
 
#define REFN(indi)  find_tag(nchild(indi),"REFN")
556
 
#define SEX(indi)   val_to_sex(find_tag(nchild(indi),"SEX"))
557
 
#define BIRT(indi)  find_tag(nchild(indi),"BIRT")
558
 
#define DEAT(indi)  find_tag(nchild(indi),"DEAT")
559
 
#define BAPT(indi)  find_tag(nchild(indi),"CHR")
560
 
#define BURI(indi)  find_tag(nchild(indi),"BURI")
561
 
#define FAMC(indi)  find_tag(nchild(indi),"FAMC")
562
 
#define FAMS(indi)  find_tag(nchild(indi),"FAMS")
563
 
 
564
 
#define HUSB(fam)   find_tag(nchild(fam),"HUSB")
565
 
#define WIFE(fam)   find_tag(nchild(fam),"WIFE")
566
 
#define MARR(fam)   find_tag(nchild(fam),"MARR")
567
 
#define CHIL(fam)   find_tag(nchild(fam),"CHIL")
568
 
 
569
 
#define DATE(evnt)   find_tag(nchild(evnt),"DATE")
570
 
#define PLAC(evnt)   find_tag(nchild(evnt),"PLAC")
571
 
 
572
 
/*=============================================
573
 
 * indi_to_key, fam_to_key - return key of node
574
 
 *  eg, "I21"
575
 
 *  returns static buffer
576
 
 *===========================================*/
577
 
#define indi_to_key(indi)  (rmvat(nxref(indi)))
578
 
#define fam_to_key(fam)    (rmvat(nxref(fam)))
579
 
#define node_to_key(node)  (rmvat(nxref(node)))
580
 
 
581
 
/*=============================================
582
 
 * indi_to_keynum, fam_to_keynum, etc - 
583
 
 *  return keynum of node, eg, 21
584
 
 *===========================================*/
585
 
#define indi_to_keynum(indi) (node_to_keynum('I', indi))
586
 
#define fam_to_keynum(fam)  (node_to_keynum('F', fam))
587
 
#define sour_to_keynum(sour) (node_to_keynum('S', sour))
588
 
 
589
 
/*=============================================
590
 
 * num_families - count spouses of indi
591
 
 *===========================================*/
592
 
#define num_families(indi) (length_nodes(FAMS(indi)))
593
 
 
594
 
 /*=============================================
595
 
 * num_children - count children of indi
596
 
 *===========================================*/
597
 
#define num_children(fam)  (length_nodes(CHIL(fam)))
598
 
 
599
 
/*
600
 
TODO: Change all FORCHILDRENx to FORCHILDREN loops
601
 
This means changing use of NODE to RECORD
602
 
Perry, 2002.06.24
603
 
*/
604
 
#define FORCHILDRENx(fam,child,num) \
605
 
        {\
606
 
        NODE __node = find_tag(nchild(fam), "CHIL");\
607
 
        NODE child=0;\
608
 
        STRING __key=0;\
609
 
        num = 0;\
610
 
        while (__node) {\
611
 
                __key = rmvat(nval(__node));\
612
 
                if (!__key || !(child = key_to_indi(__key))) {\
613
 
                        ++num;\
614
 
                        __node = nsibling(__node);\
615
 
                        continue;\
616
 
                }\
617
 
                ++num;\
618
 
                {
619
 
 
620
 
#define ENDCHILDRENx \
621
 
                }\
622
 
                __node = nsibling(__node);\
623
 
                if (__node && nestr(ntag(__node), "CHIL")) __node = NULL;\
624
 
        }}
625
 
 
626
 
#define FORCHILDREN(fam,child,num) \
627
 
        {\
628
 
        NODE __node = find_tag(nchild(fam), "CHIL");\
629
 
        RECORD child=0;\
630
 
        STRING __key=0;\
631
 
        num = 0;\
632
 
        while (__node) {\
633
 
                __key = rmvat(nval(__node));\
634
 
                if (!__key || !(child = key_to_irecord(__key))) {\
635
 
                        ++num;\
636
 
                        __node = nsibling(__node);\
637
 
                        continue;\
638
 
                }\
639
 
                ++num;\
640
 
                {
641
 
 
642
 
#define ENDCHILDREN \
643
 
                }\
644
 
                __node = nsibling(__node);\
645
 
                if (__node && nestr(ntag(__node), "CHIL")) __node = NULL;\
646
 
        }}
647
 
 
648
 
#define FORSPOUSES(indi,spouse,fam,num) \
649
 
        {\
650
 
        NODE __node = FAMS(indi);\
651
 
        INT __sex = SEX(indi);\
652
 
        NODE spouse=0,fam=0;\
653
 
        STRING __key=0;\
654
 
        num = 0;\
655
 
        while (__node) {\
656
 
                __key = rmvat(nval(__node));\
657
 
                if (!__key || !(fam = qkey_to_fam(__key))) {\
658
 
                        ++num;\
659
 
                        __node = nsibling(__node);\
660
 
                        continue;\
661
 
                }\
662
 
                if (__sex == SEX_MALE)\
663
 
                        spouse = fam_to_wife_node(fam);\
664
 
                else if (__sex == SEX_FEMALE)\
665
 
                        spouse = fam_to_husb_node(fam);\
666
 
                else    spouse = fam_to_spouse(fam, indi);\
667
 
                if (spouse != NULL) {\
668
 
                        ++num;\
669
 
                        {
670
 
 
671
 
#define ENDSPOUSES \
672
 
                }}\
673
 
                __node = nsibling(__node);\
674
 
                if (__node && nestr(ntag(__node), "FAMS")) __node = NULL;\
675
 
        }}
676
 
 
677
 
#define FORFAMSS(indi,fam,spouse,num) \
678
 
        {\
679
 
        NODE __node = FAMS(indi);\
680
 
        INT __sex = SEX(indi);\
681
 
        NODE fam=0, spouse=0;\
682
 
        STRING __key=0;\
683
 
        num = 0;\
684
 
        while (__node) {\
685
 
                __key = rmvat(nval(__node));\
686
 
                if (!__key || !(fam = qkey_to_fam(__key))) {\
687
 
                        ++num;\
688
 
                        __node = nsibling(__node);\
689
 
                        continue;\
690
 
                }\
691
 
                if (__sex == SEX_MALE)\
692
 
                        spouse = fam_to_wife_node(fam);\
693
 
                else if (__sex == SEX_FEMALE)\
694
 
                        spouse = fam_to_husb_node(fam);\
695
 
                else \
696
 
                        spouse = fam_to_spouse(fam, indi);\
697
 
                ++num;\
698
 
                {
699
 
 
700
 
#define ENDFAMSS \
701
 
                }\
702
 
                __node = nsibling(__node);\
703
 
                if (__node && nestr(ntag(__node), "FAMS")) __node = NULL;\
704
 
        }}
705
 
 
706
 
#define FORFAMCS(indi,fam,fath,moth,num) \
707
 
        {\
708
 
        NODE __node = FAMC(indi);\
709
 
        NODE fam, fath, moth;\
710
 
        STRING __key=0;\
711
 
        num = 0;\
712
 
        while (__node) {\
713
 
                __key = rmvat(nval(__node));\
714
 
                if (!__key || !(fam = qkey_to_fam(__key))) {\
715
 
                         ++num;\
716
 
                         __node = nsibling(__node);\
717
 
                         continue;\
718
 
                }\
719
 
                fath = fam_to_husb_node(fam);\
720
 
                moth = fam_to_wife_node(fam);\
721
 
                ++num;\
722
 
                {
723
 
 
724
 
#define ENDFAMCS \
725
 
                }\
726
 
                __node = nsibling(__node);\
727
 
                if (__node && nestr(ntag(__node), "FAMC")) __node = NULL;\
728
 
        }}
729
 
 
730
 
#define FORHUSBS(fam,husb,num) \
731
 
        {\
732
 
        NODE __node = find_tag(nchild(fam), "HUSB");\
733
 
        NODE husb=0;\
734
 
        STRING __key=0;\
735
 
        num = 0;\
736
 
        while (__node) {\
737
 
                __key = rmvat(nval(__node));\
738
 
                if (!__key || !(husb = key_to_indi(__key))) {\
739
 
                        ++num;\
740
 
                        __node = nsibling(__node);\
741
 
                        continue;\
742
 
                }\
743
 
                ++num;\
744
 
                {
745
 
 
746
 
#define ENDHUSBS \
747
 
                }\
748
 
                __node = nsibling(__node);\
749
 
                if (__node && nestr(ntag(__node), "HUSB")) __node = NULL;\
750
 
        }}
751
 
 
752
 
#define FORWIFES(fam,wife,num) \
753
 
        {\
754
 
        NODE __node = find_tag(nchild(fam), "WIFE");\
755
 
        NODE wife=0;\
756
 
        STRING __key=0;\
757
 
        num = 0;\
758
 
        while (__node) {\
759
 
                __key = rmvat(nval(__node));\
760
 
                if (!__key || !(wife = key_to_indi(__key))) {\
761
 
                        ++num;\
762
 
                        __node = nsibling(__node);\
763
 
                        continue;\
764
 
                }\
765
 
                ASSERT(wife);\
766
 
                num++;\
767
 
                {
768
 
 
769
 
#define ENDWIFES \
770
 
                }\
771
 
                __node = nsibling(__node);\
772
 
                if (__node && nestr(ntag(__node), "WIFE")) __node = NULL;\
773
 
        }}
774
 
 
775
 
#define FORTAGVALUES(root,tag,node,value)\
776
 
        {\
777
 
        NODE node, __node = nchild(root);\
778
 
        STRING value, __value;\
779
 
        while (__node) {\
780
 
                while (__node && nestr(tag, ntag(__node)))\
781
 
                        __node = nsibling(__node);\
782
 
                if (__node == NULL) break;\
783
 
                __value = value = full_value(__node, "\n");/*OBLIGATION*/\
784
 
                node = __node;\
785
 
                {
786
 
#define ENDTAGVALUES \
787
 
                }\
788
 
                if (__value) stdfree(__value);/*RELEASE*/\
789
 
                 __node = nsibling(__node);\
790
 
        }}
 
565
/* xreffile.c */
 
566
BOOLEAN addxref_if_missing (CNSTRING key);
 
567
BOOLEAN delete_xref_if_present(CNSTRING key);
 
568
INT xref_firste(void);
 
569
INT xref_firstf(void);
 
570
INT xref_firsti(void);
 
571
INT xref_firsts(void);
 
572
INT xref_firstx(void);
 
573
INT xref_laste(void);
 
574
INT xref_lastf(void);
 
575
INT xref_lasti(void);
 
576
INT xref_lasts(void);
 
577
INT xref_lastx(void);
 
578
INT xref_max_any(void);
 
579
INT xref_max_indis(void);
 
580
INT xref_max_evens (void);
 
581
INT xref_max_fams (void);
 
582
INT xref_max_othrs (void);
 
583
INT xref_max_sours (void);
 
584
INT xref_next(char ntype, INT i);
 
585
INT xref_nexte(INT);
 
586
INT xref_nextf(INT);
 
587
INT xref_nexti(INT);
 
588
INT xref_nexts(INT);
 
589
INT xref_nextx(INT);
 
590
INT xref_prev(char ntype, INT i);
 
591
INT xref_preve(INT);
 
592
INT xref_prevf(INT);
 
593
INT xref_previ(INT);
 
594
INT xref_prevs(INT);
 
595
INT xref_prevx(INT);
 
596
 
 
597
#ifndef GEDCOM_MACROS_INCLUDED
 
598
#include "gedcom_macros.h"
 
599
#endif
791
600
 
792
601
#endif /* _GEDCOM_H */
793