← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/gedlib/names.c

  • 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/gedlib/names.c
38
38
#include "mystring.h" /* fi_chrcmp */
39
39
#include "zstr.h"
40
40
 
 
41
 
41
42
/*********************************************
42
43
 * external/imported variables
43
44
 *********************************************/
60
61
static CNSTRING getsurname_impl(CNSTRING name);
61
62
static STRING name_surfirst(STRING);
62
63
static void name_to_parts(CNSTRING, STRING*);
63
 
static void name2rkey(CNSTRING, RKEY *);
 
64
/* static void name2rkey(CNSTRING, RKEY *); */
64
65
static CNSTRING nextpiece(CNSTRING);
65
66
static STRING parts_to_name(STRING*);
66
67
static BOOLEAN piecematch(STRING, STRING);
67
68
static void remove_namekey(const RKEY * rkeyname, CNSTRING name, const RKEY * rkeyid);
68
 
static void rkey_cpy(const RKEY * src, RKEY * dest);
 
69
/* static void rkey_cpy(const RKEY * src, RKEY * dest);*/
69
70
static BOOLEAN rkey_eq(const RKEY * rkey1, const RKEY * rkey2);
70
71
static void soundex2rkey(char finitial, CNSTRING sdex, RKEY * rkey);
71
72
static void squeeze(CNSTRING, STRING);
132
133
parsenamerec (const RKEY * rkey, CNSTRING p)
133
134
{
134
135
        INT i;
135
 
        rkey_cpy(rkey, &NRkey);
 
136
        memcpy(&NRkey, rkey, sizeof(*rkey));
136
137
/* Store name record in data structures */
137
138
        memcpy (&NRcount, p, sizeof(INT));
138
139
        ASSERT(NRcount < 1000000); /* 1000000 names in a given slot ? */
172
173
        if (NRrec && eqrkey(rkey, &NRKEY))
173
174
                return NRcount>0;
174
175
*/
175
 
        rkey_cpy(rkey, &NRkey);
 
176
        memcpy(&NRkey, rkey, sizeof(*rkey));
176
177
        strfree(&NRrec);
177
 
        p = NRrec = getrecord(BTR, rkey, &NRsize);
 
178
        p = NRrec = bt_getrecord(BTR, rkey, &NRsize);
178
179
        if (!NRrec) {
179
180
                NRcount = 0;
180
181
                if (NRmax == 0) {
191
192
/*============================================
192
193
 * name2rkey - Convert name to name record key
193
194
 *==========================================*/
 
195
/* unused
194
196
static void
195
197
name2rkey (CNSTRING name, RKEY * rkey)
196
198
{
204
206
        rkey->r_rkey[6] = *sdex++;
205
207
        rkey->r_rkey[7] = *sdex;
206
208
}
 
209
unused */
207
210
/*============================================
208
211
 * soundex2rkey - Convert soundex coded name to name record key
209
212
 *==========================================*/
233
236
        return TRUE;
234
237
}
235
238
/*============================================
236
 
 * eqrkey - Are two rkeys the same ?
 
239
 * rkey_cpy - copy rkeys from src to dest?
237
240
 *==========================================*/
 
241
/* unused 
238
242
static void
239
243
rkey_cpy (const RKEY * src, RKEY * dest)
240
244
{
244
248
                dest->r_rkey[i] = src->r_rkey[i];
245
249
        }
246
250
}
 
251
unused */
247
252
/*=======================================
248
253
 * name_lo - Lower limit for name records
249
254
 *=====================================*/
360
365
 *  key:   [in] person's INDI key
361
366
 *=======================================*/
362
367
void
363
 
add_name (STRING name, STRING key)
 
368
add_name (CNSTRING name, CNSTRING key)
364
369
{
365
370
        INT i;
366
371
        RKEY rkeyid = str2rkey(key);
367
372
        RKEY rkeyname;
368
373
        char finitial = getfinitial(name);
369
374
        STRING surname = strsave(getsxsurname(name));
370
 
        TABLE donetab = create_table(FREEKEY);
 
375
        TABLE donetab = create_table_int();
371
376
        STRING rkeystr=0;
372
377
 
373
378
        for (i=0; i<soundex_count(); ++i)       {
375
380
                soundex2rkey(finitial, sdex, &rkeyname);
376
381
                /* rkeyname is where names with this soundex/finitial are stored */
377
382
                /* check if we've already done this entry */
378
 
                rkeystr = strsave(rkey2str(rkeyname));
 
383
                rkeystr = rkey2str(rkeyname);
379
384
                if (dupcheck(donetab, rkeystr)) {
380
385
                        strfree(&rkeystr);
381
386
                        continue;
434
439
                p += strlen(NRnames[i]) + 1;
435
440
                len += strlen(NRnames[i]) + 1;
436
441
        }
437
 
        addrecord(BTR, NRkey, rec, len);
 
442
        bt_addrecord(BTR, NRkey, rec, len);
438
443
        stdfree(rec);
439
444
 
440
445
        /* NRnames[NRcount] doesn't point into record */
446
451
 *  key:  [in] person's INDI key
447
452
 *===========================================*/
448
453
void
449
 
remove_name (STRING name, STRING key)
 
454
remove_name (STRING name, CNSTRING key)
450
455
{
451
456
        INT i;
452
457
        RKEY rkeyid = str2rkey(key);
453
458
        RKEY rkeyname;
454
459
        char finitial = getfinitial(name);
455
460
        STRING surname = strsave(getsxsurname(name));
456
 
        TABLE donetab = create_table(FREEKEY);
 
461
        TABLE donetab = create_table_int();
457
462
        STRING rkeystr=0;
458
463
 
459
464
        for (i=0; i<soundex_count(); ++i)       {
525
530
                p += strlen(NRnames[i]) + 1;
526
531
                len += strlen(NRnames[i]) + 1;
527
532
        }
528
 
        addrecord(BTR, NRkey, rec, len);
 
533
        bt_addrecord(BTR, NRkey, rec, len);
529
534
        stdfree(rec);
530
535
}
531
536
/*=========================================================
630
635
        RECORD rec;
631
636
        uchar finitial = getfinitial(name);
632
637
        STRING surname = strsave(getsxsurname(name));
633
 
        TABLE donetab = create_table(FREEKEY);
 
638
        TABLE donetab = create_table_int();
634
639
        LIST list = create_list2(LISTDOFREE);
635
640
 
636
641
        /* See if user is asking for person by key instead of name */
717
722
static BOOLEAN
718
723
dupcheck (TABLE tab, CNSTRING str)
719
724
{
720
 
        if (valueof_str(tab, str))
 
725
        if (in_table(tab, str))
721
726
                return TRUE;
722
 
        insert_table_str(tab, strsave(str), 0);
 
727
        insert_table_int(tab, str, 1);
723
728
        return FALSE;
724
729
}
725
730
/*====================================
1020
1025
 *  name:  [IN]  name to search for
1021
1026
 *  ctype: [IN]  type of record (eg, 'I') (0 for any)
1022
1027
 * returns record found, or NULL
 
1028
 * returns addref'd record
1023
1029
 *==============================*/
1024
1030
RECORD
1025
1031
id_by_key (CNSTRING name, char ctype)
1078
1084
/*============================================
1079
1085
 * name_to_list -- Convert name to string list
1080
1086
 *  name:  [IN]  GEDCOM name
1081
 
 *  list:  [I/O] list (must exist)
1082
1087
 *  plen:  [OUT]  returned length
1083
1088
 *  psind: [OUT]  index (rel 1) of surname in list
1084
1089
 * Returns a list whose elements are strings
1085
1090
 *==========================================*/
1086
 
BOOLEAN
1087
 
name_to_list (CNSTRING name, LIST list, INT *plen, INT *psind)
 
1091
LIST
 
1092
name_to_list (CNSTRING name, INT *plen, INT *psind)
1088
1093
{
1089
1094
        INT i;
1090
1095
        STRING str;
1091
1096
        STRING parts[MAXPARTS];
1092
 
        if (!name || *name == 0 || !list) return FALSE;
1093
 
        make_list_empty(list);
1094
 
        set_list_type(list, LISTDOFREE);
 
1097
        LIST list = create_list2(LISTDOFREE);
 
1098
 
 
1099
        if (!name || *name == 0)
 
1100
                return list;
 
1101
 
1095
1102
        *psind = 0;
1096
1103
        name_to_parts(name, parts);
1097
1104
        for (i = 0; i < MAXPARTS; i++) {
1106
1113
                set_list_element(list, i + 1, str, NULL);
1107
1114
        }
1108
1115
        *plen = i;
1109
 
        return TRUE;
1110
 
}
1111
 
/*====================================================
1112
 
 * free_string_el -- free alloc'd string element of list
1113
 
 *==================================================*/
1114
 
static void
1115
 
free_string_el(VPTR w)
1116
 
{
1117
 
        stdfree((STRING)w);
1118
 
}
1119
 
/*====================================================
1120
 
 * free_name_list -- Free list created by name_to_list
1121
 
 *==================================================*/
1122
 
void
1123
 
free_name_list (LIST list)
1124
 
{
1125
 
        /* name list is just string list */
1126
 
        free_string_list(list);
1127
 
}
1128
 
/*====================================================
1129
 
 * free_string_list -- free list of alloc'd strings
1130
 
 *==================================================*/
1131
 
void
1132
 
free_string_list(LIST list)
1133
 
{
1134
 
        remove_list(list, free_string_el);
 
1116
        return list;
1135
1117
}
1136
1118
/*====================================================
1137
1119
 * traverse_names -- traverse names in db
1142
1124
 *==================================================*/
1143
1125
typedef struct
1144
1126
{
1145
 
        BOOLEAN(*func)(STRING key, CNSTRING name, BOOLEAN newset, void *param);
 
1127
        BOOLEAN(*func)(CNSTRING key, CNSTRING name, BOOLEAN newset, void *param);
1146
1128
        void * param;
1147
1129
} TRAV_NAME_PARAM;
1148
1130
/* see above */
1149
1131
static BOOLEAN
1150
 
traverse_name_callback (RKEY rkey, CNSTRING data, INT len, void *param)
 
1132
traverse_name_callback (RKEY rkey, STRING data, INT len, void *param)
1151
1133
{
1152
1134
        TRAV_NAME_PARAM *tparam = (TRAV_NAME_PARAM *)param;
1153
1135
        INT i;
1164
1146
}
1165
1147
/* see above */
1166
1148
void
1167
 
traverse_names (BOOLEAN(*func)(STRING key, CNSTRING name, BOOLEAN newset, void *param), void *param)
 
1149
traverse_names (BOOLEAN(*func)(CNSTRING key, CNSTRING name, BOOLEAN newset, void *param), void *param)
1168
1150
{
1169
1151
        TRAV_NAME_PARAM tparam;
1170
1152
        tparam.param = param;