docs/specifications/config-api.txt

   1 ===============================
   2  gEDA Configuration System API
   3 ===============================
   4
   5 :Author: Peter Brett
   6 :Status: Proposed Specification
   7
   8 ..
   9   This document can be processed with docutils <http://docutils.sf.net>
  10   to generate HTML or LaTeX.  However, the markup is designed to be
  11   fully human-readable as-is.
  12
  13 .. contents::
  14 ..
  15     1  Introduction
  16     2  Error Handling
  17       2.1  Errors in C functions
  18       2.2  Errors in Scheme functions
  19     3  Configuration Contexts
  20       3.1  Obtaining a Context
  21         3.1.1  Default context
  22         3.1.2  System context
  23         3.1.3  User context
  24       3.2  Loading configuration files
  25       3.3  Saving configuration files
  26       3.4  Context parents
  27       3.5  Context trust
  28     4  Configuration Parameters
  29       4.1  Groups
  30       4.2  Keys
  31       4.3  Configuration inheritance
  32       4.4  Values
  33         4.4.1  Getting configuration values
  34         4.4.2  Setting configuration values
  35     5  Configuration Events
  36       5.1  Event propagation
  37       5.2  Handlers
  38       5.3  Delaying events
  39     6  References
  40
  41 Introduction
  42 ============
  43
  44 This document outlines the API provided by libgeda for configuration
  45 of both libgeda and applications based on it.  The API is designed for
  46 not only saving and loading static configuration data to and from
  47 permanent storage, but also to allow on-line event-driven updates to
  48 the configuration state.  The API is designed to be equally usable
  49 from C code and from Scheme extensions.  It is heavily inspired by the
  50 ``GKeyFile`` API from GLib, with a few changes and enhancements
  51 [GLIB]_.
  52
  53 Error Handling
  54 ==============
  55
  56 Errors in C functions
  57 ---------------------
  58
  59 Recoverable errors that occur in C functions are signalled to the
  60 caller using the "GError" mechanism [GLIB]_.
  61
  62 - File errors (e.g. "Access denied" or "File not found") are indicated
  63   using the ``G_IO_ERROR`` error domain.  See the GIO manual for
  64   information on error codes.  Functions that may cause a
  65   ``G_IO_ERROR`` are clearly noted as such.
  66
  67 - All other errors are indicated using the ``EDA_CONFIG_ERROR`` error
  68   domain.  The possible error codes are:
  69
  70   ``EDA_CONFIG_ERROR_UNKNOWN_ENCODING``
  71     The text being parsed was in an unknown encoding.
  72
  73   ``EDA_CONFIG_ERROR_PARSE``
  74     The configuration data was ill-formed.
  75
  76   ``EDA_CONFIG_ERROR_KEY_NOT_FOUND``
  77     A requested configuration key was not found.
  78
  79   ``EDA_CONFIG_ERROR_GROUP_NOT_FOUND``
  80     A requested configuration group was not found.
  81
  82   ``EDA_CONFIG_ERROR_INVALID_VALUE``
  83     A configuration value could not be parsed into the requested
  84     format.
  85
  86 Errors in Scheme functions
  87 --------------------------
  88
  89 All errors in Scheme functions are reported by raising Guile errors
  90 [GUILE]_.  There are two possible error keys that may arise:
  91
  92 - File errors (e.g. "Access denied" or "File not found") are indicated
  93   with the ``system-error`` key.
  94
  95 - All other errors are indicated using the ``config-error`` key.  The
  96   ``data`` part of the error arguments is a list containing one of the
  97   following symbols:
  98
  99   ``unknown-encoding``
 100     The text being parsed was in an unknown encoding.
 101
 102   ``parse``
 103     The configuration data was ill-formed.
 104
 105   ``key-not-found``
 106     A requested configuration key was not found.
 107
 108   ``group-not-found``
 109     A requested configuration group was not found.
 110
 111   ``invalid-value``
 112     A configuration value could not be parsed into the requested
 113     format.
 114
 115 Configuration Contexts
 116 ======================
 117
 118 A configuration parameter is always evaluated within a *configuration
 119 context*.  Each context is associated with a configuration file
 120 (although the file does not necessarily need to exist).
 121
 122 Each configuration context may have a *parent context*.  If, when
 123 looking up a parameter, it has no value set in the selected context,
 124 the parent context is checked, and so on.
 125
 126 Configuration contexts are reference counted.  You can increment and
 127 decrement their reference counters using ``g_object_ref()`` and
 128 ``g_object_unref()`` [GOBJECT]_.
 129
 130 Three special contexts are always automatically defined: the `default
 131 context`_, the `system context`_, and the `user context`_.  The user
 132 context is the default parent context for newly-created configuration
 133 contexts.
 134
 135 Obtaining a Context
 136 -------------------
 137
 138 C function::
 139
 140   EdaConfig *eda_config_get_context_for_path (const gchar *path,
 141                                               GError *error)
 142
 143 Scheme function::
 144
 145   path-config-context path
 146
 147 Normally, you shouldn't create a configuration context directly; you
 148 should obtain the configuration context associated with a ``path``.
 149 If a context matching the path does not yet exist, it is created.
 150
 151 ``path-config-context`` looks for a configuration file named
 152 ``geda.conf``.  If ``path`` is not a directory, it is truncated, and
 153 then a file named ``geda.conf`` is looked for in that directory.  If
 154 none is found, the parent directory is checked, and so on until a
 155 configuration file is found or the filesystem root is reached.  If no
 156 configuration file was found, the returned context will be associated
 157 with a ``geda.conf`` in the same directory as ``path``.
 158
 159 .. warning:: Do not assume that the configuration file associated with
 160              the context returned by ``path-config-context`` is
 161              located in the directory specified by ``path``.
 162
 163 The configuration context returned by
 164 ``eda_config_get_context_for_path()`` is owned by the library, and
 165 should not be disposed of with ``g_object_unref()``.
 166
 167
 168 Default context
 169 ~~~~~~~~~~~~~~~
 170
 171 C function::
 172
 173   EdaConfig *eda_config_get_default_context ()
 174
 175 Scheme function::
 176
 177   default-config-context
 178
 179 The default context is not associated with any physical path or
 180 on-disk configuration file, and has no parent context.  It contains
 181 the default configuration used when no configuration file can be
 182 loaded.  Applications should normally populate the default context
 183 with their built-in default configuration settings on start-up, before
 184 loading any further configuration files.
 185
 186 The configuration context returned by
 187 ``eda_config_get_default_context()`` is owned by the library, and
 188 should not be disposed of with ``g_object_unref()``.
 189
 190 System context
 191 ~~~~~~~~~~~~~~
 192
 193 C function::
 194
 195   EdaConfig *eda_config_get_system_context ()
 196
 197 Scheme function::
 198
 199   system-config-context
 200
 201 The system context is used for system-wide configuration.  It is located:
 202
 203 1. By searching ``${XDG_CONFIG_DIRS}`` for a ``gEDA/geda-system.conf``
 204    configuration file.
 205
 206 2. By checking ``${sysconfdir}/gEDA`` for a configuration file.
 207
 208 Its parent context is the `default context`_.
 209
 210 The configuration context returned by
 211 ``eda_config_get_system_context()`` is owned by the library, and
 212 should not be disposed of with ``g_object_unref()``.
 213
 214 User context
 215 ~~~~~~~~~~~~
 216
 217 C function::
 218
 219   EdaConfig *eda_config_get_user_context ()
 220
 221 Scheme function::
 222
 223   user-config-context
 224
 225 The user context is used for user-specific configuration, and is
 226 loaded from ``${XDG_CONFIG_HOME}/gEDA/geda-user.conf`` [XDGDIRS]_.
 227 Its parent context is the `system context`_.
 228
 229 The configuration context returned by
 230 ``eda_config_get_user_context()`` is owned by the library, and should
 231 not be disposed of with ``g_object_unref()``.
 232
 233 Loading configuration files
 234 ---------------------------
 235
 236 Other than the `default context`_, all configuration contexts are
 237 associated with an on-disk configuration file.
 238
 239 C function::
 240
 241   const gchar *eda_config_get_filename (EdaConfig *cfg)
 242
 243 Scheme function::
 244
 245   config-filename cfg
 246
 247 Return the filename of the configuration file associated with the
 248 context ``cfg``.  For some contexts (including the `default
 249 context`_), this will return ``NULL`` (in C) or ``#f`` (in Scheme).
 250
 251 C function::
 252
 253   gboolean eda_config_load (EdaConfig *cfg, GError **err)
 254
 255 Scheme function::
 256
 257   load-config! cfg
 258
 259 Attempt to load configuration parameters for the context ``cfg`` from
 260 its associated file.  This function may generate a ``GIOError`` (in
 261 C) or a ``system-error`` (in Scheme).
 262
 263 C function::
 264
 265   gboolean eda_config_is_loaded (EdaConfig *cfg)
 266
 267 Scheme function::
 268
 269   config-loaded? cfg
 270
 271 Determine whether the context ``cfg`` has been successfully loaded
 272 from disk.
 273
 274 Saving configuration files
 275 --------------------------
 276
 277 C function::
 278
 279   gboolean eda_config_save (EdaConfig *cfg, GError *error)
 280
 281 Scheme function::
 282
 283   save-config! cfg
 284
 285 Attempt to save configuration parameters for the context ``cfg`` to
 286 its associated file.  This function may generate a ``GIOError`` (in
 287 C) or a ``system-error`` (in Scheme).
 288
 289 C function::
 290
 291   gboolean eda_config_is_changed (EdaConfig *cfg)
 292
 293 Scheme function::
 294
 295   config-changed? cfg
 296
 297 Determine whether the context ``cfg`` has been altered since it was
 298 last synchronised with the on-disk version by loading or saving it.
 299
 300 Context parents
 301 ---------------
 302
 303 C function::
 304
 305   EdaConfig *eda_config_get_parent (EdaConfig *cfg)
 306
 307 Scheme function::
 308
 309   config-parent cfg
 310
 311 Return the parent context of the context ``cfg``, if it has one.
 312
 313 C function::
 314
 315   void eda_config_set_parent (EdaConfig *cfg, EdaConfig *parent)
 316
 317 Scheme function::
 318
 319   set-config-parent! cfg parent
 320
 321 Sets ``parent`` as the parent context of ``cfg``.  If ``parent`` is
 322 NULL or ``#f``, sets ``cfg`` as having no parent context.
 323
 324 .. note:: Normally, application code should avoid using this function;
 325           keeping to the default configuration inheritance structure
 326           is recommended in order to ensure consistent behaviour of
 327           all libgeda applications.
 328
 329 Context trust
 330 -------------
 331
 332 Some configuration parameters are dangerous; in particular, parameters
 333 that may lead to arbitrary code execution need to be handled
 334 carefully.  Such settings might include:
 335
 336 - Preferred PDF reader
 337 - Preferred web browser
 338 - Search path for Scheme plugins
 339
 340 Configuration contexts can be flagged as being 'trusted'.  This allows
 341 code that needs to access such dangerous parameters to determine
 342 whether the value has been obtained from a safe source.
 343
 344 By default, the `default context`_, `system context`_ and `user
 345 context`_ are trusted, and all other contexts untrusted.
 346
 347 C function::
 348
 349   gboolean eda_config_is_trusted (EdaConfig *cfg)
 350
 351 Scheme function::
 352
 353   config-trusted? cfg
 354
 355 Test whether ``cfg`` is a trusted configuration context.
 356
 357 C function::
 358
 359   void eda_config_set_trusted (EdaConfig *cfg, gboolean trusted)
 360
 361 Scheme function::
 362
 363   set-config-trusted! cfg trusted
 364
 365 Set whether the configuration context ``cfg`` should be trusted as a
 366 source for dangerous configuration parameters.
 367
 368 .. warning:: You should not set a configuration context as trusted
 369              unless you are certain that it originated from a safe
 370              source (e.g. by interacting with the user to verify it).
 371
 372 C function::
 373
 374   EdaConfig *eda_config_get_trusted_context (EdaConfig *cfg)
 375
 376 Scheme function::
 377
 378   config-trusted-context cfg
 379
 380 If ``cfg`` is trusted, returns ``cfg``; otherwise, returns the first
 381 parent context of the configuration context ``cfg`` that is a trusted
 382 context.  If no trusted context could be found, returns NULL or
 383 ``#f``.
 384
 385 Configuration Parameters
 386 ========================
 387
 388 A gEDA/gaf *configuration parameter* consists of three components:
 389
 390 Group
 391   A UTF-8 string which identifies the general category in which the
 392   parameter lies (e.g. which application).
 393
 394 Name
 395   A UTF-8 string which specifically identifies the parameter within
 396   the group.
 397
 398 Value
 399   The value of the parameter.  This is stored as a UTF-8 string, but
 400   can be converted to a number of possible scalar and list types.
 401
 402 Groups, names and values are all case-sensitive.
 403
 404 Groups
 405 ------
 406
 407 C function::
 408
 409   gchar **eda_config_get_groups (EdaConfig *cfg, gsize *length)
 410
 411 Scheme function::
 412
 413   config-groups cfg
 414
 415 Returns a list of all groups available in ``cfg`` and its parent
 416 contexts.  The value returned by ``eda_config_get_groups()`` is a
 417 newly-allocated NULL-terminated array of strings.  Use
 418 ``g_strfreev()`` to free it [GLIB_].  The ``length`` argument is an
 419 optional return location for the number of groups returned.
 420
 421 C function::
 422
 423   gboolean eda_config_has_group (EdaConfig *cfg, const gchar *group)
 424
 425 Scheme function::
 426
 427   config-has-group? cfg group
 428
 429 Test whether ``cfg`` or its parent contexts contain the specified
 430 ``group``.
 431
 432 Keys
 433 ----
 434
 435 C function::
 436
 437   gchar **eda_config_get_keys (EdaConfig *cfg, const gchar *group,
 438                                gsize *length, GError **error)
 439
 440 Scheme function::
 441
 442   config-keys cfg group
 443
 444 Returns a list of all keys available in the specified ``group`` in
 445 ``cfg`` and its parent contexts.  The value returned by
 446 ``eda_config_get_keys()`` is a newly-allocated NULL-terminated array
 447 of strings.  Use ``g_strfreev()`` to free it [GLIB_].  The ``length``
 448 argument is an optional return location for the number of keys
 449 returned.  If neither ``cfg`` nor any of its parent contexts contain
 450 ``group``, raises an ``EdaConfigError`` (in C) or a ``config-error``
 451 (in Scheme).
 452
 453 C function::
 454
 455   gboolean eda_config_has_key (EdaConfig *cfg, const gchar *group,
 456                                const gchar *key, GError **err)
 457
 458 Scheme function::
 459
 460   config-has-key? cfg group key
 461
 462 Test whether ``cfg`` or its parent contexts contains ``key`` in the
 463 specified ``group``.
 464
 465 Configuration inheritance
 466 -------------------------
 467
 468 C function::
 469
 470   gboolean eda_config_is_inherited (EdaConfig *cfg, const gchar *group,
 471                                     const gchar *key, GError **err)
 472
 473 Scheme function::
 474
 475   config-inherited? cfg group key
 476
 477 Tests whether the value of the configuration parameter with the given
 478 ``group`` and ``key`` is specified in the context ``cfg``, or whether
 479 it is inherited from a parent context of ``cfg``.
 480
 481 C function::
 482
 483   EdaConfig *eda_config_get_source (EdaConfig *cfg, const gchar *group,
 484                                     const gchar *key, GError **err)
 485
 486 Scheme function::
 487
 488   config-source group key
 489
 490 Returns the configuration context (either ``cfg`` or one of its parent
 491 contexts) in which the configuration parameter with the given
 492 ``group`` and ``key`` has a value specified.
 493
 494
 495 Values
 496 ------
 497
 498 Each value is stored as a UTF-8 string in the configuration file.
 499 However, this string can be parsed as several different types.  All of
 500 the following types are supported:
 501
 502 - UTF-8 strings
 503 - Booleans
 504 - Integers
 505 - Double-precision floating point numbers
 506
 507 In addition, lists of all of the above are supported.
 508
 509 Getting configuration values
 510 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 511
 512 In general, errors in obtaining a value using the C functions should
 513 be checked for using a GError.  The list functions take a return
 514 location for the ``length`` of list (for
 515 ``eda_config_get_string_list()`` this argument may be NULL, since the
 516 returned array is NULL-terminated).  Returned strings should be freed
 517 using ``g_free()``, and returned lists should be freed using
 518 ``g_free()`` or ``g_strfreev()`` as appropriate [GLIB]_.
 519
 520 C functions::
 521
 522   gchar *eda_config_get_string (EdaConfig *cfg, const gchar *group, const gchar *key,
 523                                 GError **err)
 524
 525   gboolean eda_config_get_boolean (EdaConfig *cfg, const gchar *group, const gchar *key,
 526                                    GError **err)
 527
 528   gint eda_config_get_int (EdaConfig *cfg, const gchar *group, const gchar *key,
 529                            GError **err)
 530
 531   gdouble eda_config_get_double (EdaConfig *cfg, const gchar *group, const gchar *key,
 532                                  GError **err)
 533
 534   gchar **eda_config_get_string_list (EdaConfig *cfg, const gchar *group, const gchar *key,
 535                                       gsize *length, GError **err)
 536
 537   gboolean *eda_config_get_boolean_list (EdaConfig *cfg, const gchar *group, const gchar *key,
 538                                          gsize *length, GError **err)
 539
 540   gint *eda_config_get_int_list (EdaConfig *cfg, const gchar *group, const gchar *key,
 541                                  gsize *length, GError **err)
 542
 543   gdouble *eda_config_get_double_list (EdaConfig *cfg, const gchar *group, const gchar *key,
 544                                        gsize *length, GError **err)
 545
 546 Scheme functions::
 547
 548   config-string cfg group key [default]
 549   config-boolean cfg group key [default]
 550   config-int cfg group key [default]
 551   config-real cfg group key [default]
 552   config-string-list cfg group key [default]
 553   config-boolean-list cfg group key [default]
 554   config-int-list cfg group key [default]
 555   config-real-list cfg group key [default]
 556
 557 If a ``default`` argument is specified, it is returned in lieu of
 558 raising a ``config-error`` exception if an error occurs.
 559
 560 All values returned by ``config-real`` and ``config-real-list`` are
 561 real and inexact [GUILE]_, even if the on-disk representation would
 562 permit an exact representation.
 563
 564 Setting configuration values
 565 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 566
 567 C functions::
 568
 569   void eda_config_set_string (EdaConfig *cfg, const gchar *group, const gchar *key,
 570                               const gchar *value)
 571
 572   void eda_config_set_boolean (EdaConfig *cfg, const gchar *group, const gchar *key,
 573                                gboolean value)
 574
 575   void eda_config_set_int (EdaConfig *cfg, const gchar *group, const gchar *key,
 576                            gint value)
 577
 578   void eda_config_set_double (EdaConfig *cfg, const gchar *group, const gchar *key,
 579                               gdouble value)
 580
 581   void eda_config_set_string_list (EdaConfig *cfg, const char *group, const gchar *key,
 582                                    const gchar * const list[], gsize length)
 583
 584   void eda_config_set_boolean_list (EdaConfig *cfg, const gchar *group, const gchar *key,
 585                                     gboolean list[], gsize length)
 586
 587   void eda_config_set_int_list (EdaConfig *cfg, const gchar *group, const gchar *key,
 588                                 gint list[], gsize length)
 589
 590   void eda_config_set_double_list (EdaConfig *cfg, const gchar *group, const gchar *key,
 591                                    gdouble list[], gsize length)
 592
 593 Scheme functions::
 594
 595   set-config! cfg group key value
 596
 597 The ``config-set!`` function infers the necessary type from the type
 598 of its ``value`` argument.
 599
 600 Configuration Events
 601 ====================
 602
 603 When the value of a configuration parameter is altered, either by
 604 loading a file or directly via the API, a *configuration event* is
 605 generated.  Handlers can be registered to be notified when a
 606 configuration event occurs.  Handlers can match on:
 607
 608 - A particular group and key;
 609
 610 - A particular group;
 611
 612 - or on all parameters.
 613
 614 The events are also emitted as a GObject "config-changed" signal.
 615
 616 Event propagation
 617 -----------------
 618
 619 Recall that configuration value look-ups "flow" from configuration
 620 contexts to their parent contexts, i.e. up the configuration tree.  In
 621 a similar manner, configuration events flow *down* the configuration
 622 tree, from the context where the parameter was altered to any child
 623 contexts which inherit that parameter's value.
 624
 625 For example, consider a context ``parent`` which has child contexts
 626 ``child1`` and ``child2``.  In ``parent``, the parameter ``foo`` has
 627 value ``bar``; in ``child1``, its value is ``baz``; and in ``child2``,
 628 it is not set.
 629
 630 ::
 631
 632                    parent  [foo=bar]
 633                      |
 634                     / \
 635    [foo=baz]  child1   child2  [foo not set]
 636
 637 If the ``foo`` parameter is altered in ``parent``, then the resulting
 638 event will be dispatched in ``parent`` and ``child2``.
 639
 640 Handlers
 641 --------
 642
 643 In C, configuration event handlers must have the
 644 ``EdaConfigEventHandlerFunc`` prototype::
 645
 646   void handler (EdaConfig *cfg, const gchar *group, const gchar *key, gpointer user_data)
 647
 648 In Scheme, a configuration event handler must be a closure that
 649 accepts three arguments::
 650
 651   handler cfg group key
 652
 653 ``cfg`` is always the configuration context that received the event,
 654 and the ``group`` and ``key`` identify the configuration parameter
 655 that was changed.  The ``user_data`` argument to the C handler is a
 656 data structure provided by the API user at the time when the handler
 657 was registered.
 658
 659 Adding and removing handlers is quite straightforward:
 660
 661 C function::
 662
 663   void eda_config_event_add (EdaConfig *cfg, const gchar *group, const gchar *key, EdaConfigEventHandlerFunc func, gpointer user_data)
 664
 665 Scheme function::
 666
 667   add-config-event! cfg func [group [key]]
 668
 669 Registers ``func`` to be called when the configuration parameter
 670 identified by ``group`` and ``key`` is modified in the context
 671 ``cfg``.  If ``key`` is not specified (or NULL), matches on any
 672 parameter in ``group``.  If group is not specified (or NULL), matches
 673 on any parameter.  If an identical event handler was already
 674 registered, does nothing.
 675
 676 C function::
 677
 678   void eda_config_event_remove (EdaConfig *cfg, const gchar *group, const gchar *key, EdaConfigEventHandlerFunc func, gpointer user_data)
 679
 680 Scheme function::
 681
 682   remove-config-event! cfg func [group [key]]
 683
 684 Unregisters the event handler ``func`` from the context ``cfg``.  The
 685 ``group``, ``key``, and (in C) ``user_data`` parameters must match
 686 those specified when the event handler was registered.  If no matching
 687 event handler was registered, does nothing.
 688
 689 C function::
 690
 691   void eda_config_event_remove_all (EdaConfig *cfg, EdaConfigEventHandlerFunc func, gpointer user_data)
 692
 693 Scheme function::
 694
 695   remove-config-event! cfg func #t
 696
 697 Unregisters all occurrences of the event handler ``func`` from the
 698 context ``cfg``, no matter what events ``func`` was set to trigger on.
 699 In C, the ``user_data`` parameter must match that specified when the
 700 event handler was registered.
 701
 702
 703 Delaying events
 704 ---------------
 705
 706 It is sometimes desirable to delay configuration event notifications.
 707 For example, this might be necessary if you are planning to change a
 708 large number of configuration values at the same time.
 709
 710 C functions::
 711
 712   void eda_config_event_freeze (EdaConfig *cfg)
 713   void eda_config_event_thaw (EdaConfig *cfg)
 714
 715 When ``eda_config_event_freeze()`` is called on it, the context
 716 ``cfg`` stops dispatching event notifications.  Whenever an event
 717 notification would normally be dispatched, it instead is added to an
 718 internal queue.  When ``eda_config_event_thaw()`` is called, any
 719 queued events are dispatched.  Multiple pairs of
 720 ``eda_config_event_freeze()`` and ``eda_config_event_thaw()`` calls
 721 can be nested.
 722
 723 Scheme function::
 724
 725   delay-config-events cfg thunk
 726
 727 Call ``thunk``, delaying configuration event notifications until
 728 ``thunk`` exits, either normally or non-locally.
 729
 730
 731 References
 732 ==========
 733
 734 .. [GLIB]    The GNOME Project, "GLib Reference Manual".
 735              <http://library.gnome.org/devel/glib/stable/>
 736
 737 .. [GOBJECT] The GNOME Project, "GObject Reference Manual".
 738              <http://library.gnome.org/devel/glib/stable/>
 739
 740 .. [GUILE]   Free Software Foundation, "GNU Guile Reference Manual", Version
 741              1.8.
 742              <http://www.gnu.org/software/guile/manual/>
 743
 744 .. [XDGDIRS] W. Bastian, R. Lortie and L. Poettering, "XDG Base
 745              Directory Specification", Version 0.7.
 746              <http://www.freedesktop.org/wiki/Standards/basedir-spec>
 747
 748 ..
 749    Local Variables:
 750    mode: rst
 751    End: