← Back to branch summary

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

« back to all changes in this revision

Viewing changes to reports/ssdi-import.ll

  • 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:
reports/ssdi-import.ll
 
1
/*
 
2
 * @progname       ssdi-import.ll
 
3
 * @version        1994-11-12
 
4
 * @author         Kurt Baudendistel (baud@research.att.com)
 
5
 * @category       
 
6
 * @output         GEDCOM
 
7
 * @description
 
8
 *
 
9
 * Convert ssdi gedcom to lifelines-standard gedcom
 
10
 *
 
11
 *      12 NOV 1994 (3.0.1)             baud@research.att.com
 
12
 *                                      Derived from import-igi.
 
13
 */
 
14
 
 
15
proc main ()
 
16
{
 
17
  getstrmsg (msg, "SSDI Version [default X/1992]?")
 
18
  if (streq (msg, "")) {
 
19
    set (ssdiversion, "X")
 
20
    set (ssdidate, "1992")
 
21
  } else {
 
22
    if (i, index (msg, "/", 1)) {
 
23
      set (ssdiversion, save (trim (msg, sub (i, 1))))
 
24
      set (ssdidate, save (cut (msg, add(i, 1))))
 
25
    } else {
 
26
      set (ssdiversion, save (msg))
 
27
      set (ssdidate, "")
 
28
    }
 
29
  }
 
30
 
 
31
  "0 HEAD \n"
 
32
  "1 SOUR LIFELINES\n"
 
33
  "2 VER 3.0.1\n"
 
34
  "2 NAME SSDI-IMPORT REPORT\n"
 
35
  "1 DEST LIFELINES\n"
 
36
  "2 VER 3.0.1\n"
 
37
  "1 DATE " date (gettoday ()) "\n"
 
38
  "1 COPR Copyright " date (gettoday ()) ". Permission is granted to repro"
 
39
    "duce any subset\n2 CONT of the data contained herein under the condit"
 
40
    "ion that this copyright\n2 CONT notice is preserved, that the origina"
 
41
    "l source citations referenced\n2 CONT in the subset are included, and"
 
42
    " that the submitter of this file is\n2 CONT credited with original au"
 
43
    "thorship as appropriate.\n"
 
44
  "1 CHAR ASCII\n"
 
45
 
 
46
  "0 @S1@ SOUR\n"
 
47
  "1 NAME Social Security Death Index\n"
 
48
  if (strlen (ssdiversion)) {
 
49
    "1 VER " ssdiversion "\n"
 
50
  }
 
51
  if (strlen (ssdidate)) {
 
52
    "1 DATE " ssdidate "\n"
 
53
  }
 
54
 
 
55
  print ("Processing nodes ...\n")
 
56
  forindi (indi, in) {
 
57
    print ("i")
 
58
    ssdiimport (indi)
 
59
  }
 
60
 
 
61
  "0 TRLR \n"
 
62
}
 
63
 
 
64
func ssdiimport (indi)
 
