home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / unix / volume18 / geneal / part03 / fgdat.c < prev   
C/C++ Source or Header  |  1989-03-08  |  12KB  |  518 lines
  1. /* fgdat.c - routines to get pieces of info records
  2.  * Written by Jim McBeath (jimmc) at SCI
  3.  *
  4.  * Revision history:
  5.  * 27-Jan-85    Jim McBeath    convert fgclist to fg*list functions
  6.  *                add addn[cp]list functions
  7.  * 29-Jan-85    Jim McBeath    add family index in names if index>1
  8.  *                convert to 7-char-distinct names
  9.  *  2-Feb-85    Jim McBeath    Convert to LN.A instead of LNM.
  10.  * 13-Feb-85    (Ian Darwin)    use NULL and \0 instead of 0 for cstr
  11.  * 17.Aug.87  jimmc  Add fglname
  12.  * 18.Aug.87  jimmc  Add fgtype, fgspouse
  13.  * 24.Aug.87  jimmc  Add fgburied
  14.  * 25.Aug.87  jimmc  Add fgnmarriage
  15.  * 18.Sep.87  jimmc  Add #include xalloc.h; add fgaddrphn
  16.  * 26.Oct.87  jimmc  Remove basic routines into fgdatsubs.c
  17.  * 27.Oct.87  jimmc  Add fggen
  18.  *  1.Jan.88  jimmc  Make fgtnote and fggen also pick up TGEN; add fglpname
  19.  *  4.Jan.88  jimmc  Add fglhname
  20.  *  8.Jan.88  jimmc  Lint cleanup
  21.  */
  22.  
  23. /* These routines all package up various pieces of information
  24.  * from specified records.  They each take as arguments a record
  25.  * ID number; some take a field name as well.  Most return a pointer
  26.  * to a string allocated from dynamic memory, which can be freed
  27.  * by passing the pointer to the freestr() function.
  28.  * The functions in this file in general refer to and format specific
  29.  * fields; the functions in fgdatsubs are more general, without references
  30.  * to specific fields.
  31.  * In the arguments, i is an ID for an individual's record; f is an ID for
  32.  *  a family record, and n is an ID for either (or sometimes any record kind).
  33.  *  Functions which return an allocated string are:
  34.  * fgsname(i)   just the nickname; else first name; else middle name; else "?"
  35.  * fgtname(i)    all of name but last name
  36.  * fglname(f)   last name of a family only
  37.  * fglpname(f)  last name of a family plus names of parents
  38.  * fgbname(i)    full born (maiden) name
  39.  * fgfname(i)    full name (including maiden and married last names)
  40.  * fgbirth(i)    birth date and place
  41.  * fgdeath(i)    death date and place
  42.  * fgburied(i)    burial location
  43.  * fgbrtdeath(i)    birth and death dates
  44.  * fgmarriage(f)    marriage date and place
  45.  * fgnmarriage(f)    marriage date and place, and number if +n switch
  46.  * fgtnote(n)        TNOTE plus TGEN
  47.  * fggen(n)        GEN plus TGEN
  48.  *  Functions which return an integer are:
  49.  * fgspouse(f_m,i_n)    returns the spouse for marriage f_m who is not i_n
  50.  * fgbclist(f,av)    get child list; return valus is ac, fills array av
  51.  * fgclist(f,avp)    get child list; return value is ac, fills pointer avp
  52.  * fgbslist(i,av)    get spouse list; return valus is ac, fills array av
  53.  * fgslist(i,avp)    get spouse list; return value is ac, fills pointer avp
  54.  *  Other functions:
  55.  * fgtype(n)        returns single character which is type code (e.g. 'I')
  56.  */
  57.  
  58. #include <stdio.h>
  59. #include <strings.h>
  60. #include "geneal.h"
  61. #include "xalloc.h"
  62.  
  63. extern char *strcrep();
  64.  
  65. /* for forward references */
  66. char *fgdateplace();
  67.  
  68. /*..........*/
  69.  
  70. int
  71. fgtype(n)        /* get a type character from the file */
  72. int n;
  73. {
  74.     return fgchar(n,"T");
  75. }
  76.  
  77. /*..........*/
  78.  
  79. int
  80. fgspouse(m,n)
  81. int m;            /* id of the marriage */
  82. int n;            /* id of the spouse we DONT want */
  83. {
  84.     int t;
  85.  
  86.     t = fgnum(m,"H");
  87.     if (t>0 && t!=n) return t;
  88.     t = fgnum(m,"W");
  89.     if (t>0 && t!=n) return t;
  90.     return -1;
  91. }
  92.  
  93. /*..........*/
  94.  
  95. char *
  96. fgsname(n)        /* short name (first name or whatever) */
  97. int n;
  98. {
  99.     char xname[200];
  100.     int l;
  101.  
  102.     xname[0] = 0;
  103.     addindex(xname,n);
  104.     addncstr(xname,n,"PN");
  105.     l = strlen(xname);
  106.     addncstr(xname,n,"NN");    /* use nickname if there */
  107.     if (!xname[l]) addncstr(xname,n,"FN");
  108.     if (!xname[l]) addncstr(xname,n,"MN");
  109.     if (!xname[l]) addcstr(xname,"??");
  110.     addncstr(xname,n,"SN");
  111.     return strsav(xname);
  112. }
  113.  
  114. /*..........*/
  115.  
  116. char *
  117. fgtname(n)        /* get the full name (except last name) */
  118. int n;            /* person to get data item for */
  119. {
  120.     char xname[200];
  121.  
  122.     xname[0] = 0;        /* start with null */
  123.     addindex(xname,n);    /* put in id number if requested */
  124.     addncstr(xname,n,"PN");    /* prefix name */
  125.     addncstr(xname,n,"FN");    /* add first name */
  126.     addncstr(xname,n,"MN");    /* add middle name */
  127.     addnpstr(xname,n,"NN");    /* add nickname in parens */
  128.     addncstr(xname,n,"SN");    /* suffix name */
  129.     return strsav(xname);
  130. }
  131.  
  132. /*..........*/
  133.  
  134. char *
  135. fglname(f)
  136. int f;            /* family id number */
  137. {
  138.     char xname[200];
  139.  
  140.     xname[0] = 0;        /* start with null */
  141.     addindex(xname,f);    /* put in id number if requested */
  142.     addncstr(xname,f,"N");    /* the name */
  143.     return strsav(xname);
  144. }
  145.  
  146. /*..........*/
  147.  
  148. char *
  149. fglpname(f)
  150. int f;            /* family id number */
  151. {
  152.     char xname[200];
  153.     int h,w;
  154.     char *fn, *hln, *wln, *hfn, *wfn, *fpn;
  155.  
  156.     xname[0] = 0;
  157.     addindex(xname,f);
  158.     fn = fgstr(f,"N");    /* get family last name */
  159.     h = fgnum(f,"H");    /* husband and wife ID numbers */
  160.     w = fgnum(f,"W");
  161.     if (h<=0 && w<=0) {
  162.         addcstr(xname,fn);
  163.         freestr(fn);
  164.         return strsav(xname);
  165.     }
  166.     hln = fgstr(h,"LN");
  167.     wln = fgstr(w,"LN.A");    /*** sex-biased assumptions about names... */
  168.     hfn = fgsname(h);
  169.     wfn = fgsname(w);
  170.     if (strcmp(fn,hln)==0 && strcmp(fn,wln)==0) {
  171.         fpn = tprintf("%s and %s %s", hfn, wfn, fn);
  172.     }
  173.     else if (strcmp(fn,hln)==0) {
  174.         if (wln && wln[0])
  175.             fpn = tprintf("%s %s and %s %s", hfn, hln, wfn, wln);
  176.         else
  177.             fpn = tprintf("%s %s and %s", hfn, hln, wfn);
  178.     }
  179.     else {
  180.         fpn = tprintf("%s: %s %s and %s %s", fn, hfn, hln, wfn, wln);
  181.     }
  182.     addcstr(xname,fpn);
  183.     freestr(hln);
  184.     freestr(wln);
  185.     freestr(hfn);
  186.     freestr(wfn);
  187.     freestr(fn);
  188.     freestr(fpn);
  189.     return strsav(xname);
  190. }
  191.  
  192. /*..........*/
  193.  
  194. char *
  195. fglhname(f)
  196. int f;            /* family id number */
  197. {
  198.     char xname[200];
  199.     int h,w;
  200.     char *hpn, *wpn, *fn;
  201.  
  202.     xname[0] = 0;
  203.     addindex(xname,f);
  204.     h = fgnum(f,"H");    /* husband and wife ID numbers */
  205.     w = fgnum(f,"W");
  206.     hpn = fgstr(h,"PN");
  207.     if (!hpn || !hpn[0]) hpn="Mr.";
  208.     wpn = fgstr(w,"PN");
  209.     if (!wpn || !wpn[0]) wpn="Mrs.";
  210.     addcstr(xname,hpn);
  211.     addcstr(xname,"and");
  212.     addcstr(xname,wpn);
  213.     freestr(hpn);
  214.     freestr(wpn);
  215.     if (h>0) {
  216.         addncstr(xname,h,"FN");
  217.         addncstr(xname,h,"MN");
  218.         addnpstr(xname,h,"NN");
  219.         addncstr(xname,h,"LN");
  220.         addncstr(xname,h,"SN");
  221.     }
  222.     else {
  223.         fn = fgstr(f,"N");    /* get family last name */
  224.         addcstr(xname,fn);
  225.         freestr(fn);
  226.     }
  227.     return strsav(xname);
  228. }
  229.  
  230. /*..........*/
  231.  
  232. char *
  233. fgbname(n)        /* get the full born name */
  234. int n;            /* person to get data item for */
  235. {
  236.     char xname[200];
  237.  
  238.     xname[0] = 0;        /* start with null */
  239.     addindex(xname,n);        /* put in id number if requested */
  240.     addncstr(xname,n,"PN");
  241.     addncstr(xname,n,"FN");
  242.     addncstr(xname,n,"MN");
  243.     addnpstr(xname,n,"NN");
  244.     addncstr(xname,n,"LN");
  245.     addncstr(xname,n,"SN");
  246.     return strsav(xname);
  247. }
  248.  
  249. /*..........*/
  250.  
  251. char *
  252. fgfname(n)        /* get the full name */
  253. int n;            /* person to get data item for */
  254. {
  255.     char xname[200];
  256.     char lnaname[200];
  257.  
  258.     fgbstr(n,"LN.A",lnaname);
  259.     strcrep(lnaname, ';', ' ');    /* convert semicolons to space */
  260.     xname[0] = 0;        /* start with null */
  261.     addindex(xname,n);        /* put in id number if requested */
  262.     addncstr(xname,n,"PN");
  263.     addncstr(xname,n,"FN");
  264.     addncstr(xname,n,"MN");
  265.     addnpstr(xname,n,"NN");
  266.     addncstr(xname,n,"LN");
  267.     addcstr(xname,lnaname);
  268.     addncstr(xname,n,"SN");
  269.     return strsav(xname);
  270. }
  271.  
  272. /*..........*/
  273.  
  274. char *
  275. fgbirth(n)        /* get birth date info */
  276. int n;            /* person to get data item for */
  277. {
  278.     return fgdateplace(n,"B","BP","b");
  279. }
  280.  
  281. /*..........*/
  282.  
  283. char *
  284. fgdeath(n)        /* get death date info */
  285. int n;            /* person to get data item for */
  286. {
  287.     return fgdateplace(n,"D","DP","d");
  288. }
  289.  
  290. /*..........*/
  291.  
  292. char *
  293. fgburied(n)        /* get burail place */
  294. int n;            /* person to get data item for */
  295. {
  296.     char b[1000];
  297.  
  298.     fgbstr(n,"BUR",b);
  299.     if (*b) return tprintf("bur: %s",b);
  300.     else return strsav("");
  301. }
  302.  
  303. /*..........*/
  304.  
  305. char *
  306. fgbrtdeath(n)        /* get birth/death date info */
  307. int n;            /* person to get data item for */
  308. {
  309.     char bdate[100], ddate[100], dates[200];
  310.  
  311.     fgbstr(n,"B",bdate);    /* get birth date */
  312.     fgbstr(n,"D",ddate);    /* get death date */
  313.     if (*bdate==0 && *ddate==0) return "";
  314.     if (*ddate==0) sprintf(dates," ( b: %s )", bdate);
  315.     else if (*bdate==0) sprintf(dates," ( d: %s )", ddate);
  316.     else sprintf(dates," ( b: %s, d: %s )", bdate, ddate);
  317.     return strsav(dates);
  318. }
  319.  
  320. /*..........*/
  321.  
  322. char *
  323. fgmarriage(n)        /* get marriage date info */
  324. int n;            /* person to get data item for */
  325. {
  326.     return fgdateplace(n,"M","MP","m");
  327. }
  328.  
  329. /*..........*/
  330.  
  331. char *
  332. fgnmarriage(n)        /* get marriage date info and optionally number */
  333. int n;            /* person to get data item for */
  334. {
  335.     char *s, *t;
  336.  
  337.     s = fgdateplace(n,"M","MP","m");
  338.     if (!Gflag['n']) return s;
  339.     t = tprintf("%s [%d]",s,n);
  340.     freestr(s);
  341.     return t;
  342. }
  343.  
  344. /*..........*/
  345.  
  346. char *fgt2gen(n,item)
  347. int n;
  348. char *item;
  349. {
  350. char *tgen;
  351. char *istr;
  352. char *rstr;
  353.  
  354.     tgen = fgstr(n,"TGEN");
  355.     istr = fgstr(n,item);
  356.     if (tgen && tgen[0] && istr && istr[0]) {
  357.         rstr = tprintf("%s\n%s",tgen,istr);
  358.         freestr(tgen);
  359.         freestr(istr);
  360.         return rstr;
  361.     }
  362.     if (tgen && tgen[0]) return tgen;
  363.     return istr;
  364. }
  365.  
  366. char * fgtnote(n) int n; { return fgt2gen(n,"TNOTE"); }
  367. char * fggen(n) int n; { return fgt2gen(n,"GEN"); }
  368.  
  369. /*..........*/
  370.  
  371. char *
  372. fgaddrphn(n)
  373. int n;
  374. {
  375.     char addr[1000];
  376.     char phone[1000];
  377.     char *t;
  378.  
  379.     fgbstr(n,"ADDR",addr);
  380.     fgbstr(n,"PHONE",phone);
  381.     if (*addr && *phone)
  382.         t = tprintf("%s\n%s",addr,phone);
  383.     else if (*addr)
  384.         t = strsav(addr);
  385.     else if (*phone)
  386.         t = strsav(phone);
  387.     else
  388.         t = strsav("");
  389.     return t;
  390. }
  391.  
  392. /*..........*/
  393.  
  394. int
  395. fgclist(n,avp)        /* get child list into allocated array */
  396. int n;            /* family to get list for */
  397. int **avp;        /* where we should put the pointer to the array */
  398. {
  399.     return fglist(n,"C",avp);
  400. }
  401.  
  402. /*..........*/
  403.  
  404. int
  405. fgbclist(n,av)        /* get child list into specified array */
  406. int n;            /* family to get list for */
  407. int *av;        /* where we should put the data */
  408. {
  409.     return fgblist(n,"C",av);
  410. }
  411.  
  412. /*..........*/
  413.  
  414. int
  415. fgslist(n,avp)        /* get spouse list into allocated array */
  416. int n;            /* person to get list for */
  417. int **avp;        /* where we should put the pointer to the array */
  418. {
  419.     return fglist(n,"S",avp);
  420. }
  421.  
  422. /*..........*/
  423.  
  424. int
  425. fgbslist(n,av)        /* get spouse list into specified array */
  426. int n;            /* person to get list for */
  427. int *av;        /* where we should put the data */
  428. {
  429.     return fgblist(n,"S",av);
  430. }
  431.  
  432. /*..........*/
  433.  
  434. char *
  435. fgdateplace(n,dk,pk,cc)    /* get date/place info */
  436. int n;            /* person to get data item for */
  437. char *dk;        /* date keyword */
  438. char *pk;        /* place keyword */
  439. char *cc;        /* string to use as output key */
  440. {
  441.     char date[100], place[100];
  442.  
  443.     fgbstr(n,dk,date);    /* get date */
  444.     fgbstr(n,pk,place);    /* get place */
  445.     if (*date==0 && *place==0) return "";
  446.     if (*date && *place) return tprintf("%s: %s, %s", cc, date, place);
  447.     if (*date) return tprintf("%s: %s", cc, date);
  448.     return tprintf("%s: %s", cc, place);
  449. }
  450.  
  451. /*..........*/
  452.  
  453. addncstr(dd,n,ff)    /* add a field value onto a string */
  454. char *dd;        /* the string being built */
  455. int n;            /* record number */
  456. char *ff;        /* name of field to get from that record */
  457. {
  458.     char buf[1000];
  459.  
  460.     fgbstr(n,ff,buf);
  461.     addcstr(dd,buf);
  462. }
  463.  
  464. /*..........*/
  465.  
  466. addnpstr(dd,n,ff)    /* add a field value onto a string in parens */
  467. char *dd;        /* the string being built */
  468. int n;            /* record number */
  469. char *ff;        /* name of field to get from that record */
  470. {
  471.     char buf[1000];
  472.  
  473.     fgbstr(n,ff,buf);
  474.     addpstr(dd,buf);
  475. }
  476.  
  477. /*..........*/
  478.  
  479. addcstr(dd,ss)        /* add a string to another */
  480. char *dd;        /* the string being built */
  481. char *ss;        /* the string to add if not null */
  482. {
  483.     if (ss && *ss) {
  484.         if (dd[0]) strcat(dd," ");
  485.         strcat(dd,ss);
  486.     }
  487. }
  488.  
  489. /*..........*/
  490.  
  491. addpstr(dd,ss)        /* add a string in parens */
  492. char *dd;        /* the string to add to */
  493. char *ss;        /* the string to add in parens if not null */
  494. {
  495.     if (ss[0]) {
  496.         if (dd[0]) strcat(dd," ");
  497.         strcat(dd,"(");
  498.         strcat(dd,ss);        /* add the string in parens */
  499.         strcat(dd,")");
  500.     }
  501. }
  502.  
  503. /*..........*/
  504.  
  505. addindex(ss,n)
  506. char *ss;            /* the string to add to */
  507. int n;                /* id number of person */
  508. {
  509.     if (Gflag['N'])
  510.         sprintf(ss,"[%d/%d]", n, fgnum(n,"P"));
  511.         /* put in both individual and family if requested */
  512.     else if (Gflag['n'])
  513.         sprintf(ss, "[%d]", n);  /* put in the id number */
  514.     /* if neither flag set, put in nothing */
  515. }
  516.  
  517. /* end */
  518.