File: burial_index.ll

package info (click to toggle)
lifelines 3.0.50-2
  • links: PTS
  • area: main
  • in suites: etch-m68k
  • size: 11,140 kB
  • ctags: 6,517
  • sloc: ansic: 57,468; xml: 8,014; sh: 4,255; makefile: 848; yacc: 601; perl: 170; sed: 16
file content (226 lines) | stat: -rw-r--r-- 8,344 bytes parent folder | download | duplicates (5)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
/*
 * @progname    burial_index.ll
 * @version     1.0
 * @author      Nicklaus
 * @category
 * @output      Text
 * @description

   Write an (unsorted) list of every person in the database
   whose burial place contains a requested string
   (which is the "town" that this report asks for).
   It matches for the town anywhere in the place field.
   so town can also be a state or county.
   Personally, many of my relatives are from Iowa, so I like to make
   a file of everyone buried in Iowa by entering Iowa to the prompt.


   For MY typical record, which looks like
   1 NAME First /Last/
   1 BIRT
   2 DATE 31 Dec 1900
   1 DEAT
   2 DATE 1 Jan 2000
   1 BURI
   2 PLAC town,county,state
   3 ADDR cemeteryname      (technically should be 2 ADDR acc. to new GEDCOM std.)

   burial_index produces a line which looks like:

       town,cemeteryname : Last, First (1900-2000)

   If your database looks like:
   1 BURI
   2 PLAC cemeteryname,town,county,state
   Then you'll probably want to change this report around a bit. Where
   I do: "getel(parts,1)", you'll want: "getel(parts,2) getel(parts,1)".

   For married women, it attempts to make their name what it may
   be on their tombstone, that is, the surname of their first
   husband, but includes a "nee" (= "born", but without the accent mark)
   and the maiden name.  This generally works great for the standard
   once-married person. If a woman was married multiple times,
   it puts all the husbands' surnames on there, starting with the first
   husband, ending with the maiden surname. So my ancestor, Ruth,
   maiden surname Matthews, who first married E. Scott, 2nd J. Alkire,
   and 3rd married N. Bates, gets an entry like this:
         Scott, a.k.a. Alkire, a.k.a. Bates, nee Matthews, Ruth (1831-1917)
   where a.k.a. stands for "also known as". In doing all this,
   it'll (possibly wrongly) assume both that a woman was married and took
   on the father's surname for any family she was a parent in.
   It's pretty tough to cover every case automatically, so you just
   have to examine and edit the output when it's done if you care.

   It is probably useful to run the output of this through Unix sort.
   There is also a companion program, bury.c, which reformats the sorted
   output to make it prettier.

   An example is at: http://www.geocities.com/grandmashannon/iowa_burials.txt

   Written 1999, Dennis Nicklaus, nicklaus@fnal.gov

*/

proc main ()
{
   list(parts)
   getstrmsg(town, "Enter town for burial index")
        set (town,save(town))

    print("Looking for ") print(town)

        "                         Burials in " town "\n"
    forindi(person, number) {
        set(e,burial(person))

        if (and(e,place(e))) {
                if (index(place(e),town,1)) {
                        extractplaces(e,parts,np)
                        getel(parts,1)
                        call doSite(e) " : "
                        if (female(person)) {
                                /* print out married surnames of women */
                                set(nffam,nfamilies(person))
                                families(person,fam,sp,spi) {
                                        surname(sp)
                                        if (eq(spi,nffam)) {
                                           /* the next IF  is designed to catch a
                                              case where a woman
                                              had one child where the father wasn't
                                              known and she didn't otherwise marry.
                                              In that case, just her maiden
                                              surname will appear, no "nee".
                                              Odd cases will still circumvent this,
                                              and make things look odd, such as
                                              multiple kids by different unknown
                                              fathers, ... I don't care. */

                                           if (or(sp,gt(nffam,1))) {
                                             ", nee "
                                           }
                                        }
                                        else {
                                           /* cover the case where the father's
                                              name isn't known at all.  Don't
                                              print an extra "a.k.a".
                                              odd cases will still look bad,
                                              such as married, then mother with
                                              unknown father. */
                                           if (sp) {
                                              ", a.k.a. "
                                           }
                                        }
                                }
                        }
                        fullname(person,0,0,80)
                        " (" year(birth(person)) "-"    year(death(person)) ")"
                        "\n"
                }
        }
    }
}
proc doSite(event)
{
  fornodes(event, subnode) {
    if (eq(0,strcmp("PLAC", tag(subnode)))) {
      fornodes(subnode, subnode2) {
        if (eq(0,strcmp("ADDR", tag(subnode2)))) {
            ", " value(subnode2)
  }}}}
}