65
{
 
66
  set (number, 0)
 
67
  set (residences, 0)
 
68
  set (root, inode (indi))
 
69
  forlist (subnodes (root, "NOTE"), note, nn) {
 
70
    if (streq (trim (value (note), 24), "Social Security Number: ")) {
 
71
      set (number, save (cut (value (note), 25)))
 
72
    } elsif (streq (value (note), "Death Residence Localities")) {
 
73
      set (residences, localities (note))
 
74
    }
 
75
    deletenode (note)
 
76
  }
 
77
 
 
78
  reformatnames (root, "@S1@")
 
79
 
 
80
  if (number) {
 
81
    set (ssn, createnode ("SSN", number))
 
82
    if (birthplace, subnode (birth (indi), "PLAC")) {
 
83
      if (streq (value (birthplace), "Not Identified")) {
 
84
        set (ssnsour,
 
85
          createnodes ("SOUR",
 
86
            concat ("Issued to ",
 
87
              concat (fullname (indi, 0, 1, 999),
 
88
                ", but no location of issuance was identified."))))
 
89
      } else {
 
90
        set (ssnsour,
 
91
          createnodes ("SOUR",
 
92
            concat ("Issued in ",
 
93
              concat (value (birthplace),
 
94
                concat (" to ",
 
95
                  concat (fullname (indi, 0, 1, 999), "."))))))
 
96
      }
 
97
      catnode (ssnsour, createnode ("SOUR", "@S1@"))
 
98
      catnode (ssn, ssnsour)
 
99
    } else {
 
100
      catnode (ssn, createnode ("SOUR", "@S1@"))
 
101
    }
 
102
    addnode (ssn, root, subnode (root, "NAME"))
 
103
  }
 
104
 
 
105
  if (birth (indi)) {
 
106
    if (birthplace, subnode (birth (indi), "PLAC")) {
 
107
      deletenode (birthplace)
 
108
    }
 
109
    catnode (birth (indi), createnode ("SOUR", "@S1@"))
 
110
  }
 
111
 
 
112
  if (death (indi)) {
 
113
    set (deathplace, subnode (death (indi), "PLAC"))
 
114
    set (zip, "an unknown")
 
115
    if (code, dequeue (residences)) {
 
116
      if (streq (trim (code, 10), "Zip Code: ")) {
 
117
        set (zip, save (concat ("the ", cut (code, 11))))
 
118
      } else {
 
119
        requeue (residences, zip)
 
120
      }
 
121
    }
 
122
    if (rn, residences) {
 
123
      forlist (residences, res, rn) {
 
124
        catnode (death (indi), createnode ("PLAC", res))
 
125
        if (and (deathplace, index (res, value (deathplace), 1))) {
 
126
          deletenode (deathplace)
 
127
          set (deathplace, 0)
 
128
        }
 
129
      }
 
130
    }
 
131
    if (and (deathplace, not (value (deathplace)))) {
 
132
      deletenode (deathplace)
 
133
    }
 
134
    if (rn) {
 
135
      if (eq (rn, 1)) {
 
136
        set (trailer, " zip code.")
 
137
      } else {
 
138
        set (trailer, " zip code, which encompasses the named localities.")
 
139
      }
 
140
      set (sour, createnodes ("SOUR",
 
141
        concat3 ("The residence at the time of death was in ", zip, trailer)))
 
142
      catnode (sour, createnode ("SOUR", "@S1@"))
 
143
      catnode (death (indi), sour)
 
144
    } else {
 
145
      catnode (death (indi), createnode ("SOUR", "@S1@"))
 
146
    }
 
147
  }
 
148
 
 
149
  gedcomnode (root)
 
150
  return (0)
 
151
}
 
152
 
 
153
func localities (root) {
 
154
  list (residences)
 
155
  if (root) {
 
156
    fornodes (root, node) {
 
157
      enqueue (residences, value (node))
 
158
    }
 
159
  }
 
160
  return (residences)
 
161
}
 
162
 
 
163
/* common import/export functions */
 
164
 
 
165
func cond (x, a, b) {
 
166
  if (x) {
 
167
    return (a)
 
168
  } else {
 
169
    return (b)
 
170
  }
 
171
}
 
172
 
 
173
func gedcomnode (root) {
 
174
  traverse (root, node, level) {
 
175
    d (level)
 
176
    if (x, xref (node))  { " " x }
 
177
    if (x, tag (node))   { " " x }
 
178
    if (x, value (node)) { " " x }
 
179
    "\n"
 
180
  }
 
181
  return (0)
 
182
}
 
183
 
 
184
func denull (alist) {
 
185
  list (blist)
 
186
  forlist (alist, a, an) {
 
187
    if (a) { enqueue (blist, a) }
 
188
  }
 
189
  return (blist)
 
190
}
 
191
 
 
192
func reformatdates (root) {
 
193
  traverse (root, node, level) {
 
194
    if (streq (tag (node), "DATE")) {
 
195
      if (v, value (node)) {
 
196
        if (and (eq (index (v, "<", 1), 1),
 
197
                 eq (index (v, ">", 1), strlen (v)))) {
 
198
          replacenode
 
199
            (createnode ("DATE", save (substring (v, 2, sub (strlen (v), 1)))),
 
200
             subnode (node, "DATE"))
 
201
        }
 
202
      }
 
203
    }
 
204
  }
 
205
  return (0)
 
206
}
 
207
 
 
208
func reformatnames (root, sourcetext) {
 
209
  list (namelist)
 
210
  list (surnamelist)
 
211
  list (choppedsurnamelist)
 
212
  list (newchoppedsurnamelist)
 
213
  if (namenode, subnode (root, "NAME")) {
 
214
    extractnames (namenode, namelist, nameN, surnameN)
 
215
    set (lastnamenode, namenode)
 
216
    forlist (namelist, s, sn) {
 
217
      set (s, strremove (s, "."))
 
218
      set (s, strremove (s, "_"))
 
219
      setel (namelist, sn, s)
 
220
    }
 
221
    enqueue (surnamelist, getel (namelist, surnameN))
 
222
    while (surname, dequeue (surnamelist)) {
 
223
      set (choppedsurnamelist, strchop (surname, " "))
 
224
      forlist (choppedsurnamelist, s, sn) {
 
225
        if (streq ("VON", s)) {
 
226
          enqueue (newchoppedsurnamelist, s)
 
227
        } elsif (streq ("DER", s)) {
 
228
          enqueue (newchoppedsurnamelist, s)
 
229
        } elsif (and (eq (index (s, "(", 1), 1),
 
230
                      eq (index (s, ")", 1), strlen (s)))) {
 
231
          enqueue (surnamelist, save (substring (s, 2, sub (strlen (s), 1))))
 
232
        } else {
 
233
          enqueue (newchoppedsurnamelist, save (capitalize (lower (s))))
 
234
        }
 
235
      }
 
236
      set (newsurname, strjoin (newchoppedsurnamelist, " "))
 
237
      if (strlen (newsurname)) {
 
238
        if (i, index (newsurname, "Mc ", 1)) {
 
239
          set (newsurname, save (concat (trim (newsurname, add (i, 1)),
 
240
                                         cut (newsurname, add (i, 3)))))
 
241
        }
 
242
        set (newsurname, save (concat3 ("/", newsurname, "/")))
 
243
      }
 
244
      setel (namelist, surnameN, newsurname)
 
245
      set (newnamenode, createnode ("NAME", strjoin (namelist, " ")))
 
246
      addnode (newnamenode, parent (lastnamenode), lastnamenode)
 
247
      if (sourcetext) {
 
248
        catnode (newnamenode, createnode ("SOUR", sourcetext))
 
249
      }
 
250
      set (lastnamenode, newnamenode)
 
251
    }
 
252
    deletenode (namenode)
 
253
  }
 
254
  return (0)
 
255
}
 
256
 
 
257
func streq (x, y) {
 
258
  return (not (strcmp (x, y)))
 
259
}
 
260
 
 
261
func createnodes (tag, text) {
 
262
  set (text, trimspaces (text))
 
263
  if (le (strlen (text), 72)) {
 
264
    return (createnode (tag, text))
 
265
  } else {
 
266
    list (textlist)
 
267
    while (gt (strlen (text), 72)) {
 
268
      set (n, 1)
 
269
      if (i, index (text, " ", n)) {
 
270
        set (j, i)
 
271
      } else {
 
272
        set (j, add (strlen (text), 1))
 
273
      }
 
274
      while (and (i, lt (i, 73))) {
 
275
        incr (n)
 
276
        set (j, i)
 
277
        set (i, index (text, " ", n))
 
278
      }
 
279
      enqueue (textlist, save (trim (text, sub (j, 1))))
 
280
      set (text, save (cut (text, add (j, 1))))
 
281
    }
 
282
    if (gt (strlen (text), 0)) {
 
283
      enqueue (textlist, text)
 
284
    }
 
285
    set (root, createnode (tag, dequeue (textlist)))
 
286
    set (lastnode, 0)
 
287
    forlist (textlist, text, tn) {
 
288
      set (node, createnode ("CONT", text))
 
289
      addnode (node, root, lastnode)
 
290
      set (lastnode, node)
 
291
    }
 
292
    return (root)
 
293
  }
 
294
}
 
295
 
 
296
func trimspaces (text) {
 
297
  set (ss, 0)
 
298
  set (s0, 1)
 
299
  set (sn, strlen (text))
 
300
  while (and (le (s0, sn), streq (substring (text, s0, s0), " "))) {
 
301
    set (ss, 1)
 
302
    incr (s0)
 
303
  }
 
304
  while (and (le (s0, sn), streq (substring (text, sn, sn), " "))) {
 
305
    set (ss, 1)
 
306
    decr (sn)
 
307
  }
 
308
  if (ss) {
 
309
    return (save (substring (text, s0, sn)))
 
310
  } else {
 
311
    return (text)
 
312
  }
 
313
}
 
314
 
 
315
func catnode (root, newnode) {
 
316
  if (root) {
 
317
    set (lastnode, 0)
 
318
    fornodes (root, node) {
 
319
      set (lastnode, node)
 
320
    }
 
321
    addnode (newnode, root, lastnode)
 
322
  }
 
323
  return (0)
 
324
}
 
325
 
 
326
func strchop (s, d) {
 
327
  list (slist)
 
328
  set (dn, strlen (d))
 
329
  if (strlen (s)) {
 
330
    set (n, 1)
 
331
    set (s0, 1)
 
332
    while (sn, index (s, d, n)) {
 
333
      enqueue (slist, save (substring (s, s0, sub (sn, 1))))
 
334
      set (s0, add (sn, dn))
 
335
      incr (n)
 
336
    }
 
337
    enqueue (slist, save (cut (s, s0)))
 
338
  }
 
339
  return (slist)
 
340
}
 
341
 
 
342
func strjoin (slist, d) {
 
343
  forlist (slist, s, sn) {
 
344
    if (not (strlen (str))) {
 
345
      set (str, s)
 
346
    } elsif (strlen (s)) {
 
347
      set (str, save (concat3 (str, d, s)))
 
348
    }
 
349
  }
 
350
  return (str)
 
351
}
 
352
 
 
353
func subnode (root, tag) {
 
354
  if (root) {
 
355
    fornodes (root, node) {
 
356
      if (streq (tag (node), tag)) {
 
357
        return (node)
 
358
      }
 
359
    }
 
360
  }
 
361
  return (0)
 
362
}
 
363
 
 
364
func subnodes (root, tag) {
 
365
  list (nodelist)
 
366
  if (root) {
 
367
    fornodes (root, node) {
 
368
      if (streq (tag (node), tag)) {
 
369
        enqueue (nodelist, node)
 
370
      }
 
371
    }
 
372
  }
 
373
  return (nodelist)
 
374
}
 
375
 
 
376
func replacenode (newnode, oldnode) {
 
377
  if (newnode) {
 
378
    if (root, parent (oldnode)) {
 
379
      addnode (newnode, root, oldnode)
 
380
      deletenode (oldnode)
 
381
    }
 
382
  }
 
383
  return (0)
 
384
}
 
385
 
 
386
func concat3 (x, y, z) {
 
387
  return (concat (x, concat (y, z)))
 
388
}
 
389
 
 
390
func cut (s, n) {
 
391
  return (substring (s, n, strlen (s)))
 
392
}
 
393
 
 
394
func values (root) {
 
395
  if (root) {
 
396
    set (str, value (root))
 
397
    fornodes (root, node) {
 
398
      if (not (str)) {
 
399
        set (str, value (node))
 
400
      } elsif (strlen (value (node))) {
 
401
        set (str, save (concat3 (str, " ", value (node))))
 
402
      }
 
403
    }
 
404
    return (str)
 
405
  } else {
 
406
    return (0)
 
407
  }
 
408
}
 
409
 
 
410
func strremove (s, d) {
 
411
  if (strlen (s)) {
 
412
    while (i, index (s, d, 1)) {
 
413
      set (s, save (concat (trim (s, sub (i, 1)), cut (s, add (i, 1)))))
 
414
    }
 
415
  }
 
416
  return (s)
 
417
}