1 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"><html><head><title>Using the GEDCOM parser library</title>
4 <meta http-equiv="content-type" content="text/html; charset=ISO-8859-1"></head><body text="#000000" bgcolor="#ffffff" link="#000099" vlink="#990099" alink="#000099">
6 <h1 align="center">Using the GEDCOM parser library</h1>
12 <li><a href="#anchor">Overview</a></li>
13 <li><a href="#Error_handling">Error handling</a></li>
14 <li><a href="#Data_callback_mechanism">Data callback mechanism</a></li>
17 <li><a href="#Start_and_end_callbacks">Start and end callbacks</a></li>
18 <li><a href="#Default_callbacks">Default callbacks</a></li>
20 </ul><li><a href="#Support_for_writing_GEDCOM_files">Support for writing GEDCOM files</a></li>
22 <li><a href="#Opening_and_closing_files">Opening and closing files</a></li>
23 <li><a href="#Controlling_some_settings">Controlling some settings</a></li>
24 <li><a href="#Writing_data">Writing data</a><br>
27 <li><a href="#Other_API_functions">Other API functions</a></li>
30 <li><a href="#Debugging">Debugging</a></li>
31 <li><a href="#Error_treatment">Error treatment</a></li>
32 <li><a href="#Compatibility_mode">Compatibility mode</a></li>
35 <li><a href="#Converting_character_sets">Converting character sets</a></li>
36 <li><a href="#Support_for_configure.in">Development support</a><br>
39 <li><a href="interface.html">Interface details of the callback parser</a></li><li><a href="gom.html">C object model</a><br>
45 <hr width="100%" size="2">
46 <h2><a name="Overview"></a>Overview<br>
48 parser library provides two interfaces. At the one hand, it can be
49 used as a callback-based parser (comparable to the SAX interface of
50 XML); at the other hand, the parser can be used to convert the GEDCOM file
51 into an object model (comparable to the DOM interface of XML). It comes
55 <li>a library (<code>libgedcom.so</code>), to be linked in the
56 application program, which implements the callback parser</li>
57 <li>a header file (<code>gedcom.h</code>), to be used in the sources
58 of the application program</li>
59 <li>a header file (<code>gedcom-tags.h</code>) that is also installed,
60 but that is automatically included via <code>gedcom.h</code></li></ul>Additionally, if you want to use the GEDCOM C object model, the following should be used (note that <code>libgedcom.so</code> is also needed in this case, because the object model uses the callback parser internally):<br>
62 <li>a library (<code>libgedcom_gom.so</code>), to be linked in the application program, which implements the C object model</li>
63 <li>a header file (<code>gom.h</code>), to be used in the sources of the application program<br>
67 </ul>There is a separate script to help with library and compilation flags, see the <a href="#Support_for_configure.in">development support</a>.<br>
69 Next to these, there is also a data directory in <code>$PREFIX/share/gedcom-parse</code>
70 that contains some additional stuff, but which is not immediately
71 important at first. I'll leave the description of the data directory
74 The very simplest call of the gedcom callback parser is simply the following
75 piece of code (include of the <code>gedcom.h</code> header is assumed, as everywhere
78 <blockquote><code>int result;<br>
80 <b>gedcom_init</b>();<br>
82 result = <b>gedcom_parse_file</b>("myfamily.ged");<br>
84 Although this will not provide much information, one thing it does
85 is parse the entire file and return the result. The function returns
86 0 on success and 1 on failure. No other information is available
87 using this function only.<br>
89 Alternatively, programs using the C object model should use the following (in this case, the inclusion of both <code>gedcom.h</code> and <code>gom.h</code> is required):<br>
91 <blockquote><code>int result;<br>
93 <b>gedcom_init</b>();<br>
95 result = <b>gom_parse_file</b>("myfamily.ged");<br>
97 The call to <code>gom_parse_file</code> will build the C object model, which is then a complete representation of the GEDCOM file.<br>
99 No matter which of the interfaces you use, the call to <code>gedcom_init</code>() should be one of the first calls
100 in your program. The requirement is that it should come before the first
101 call to <code>iconv_open</code> (part of the generic character set conversion
102 feature) in the program, either by your program itself, or indirectly by
103 the library calls it makes. Practically, it should e.g. come before
104 any calls to any GTK functions, because GTK uses <code>iconv_open</code>
105 in its initialization.<br>
107 For the same reason it is also advised to put
108 the <code>-lgedcom</code> option
109 on the linking of the program as the last option, so that its initialization
110 code is run first. In the case of using the C object model, the linking
111 options should be: <code>-lgedcom_gom -lgedcom</code><br>
112 <br>The function <code>gedcom_init()</code> also initializes locale handling by calling <code>setlocale(LC_ALL, "")</code>, in case the application would not do this (it doesn't hurt for the application to do the same).<br>
114 The next sections will refine this piece of code to be able to have
115 meaningful errors and the actual data that is in the file.<br>
117 <hr width="100%" size="2">
118 <h2><a name="Error_handling"></a>Error handling</h2>The library can be used in several different circumstances, both
119 terminal-based as GUI-based. Therefore, it leaves the actual display
120 of the error message up to the application. For this, the application
121 needs to register a callback before parsing the GEDCOM file, which will
122 be called by the library on errors, warnings and messages.<br>
124 A typical piece of code would be (<code>gom_parse_file</code> would be called in case the C object model is used):<br>
126 <blockquote><code>void <b>my_message_handler</b> (Gedcom_msg_type type,
132 <b>gedcom_set_message_handler</b>(my_message_handler);<br>
134 result = <b>gedcom_parse_file</b>("myfamily.ged");</code><br>
136 In the above piece of code, <code>my_message_handler</code> is the
137 callback that will be called for errors (<code>type=ERROR</code>), warnings
138 (<code>type=WARNING</code>) and messages (<code>type=MESSAGE</code>). The
139 callback must have the signature as in the example. For errors,
140 the <code> msg</code> passed to the callback will have the format:<br>
142 <blockquote><code>Error on line</code> <i><lineno></i>: <i><actual_message></i><br>
144 Note that the entire string will be properly internationalized, and
145 encoded in UTF-8 (<a href="encoding.html">Why UTF-8?</a>). Also,
146 no newline is appended, so that the application program can use it in any
147 way it wants. Warnings are similar, but use "Warning" instead of "Error".
148 Messages are plain text, without any prefix.<br>
150 With this in place, the resulting code will already show errors and
151 warnings produced by the parser, e.g. on the terminal if a simple <code>
152 printf</code> is used in the message handler.<br>
154 <hr width="100%" size="2">
155 <h2><a name="Data_callback_mechanism"></a>Data callback mechanism</h2>
156 The most important use of the parser is of course to get the data
157 out of the GEDCOM file. This section focuses on the callback mechanism (see <a href="gom.html">here</a> for the C object model). In fact, the mechanism involves two levels.<br>
159 The primary level is that each of the sections in a GEDCOM file is
160 notified to the application code via a "start element" callback and an
161 "end element" callback (much like in a SAX interface for XML), i.e. when
162 a line containing a certain tag is parsed, the "start element" callback
163 is called for that tag, and when all its subordinate lines with their
164 tags have been processed, the "end element" callback is called for the
165 original tag. Since GEDCOM is hierarchical, this results in properly
166 nested calls to appropriate "start element" and "end element" callbacks.<br>
168 However, it would be typical for a genealogy program to support only
169 a subset of the GEDCOM standard, certainly a program that is still under
170 development. Moreover, under GEDCOM it is allowed for an application
171 to define its own tags, which will typically not be supported by
172 another application. Still, in that case, data preservation is important;
173 it would hardly be accepted that information that is not understood by
174 a certain program is just removed.<br>
176 Therefore, the second level of callbacks involves a "default callback".
177 An application needs to subscribe to callbacks for tags it does support,
178 and need to provide a "default callback" which will be called for tags
179 it doesn't support. The application can then choose to just store
180 the information that comes via the default callback in plain textual format.<br>
182 After this introduction, let's see what the API looks like...<br>
185 <h3><a name="Start_and_end_callbacks"></a>Start and end callbacks</h3>
187 <h4><i>Callbacks for records</i> <br>
189 As a simple example, we will get some information from the header
190 of a GEDCOM file. First, have a look at the following piece of code:<br>
192 <blockquote><code>Gedcom_ctxt <b>my_header_start_cb</b> (Gedcom_rec rec,<br>
193 int level, <br>
194
195 Gedcom_val xref, <br>
196
197 char *tag, <br>
198
199 char *raw_value,<br>
200
201 int parsed_tag, <br>
202
203 Gedcom_val parsed_value)<br>
205 printf("The header starts\n");<br>
206 return (Gedcom_ctxt)1;<br>
209 void <b>my_header_end_cb</b> (Gedcom_rec rec, Gedcom_ctxt self)<br>
211 printf("The header ends, context is %d\n", (int)self);
212 /* context will print as "1" */<br>
216 <b>gedcom_subscribe_to_record</b>(REC_HEAD, my_header_start_cb,
217 my_header_end_cb);<br>
219 result = <b>gedcom_parse_file</b>("myfamily.ged");</code><br>
221 Using the <code>gedcom_subscribe_to_record</code> function, the
222 application requests to use the specified callbacks as start and end
223 callback. The end callback is optional: you can pass <code>NULL</code>
224 if you are not interested in the end callback. The identifiers
225 to use as first argument to the function (here <code>REC_HEAD</code>)
226 are described in the <a href="interface.html#Record_identifiers"> interface
227 details</a> . These are also passed as first argument in the callbacks (the <code>Gedcom_rec</code> argument).<br>
229 From the name of the function it becomes clear that this function
230 is specific to complete records. For the separate elements in records
231 there is another function, which we'll see shortly. Again, the callbacks
232 need to have the signatures as shown in the example.<br>
234 The <code>Gedcom_ctxt</code> type that is used as a result of the
235 start callback and as an argument to the end callback is vital for passing
236 context necessary for the application. This type is meant to be opaque;
237 in fact, it's a void pointer, so you can pass anything via it. The
238 important thing to know is that the context that the application returns
239 in the start callback will be passed in the end callback as an argument,
240 and as we will see shortly, also to all the directly subordinate elements
243 The <code>tag</code> is the GEDCOM tag in string format, the <code>parsed_tag</code>
244 is an integer, for which symbolic values are defined as <code>TAG_HEAD,</code>
245 <code>TAG_SOUR,</code> <code>TAG_DATA,</code> ... and <code>USERTAG
246 </code><code></code> for the application-specific tags. These values
247 are defined in the header <code>gedcom-tags.h</code> that is installed,
248 and included via <code> gedcom.h</code> (so no need to include <code>gedcom-tags.h</code>
251 The example passes a simple integer as context, but an application
252 could e.g. pass a <code>struct</code> (or an object in a C++ application)
253 that will contain the information for the header. In the end callback,
254 the application could then e.g. do some finalizing operations on the
255 <code> struct</code> to put it in its database.<br>
257 (Note that the <code>Gedcom_val</code> type for the <code>xref</code>
258 and <code>parsed_value</code> arguments was not discussed, see further
262 <h4><i>Callbacks for elements</i></h4>
263 We will now retrieve the SOUR field (the name of the program that
264 wrote the file) from the header:<br>
266 <blockquote><code>Gedcom_ctxt <b>my_header_source_start_cb</b>(Gedcom_elt elt,<br>
267
268 Gedcom_ctxt
270
271 int
272 level,<br>
273
274 char*
275 tag,<br>
276
277 char*
278 raw_value,<br>
279
280 int
281 parsed_tag,<br>
282
283 Gedcom_val
284 parsed_value)<br>
286 char *source = GEDCOM_STRING(parsed_value);<br>
287 printf("This file was written by %s\n", source);<br>
288 return parent;<br>
291 void <b>my_header_source_end_cb</b>(Gedcom_elt elt,<br>
292 Gedcom_ctxt parent,<br>
293
294 Gedcom_ctxt self,<br>
295
296 Gedcom_val parsed_value)<br>
298 printf("End of the source description\n");<br>
302 <b>gedcom_subscribe_to_element</b>(ELT_HEAD_SOUR,<br>
303
304 my_header_source_start_cb,<br>
305
306 my_header_source_end_cb);<br>
308 result = <b>gedcom_parse_file</b>("myfamily.ged");</code><br>
310 The subscription mechanism for elements is similar, only the signatures
311 of the callbacks differ. The signature for the start callback shows
312 that the context of the parent line (here e.g. the <code>struct</code>
313 that describes the header) is passed to this start callback. The
314 callback itself returns here in this example the same context, but this
315 can be its own context object of course. The end callback is called
316 with both the context of the parent and the context of itself, which in this
317 example will be the same. Again, the list of identifiers to use as
318 a first argument for the subscription function are detailed in the <a href="interface.html#Element_identifiers"> interface details</a> . Again, these are passed as first argument in the callback (the <code>Gedcom_elt</code> argument).<br>
320 If we look at the other arguments of the start callback, we see the
321 level number (the initial number of the line in the GEDCOM file), the tag
322 (e.g. "SOUR"), and then a raw value, a parsed tag and a parsed value. The
323 raw value is just the raw string that occurs as value on the line next
324 to the tag (in UTF-8 encoding). The parsed value is the meaningful
325 value that is parsed from that raw string. The parsed tag is described
326 in the section for record callbacks above.<br>
328 The <code>Gedcom_val</code> type is meant to be an opaque type. The
329 only thing that needs to be known about it is that it can contain specific
330 data types, which have to be retrieved from it using pre-defined macros.
331 These data types are described in the <a href="interface.html#Gedcom_val_types"> interface details</a>.
334 Some extra notes:<br>
338 <li>The <code>Gedcom_val</code> argument of the end callback
339 is currently not used. It is there for future enhancements.</li>
340 <li>There are also two <code>Gedcom_val</code> arguments
341 in the start callback for records. The first one (<code>xref</code>
342 ) contains the <code>xref_value</code> corresponding to the cross-reference
343 (or <code>NULL</code> if there isn't one), the second one (<code>parsed_value</code>
344 ) contains the value that is parsed from the <code>raw_value</code>. See
345 the <a href="interface.html#Record_identifiers">interface details</a>
352 <h3><a name="Default_callbacks"></a>Default callbacks<br>
354 As described above, an application doesn't always implement the entire
355 GEDCOM spec, and application-specific tags may have been added by other
356 applications. To preserve this extra data anyway, a default callback
357 can be registered by the application, as in the following example:<br>
359 <blockquote><code>void <b>my_default_cb</b> (Gedcom_elt elt, Gedcom_ctxt parent, int level,
360 char* tag, char* raw_value, int parsed_tag)<br>
366 <b>gedcom_set_default_callback</b>(my_default_cb);<br>
368 result = <b>gedcom_parse_file</b>("myfamily.ged");</code><br>
370 This callback has a similar signature as the previous ones,
371 but it doesn't contain a parsed value. However, it does contain the
372 parent context, that was returned by the application for the most specific
373 containing tag that the application supported.<br>
375 Suppose e.g. that this callback is called for some tags in the header
376 that are specific to some other application, then our application could
377 make sure that the parent context contains the struct or object that represents
378 the header, and use the default callback here to add the level, tag and
379 raw_value as plain text in a member of that struct or object, thus preserving
380 the information. The application can then write this out when the
381 data is saved again in a GEDCOM file. To make it more specific, consider
382 the following example:<br>
384 <blockquote><code>struct header {<br>
385 char* source;<br>
387 char* extra_text;<br>
390 Gedcom_ctxt my_header_start_cb(Gedcom_rec rec, int level, Gedcom_val xref, char* tag,
392
393 int parsed_tag, Gedcom_val parsed_value)<br>
395 struct header head = my_make_header_struct();<br>
396 return (Gedcom_ctxt)head;<br>
399 void my_default_cb(Gedcom_elt elt, Gedcom_ctxt parent, int level, char* tag, char*
400 raw_value, int parsed_tag)<br>
402 struct header head = (struct header)parent;<br>
403 my_header_add_to_extra_text(head, level, tag, raw_value);<br>
406 gedcom_set_default_callback(my_default_cb);<br>
407 gedcom_subscribe_to_record(REC_HEAD, my_header_start, NULL);<br>
409 result = gedcom_parse_file(filename);</code><br>
411 Note that the default callback will be called for any tag that isn't
412 specifically subscribed upon by the application, and can thus be called
413 in various contexts. For simplicity, the example above doesn't take
414 this into account (the <code>parent</code> could be of different
415 types, depending on the context).<br>
417 Note also that the default callback is not called when the parent context
418 is <code>NULL</code><code></code>. This is e.g. the case if none
419 of the "upper" tags has been subscribed upon.<br>
422 <hr width="100%" size="2"><br>
423 <h2><a name="Support_for_writing_GEDCOM_files"></a>Support for writing GEDCOM files</h2>
424 The Gedcom parser library also contains functions to writing GEDCOM files.
425 Similar as for the parsing itself, there are two interfaces: an interface
426 which is very basic, and requires you to call a function for each line in
427 the GEDCOM file, and an interface which just dumps the Gedcom object model
428 to a file in one shot (if you use the Gedcom object model).<br>
430 Again, this section focuses on the basic interface, the Gedcom object model interface is described <a href="gom.html#Writing_the_object_model_to_file">here</a>.<br>
432 <h3><a name="Opening_and_closing_files"></a>Opening and closing files</h3>
433 The basic functions for opening and closing Gedcom files for writing are the following:<br>
435 <blockquote><code>Gedcom_write_hndl <b>gedcom_write_open</b> (const char* filename);<br>
436 int <b>gedcom_write_close</b> (Gedcom_write_hndl hndl, int* total_conv_fails);<br></code></blockquote>
437 The function <code>gedcom_write_open</code> takes a parameter the name of
438 the file to write, and returns a write handle, which needs to be used in
439 subsequent functions. It returns <code>NULL</code> in case of errors.<br>
441 The function <code>gedcom_write_close</code> takes, next to the write handle,
442 an integer pointer as parameter. If you pass an actual pointer for
443 this, the function will write in it the total number of conversion failures;
444 you can pass <code>NULL</code> if you're not interested. The function returns 0 in case of success, non-zero in case of failure.<br>
446 <h3><a name="Controlling_some_settings"></a>Controlling some settings<br>
448 Note that by default the file is written in ASCII encoding (and hence e.g.
449 accented characters will cause a conversion failure). You can change
450 this by calling the following function <i>before</i> calling <code>gedcom_write_open</code>, i.e. it affects all files that are opened after it is being called:<code></code><code><br>
452 <blockquote><code>int <b>gedcom_write_set_encoding</b> (const char* charset, Encoding width, Enc_bom bom);<br></code></blockquote>
453 The valid <code>charset</code> values are given in the first column in the file <code>gedcom.enc</code> in the data directory of gedcom-parse (<code>$PREFIX/share/gedcom-parse</code>).
454 The character sets UNICODE, ASCII and ANSEL are always supported (these
455 are standard for GEDCOM), as well as ANSI (not standard), but there may be
458 The <code>width</code> parameter takes one of the following values:<br>
462 <li><code><b>ONE_BYTE</b></code>: This should be used for all character sets except UNICODE.</li>
463 <li><code><b>TWO_BYTE_HILO</b></code>: High-low encoding for UNICODE (i.e. big-endian)</li>
464 <li><code><b>TWO_BYTE_LOHI</b></code>: Low-high encoding for UNICODE (i.e. little-endian)</li>
466 The <code>bom</code> parameter determines whether a byte-order-mark should
467 be written in the file in case of UNICODE encoding (usually preferred because
468 it then clearly indicates the byte ordering). It takes one of the following
471 <li><code><b>WITHOUT_BOM</b></code></li>
472 <li><code><b>WITH_BOM</b></code></li>
473 </ul> For both these parameters you can pass 0 for non-UNICODE encodings,
474 since that corresponds to the correct values (and is ignored anyway). The
475 function returns 0 in case of success, non-zero in case of error. Note
476 that you still need to pass the correct charset value for the HEAD.CHAR tag,
477 otherwise you will get a warning, and the value will be forced to the correct
480 Further, it is possible to control the kind of line terminator that is used, via the following function (also to be used before <code>gedcom_write_open</code>):<br>
481 <blockquote><code>int <b>gedcom_write_set_line_terminator</b> (Enc_line_end end);<br></code></blockquote>
482 The <code>end</code> parameter takes one of the following values:<br>
484 <li><b><code>END_CR</code></b>: only carriage return ("/r") (cf. Macintosh)</li>
485 <li><b><code>END_LF</code></b>: only line feed ("/n") (cf. Unix, Mac OS X)</li>
486 <li><b><code>END_CR_LF</code></b>: first carriage return, then line feed ("/r/n") (cf. DOS, Windows)</li>
487 <li><b><code>END_LF_CR</code></b>: first line feed, then carriage return ("/n/r")</li>
489 By default, this is set to the appropriate line terminator on the current
490 platform, so it only needs to be changed if there is some special reason
492 <h3><a name="Writing_data"></a>Writing data<br>
494 For actually writing the data, the principle is that every line in the GEDCOM
495 file to write corresponds to a call to one of the following functions, except
496 that CONT/CONC lines can be automatically taken care of. Note that
497 the resulting GEDCOM file should conform to the GEDCOM standard. Several
498 checks are built in already, and more will follow, to force this. There
499 is (currently) no compatibility mode for writing GEDCOM files.<br>
501 In general, each of the following functions expect their input in UTF-8 encoding (see also <a href="#Converting_character_sets">here</a>). If this is not the case, errors will be returned.<br>
503 Note that for examples of using these functions you can look at the sources for the Gedcom object model (e.g. the function <code>write_header</code> in <code>gom/header.c</code>).<br>
505 For writing lines corresponding to records (i.e. on level 0), the following function is available:
506 <blockquote><code>int <b>gedcom_write_record_str</b> (Gedcom_write_hndl hndl, Gedcom_rec rec, char* xrefstr, char* value);<br></code></blockquote>
507 The <code>hndl</code> parameter is the write handle that was returned by <code>gedcom_write_open</code>. The <code>rec</code> parameter is one of the identifiers given in the first column in <a href="interface.html#Record_identifiers">this table</a> (except <code>REC_USER</code>: see below). The <code>xrefstr</code> and <code>val</code> parameters are respectively the cross-reference key of the record (something like '<code>@FAM01@</code>'), and the value of the record line, which should be <code>NULL</code> for some record types, according to the same table.<br>
509 For writing lines corresponding to elements (inside records, i.e. on a level
510 bigger than 0), the following functions are available, depending on the data
512 <blockquote><code>int <b>gedcom_write_element_str</b> (Gedcom_write_hndl hndl, Gedcom_elt elt, int parsed_tag, <br>
513
514 int parent_rec_or_elt, char* value);<br>
515 i</code><code>nt <b>gedcom_write_element_xref</b> (Gedcom_write_hndl hndl, Gedcom_elt elt, int parsed_tag, <br>
516
517 int parent_rec_or_elt, struct xref_value*
519 <code>int <b>gedcom_write_element_date</b> (Gedcom_write_hndl hndl, Gedcom_elt elt, int parsed_tag, <br>
520
521 int parent_rec_or_elt, struct date_value*
523 <code>i</code><code>nt <b>gedcom_write_element_age </b> (Gedcom_write_hndl hndl, Gedcom_elt elt, int parsed_tag, <br>
524
525 int parent_rec_or_elt, struct age_value*
528 <blockquote><code></code></blockquote>
529 These functions only differ in the type of the last argument, which is the value of the element.<br>
531 The <code>hndl</code> parameter is again the write handle returned by <code>gedcom_write_open</code>. The <code>elt</code> parameter is one of the identifiers given in the first column in <a href="interface.html#Element_identifiers">this table</a> (except <code>ELT_USER</code>: see below). The <code>parent_rec_or_elt</code> is the corresponding <code>rec</code> or <code>elt</code>
532 identifier of the logically enclosing statement: this will determine the
533 level number written on the line, as the level number of the parent + 1.<br>
535 Some of the identifiers can actually stand for different tags. For this reason, the <code>parsed_tag</code> has to be passed for some of them. This parsed tag is the same as was returned by the callback functions defined <a href="#Start_and_end_callbacks">above</a>, and is an identifier of the form <code>TAG_<i>name</i></code>. This parameter is needed whenever the second column in <a href="interface.html#Element_identifiers">this table</a> shows several possible tags (this is e.g. the case for <code>ELT_SUB_FAM_EVT</code>).<br>
537 Note that for writing a date value, the given value should be valid, i.e.
538 all its struct fields filled in properly and consistent. This can be
539 done by calling <code>gedcom_normalize_date</code> (see <a href="interface.html#date">here</a>).<br>
540 <h4>User-defined tags</h4>
541 For user-defined tags (tags starting with an underscore), there are separate functions, again depending on the data type:<code></code>
542 <blockquote><code>int <b>gedcom_write_user_str</b> (Gedcom_write_hndl hndl, int level, char* tag, char* xrefstr,<br>
543 char* value);<br>
544 i</code><code>nt <b>gedcom_write_user_xref</b> (Gedcom_write_hndl hndl, </code><code>int level, char* tag, char* xrefstr,</code><br>
546 struct xref_value* value);</code><br>
547 <code></code></blockquote>
548 In the case of user-defined tags, the level and tag string are passed verbatim
549 (not controlled by the library). This allows to write any extra data
550 that doesn't use a standard tag, but is only allowed for tags starting with
552 <hr width="100%" size="2">
554 <h2><a name="Other_API_functions"></a>Other API functions<br>
557 Although the above describes the basic interface of the gedcom parser, there
558 are some other functions that allow to customize the behaviour of the library.
559 These will be explained in the current section.<br>
562 <h3><a name="Debugging"></a>Debugging</h3>
563 The library can generate various debugging output, not only from itself,
564 but also the debugging output generated by the yacc parser. By default,
565 no debugging output is generated, but this can be customized using the
566 following function:<br>
569 <blockquote><code>void <b>gedcom_set_debug_level</b> (int level, FILE*
570 trace_output)</code><br>
572 The <code>level</code> can be one of the following values:<br>
576 <li>0: no debugging information (this is the
578 <li>1: only debugging information from libgedcom
580 <li>2: debugging information from libgedcom
585 If the <code>trace_output</code> is <code>NULL</code>, debugging information
586 will be written to <code>stderr</code>, otherwise the given file handle
587 is used (which must be open).<br>
591 <h3><a name="Error_treatment"></a>Error treatment</h3>
592 One of the previous sections already described the callback to be
593 registered to get error messages. The library also allows to customize
594 what happens on an error, using the following function:<br>
597 <blockquote><code>void <b>gedcom_set_error_handling</b> (Gedcom_err_mech
598 mechanism)</code><br>
600 The <code>mechanism</code> can be one of:<br>
604 <li><code>IMMED_FAIL</code>: immediately fail
605 the parsing on an error (this is the default)</li>
606 <li><code>DEFER_FAIL</code>: continue parsing
607 after an error, but return a failure code eventually</li>
608 <li><code>IGNORE_ERRORS</code>: continue parsing
609 after an error, return success always</li>
613 This doesn't influence the generation of error or warning messages,
614 only the behaviour of the parser and its return code.<br>
618 <h3><a name="Compatibility_mode"></a>Compatibility mode<br>
620 Applications are not necessarily true to the GEDCOM spec (or use a
621 different version than 5.5). The intention is that the library is
622 resilient to this, and goes in compatibility mode for files written by specific
623 programs (detected via the HEAD.SOUR tag). This compatibility mode
624 can be enabled and disabled via the following function:<br>
627 <blockquote><code>void <b>gedcom_set_compat_handling</b> (int enable_compat)</code><br>
629 The argument can be:<br>
633 <li>0: disable compatibility mode</li>
634 <li>1: allow compatibility mode (this is the
640 Currently, there is a beginning for compatibility for ftree and Lifelines (3.0.2).<br>
642 <hr width="100%" size="2">
643 <h2><a name="Converting_character_sets"></a>Converting character sets</h2>
644 All strings passed by the GEDCOM parser to the application are in UTF-8
645 encoding. Typically, an application needs to convert this to something
646 else to be able to display it.<br>
648 The most common case is that the output character set is controlled by
649 the <code>locale</code> mechanism (i.e. via the <code>LANG</code>, <code>
650 LC_ALL</code> or <code>LC_CTYPE</code> environment variables), which also
651 controls the <code>gettext</code> mechanism in the application. <br>
653 gedcom-parse</code> comes a library implementing help functions for UTF-8 encoding (<code></code>see
654 the <a href="utf8tools.html">documentation</a> for this library).<br>
657 <hr width="100%" size="2">
659 <h2><a name="Support_for_configure.in"></a>Development support</h2>
660 <h3>Macro for configure.in<br>
663 is a macro available for use in configure.in for applications that are using
664 autoconf to configure their sources. The following macro checks whether
665 the Gedcom parser library is available and whether its version is high enough:<br>
666 <blockquote><code>AM_PATH_GEDCOM_PARSER([<i>min_version</i>,[<i>action_if_found</i>,[<i>action_if_not_found,</i>[<i>modules</i>]]]])</code><br>
668 All the arguments are optional and default to 0. E.g. to check for
669 version 1.34.2, you would put in configure.in the following statement:<br>
670 <blockquote><code>AM_PATH_GEDCOM_PARSER(1.34.2)</code><br>
671 </blockquote>Note that version numbers now contains three parts (since version
672 0.20.0: this is also the first version in which this macro is available).<br>
674 The macro also sets the variables <code>GEDCOM_CFLAGS</code> and <code>GEDCOM_LIBS</code> for use in Makefiles. Typically, this would be done as follows in a Makefile.am:<br>
675 <blockquote><code>bin_programs = myprg</code><br>
676 <code>myprg_SOURCES = myprg.c foo.c bar.c<br>
677 INCLUDES = @GEDCOM_CFLAGS@<br>
678 LDADD = @GEDCOM_LIBS@</code></blockquote>
679 If your program uses some extra modules, they can be passed as fourth argument
680 in the macro, so that the CFLAGS and LIBS are correctly filled in. Currently,
681 the only available module is <code>gom</code> (the Gedcom object model). For example:<br>
682 <blockquote><code>AM_PATH_GEDCOM_PARSER(0.21.2, , ,gom)</code><br>
684 To be able to use this macro in the sources of your application, you have three options:<br>
686 <li>Put the file <code>m4/gedcom.m4</code> in your autoconf data directory (i.e. the path given by '<code>aclocal --print-ac-dir</code>', usually <code>/usr/share/aclocal</code>). You can do this automatically by going into the m4 subdirectory and typing '<code>make install-m4</code>'.<br>
689 <li>If you're using autoconf, but not automake, copy the contents of <code>m4/gedcom.m4</code> in the <code>aclocal.m4</code> file in your sources.<br>
692 <li>If you're using automake, copy the contents of <code>m4/gedcom.m4</code> in the <code>acinclude.m4</code> file in your sources.<br>
696 There are three preprocessor symbols defined for version checks in the
697 header (but their direct use is deprecated: please use the macro above):<br>
700 <li><code>GEDCOM_PARSE_VERSION_MAJOR</code></li>
701 <li><code>GEDCOM_PARSE_VERSION_MINOR</code></li>
702 <li><code>GEDCOM_PARSE_VERSION</code><br>
706 The last one is equal to <code>(GEDCOM_PARSE_VERSION_MAJOR * 1000) + GEDCOM_PARSE_VERSION_MINOR.</code> As you see, this only checked the major and minor version, not the patch number, so this is obsolete.<br>
708 <h3>Compilation and linking flags</h3>
709 Similar to other libraries, the GEDCOM parse library installs a script <code>gedcom-config</code> to help with compilation and linking flags for programs that don't use autoconf/automake.<br>
711 To get compilation flags for your program, use (depending on whether you
712 only use the callback parser, or also the GEDCOM object model):
713 <blockquote><code>gedcom-config --cflags<br>
714 gedcom-config --cflags gom</code><br>
716 Similarly, to get linking flags, use one of the following:
717 <blockquote><code>gedcom-config --libs<br>
718 gedcom-config --libs gom</code><br>
723 <hr width="100%" size="2">
725 <pre><font size="-1">$Id$<br>$Name$</font><br></pre>
projects / gedcom-parse.git / blob