/* bury.c.
   Written 1999, Dennis Nicklaus, nicklaus@fnal.gov
   This program is used as a filter to help format the output of the
   Lifelines report called "burial_index".
   This program makes it so each cemetery name only appears once, with
   the list of people buried in that cemetery listed below it.
   You can compile this simply with:
        cc -o bury bury.c
   To use this, first run the burial index program, then run the
   output of that through Unix's sort (just default arguments to sort),
   then run it through this program.  Suppose your output from burial
   index is called "iowa.txt".
   What I typically do is:
   sort iowa.txt | bury > iowa.sort

   How it works: It just compares each "cemetery name" with the previous one
   in the file.  If the cemetery name is different, it begins a new heading
   for that cemetery, and lists under it each name that follows with the
   same cemetery name.  That's why it's important to run through sort, first.
   For MY typical record, which looks like
   1 NAME First /Last/
   1 BIRT
   2 DATE 31 Dec 1900
   1 DEAT
   2 DATE 1 Jan 2000
   1 BURI
   2 PLAC town,county,state
   3 ADDR cemeteryname
   The lifelines report burial_index produces a line which looks like:

       town,cemetery : Last, First (1900-2000)

   Since I generally make a index for a town, county, or state, running
   sort with default (no) parameters works for me.
   These sorted lines are the input to this program.
*/
/* Start C code.
#include <stdio.h>
char getline (char *line)
{
  char c;
  int in=0;
  c=getchar();
  while ((c != '\n') && (c != EOF)){
    line[in++] = c;
    c=getchar();
  }
  line[in]=0;
  return c;
}
main()
{
  char line[200],last[200],*name;
  int colon,in,maxcompare;
  while(getline(line) != EOF){
    colon = strcspn(line,":");
    maxcompare = strlen(last);
    if (colon > maxcompare) maxcompare = colon;
    if (strncmp(line,last,maxcompare)){
      strncpy(last,line,colon);
      last[colon] = '\0';
      printf("\n\t\t\t%s\n",last);
    }
    name = line+colon+1;
    printf("%s\n",name);
  }
}
 end of C code */
/*  Sample output after going through bury.c:
                        Carlisle, Carlisle Cemetery
 Morgan, Chester Howell (1889-1900)
 Morgan, Elmer Eugene (1861-1931)
 Morgan, nee Dressler, Mary Alice (1861-1950)

                        Carroll
 Walden, nee Lucey, Kathleen J. ``Kay'' (1918-1996)

                        Carroll, Mt. Olivet Cemetery
 Foley, George (1878-1948)
 Foley, nee Cuddy, Mary Cornelia (1885-1972)
 Hamill, Robert J. (1872-1953)
 Hamill, nee Lucey, Jennie Frances (1874-1940)
 Lucey, Edward J. (1849-1922)
 Lucey, George Raymond (1884-1971)
 Lucey, Rosemary (1920-1951)
 Lucey, nee Kemp, Clara Catherine (1887-1969)
 Lucey, Jeremiah ``Jerry'' (1886-1914)
 Lucey, John (1883-1914)
 Lucey, Julia (-1914)
 Lucey, Margaret (-1914)
 Lucey, nee Grace, Mary Elizabeth (1856-1914)

*/