libguile/hashtab.c

   1 /* Copyright (C) 1995,1996,1998,1999,2000,2001 Free Software Foundation, Inc.
   2  *
   3  * This program is free software; you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License as published by
   5  * the Free Software Foundation; either version 2, or (at your option)
   6  * any later version.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this software; see the file COPYING.  If not, write to
  15  * the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
  16  * Boston, MA 02111-1307 USA
  17  *
  18  * As a special exception, the Free Software Foundation gives permission
  19  * for additional uses of the text contained in its release of GUILE.
  20  *
  21  * The exception is that, if you link the GUILE library with other files
  22  * to produce an executable, this does not by itself cause the
  23  * resulting executable to be covered by the GNU General Public License.
  24  * Your use of that executable is in no way restricted on account of
  25  * linking the GUILE library code into it.
  26  *
  27  * This exception does not however invalidate any other reasons why
  28  * the executable file might be covered by the GNU General Public License.
  29  *
  30  * This exception applies only to the code released by the
  31  * Free Software Foundation under the name GUILE.  If you copy
  32  * code from other Free Software Foundation releases into a copy of
  33  * GUILE, as the General Public License permits, the exception does
  34  * not apply to the code that you add in this way.  To avoid misleading
  35  * anyone as to the status of such modified files, you must delete
  36  * this exception notice from them.
  37  *
  38  * If you write modifications of your own for GUILE, it is your choice
  39  * whether to permit this exception to apply to your modifications.
  40  * If you do not wish that, delete this exception notice.  */
  41
  42
  43 \f
  44
  45 #include "libguile/_scm.h"
  46 #include "libguile/alist.h"
  47 #include "libguile/hash.h"
  48 #include "libguile/eval.h"
  49 #include "libguile/root.h"
  50 #include "libguile/vectors.h"
  51
  52 #include "libguile/validate.h"
  53 #include "libguile/hashtab.h"
  54 \f
  55
  56 SCM
  57 scm_c_make_hash_table (unsigned long k)
  58 {
  59   return scm_c_make_vector (k, SCM_EOL);
  60 }
  61
  62
  63 SCM
  64 scm_hash_fn_get_handle (SCM table,SCM obj,unsigned long (*hash_fn)(),SCM (*assoc_fn)(),void * closure)
  65 #define FUNC_NAME "scm_hash_fn_get_handle"
  66 {
  67   unsigned long k;
  68   SCM h;
  69
  70   SCM_VALIDATE_VECTOR (1, table);
  71   if (SCM_VECTOR_LENGTH (table) == 0)
  72     return SCM_BOOL_F;
  73   k = hash_fn (obj, SCM_VECTOR_LENGTH (table), closure);
  74   if (k >= SCM_VECTOR_LENGTH (table))
  75     scm_out_of_range ("hash_fn_get_handle", scm_ulong2num (k));
  76   h = assoc_fn (obj, SCM_VELTS (table)[k], closure);
  77   return h;
  78 }
  79 #undef FUNC_NAME
  80
  81
  82 SCM
  83 scm_hash_fn_create_handle_x (SCM table,SCM obj,SCM init,unsigned long (*hash_fn)(),
  84                              SCM (*assoc_fn)(),void * closure)
  85 #define FUNC_NAME "scm_hash_fn_create_handle_x"
  86 {
  87   unsigned long k;
  88   SCM it;
  89
  90   SCM_ASSERT (SCM_VECTORP (table), table, SCM_ARG1, "hash_fn_create_handle_x");
  91   if (SCM_VECTOR_LENGTH (table) == 0)
  92     SCM_MISC_ERROR ("void hashtable", SCM_EOL);
  93
  94   k = hash_fn (obj, SCM_VECTOR_LENGTH (table), closure);
  95   if (k >= SCM_VECTOR_LENGTH (table))
  96     scm_out_of_range ("hash_fn_create_handle_x", scm_ulong2num (k));
  97   SCM_REDEFER_INTS;
  98   it = assoc_fn (obj, SCM_VELTS (table)[k], closure);
  99   if (!SCM_FALSEP (it))
 100     {
 101       SCM_REALLOW_INTS;
 102       return it;
 103     }
 104   else
 105     {
 106       SCM new_bucket;
 107       SCM old_bucket;
 108       old_bucket = SCM_VELTS (table)[k];
 109       new_bucket = scm_acons (obj, init, old_bucket);
 110       SCM_VELTS(table)[k] = new_bucket;
 111       SCM_REALLOW_INTS;
 112       return SCM_CAR (new_bucket);
 113     }
 114 }
 115 #undef FUNC_NAME
 116
 117
 118 SCM
 119 scm_hash_fn_ref (SCM table,SCM obj,SCM dflt,unsigned long (*hash_fn)(),
 120                  SCM (*assoc_fn)(),void * closure)
 121 {
 122   SCM it = scm_hash_fn_get_handle (table, obj, hash_fn, assoc_fn, closure);
 123   if (SCM_CONSP (it))
 124     return SCM_CDR (it);
 125   else
 126     return dflt;
 127 }
 128
 129
 130
 131
 132 SCM
 133 scm_hash_fn_set_x (SCM table,SCM obj,SCM val,unsigned long (*hash_fn)(),
 134                    SCM (*assoc_fn)(),void * closure)
 135 {
 136   SCM it;
 137
 138   it = scm_hash_fn_create_handle_x (table, obj, SCM_BOOL_F, hash_fn, assoc_fn, closure);
 139   SCM_SETCDR (it, val);
 140   return val;
 141 }
 142
 143
 144
 145
 146
 147 SCM
 148 scm_hash_fn_remove_x (SCM table,SCM obj,unsigned long (*hash_fn)(),SCM (*assoc_fn)(),
 149                       SCM (*delete_fn)(),void * closure)
 150 {
 151   unsigned long k;
 152   SCM h;
 153
 154   SCM_ASSERT (SCM_VECTORP (table), table, SCM_ARG1, "hash_fn_remove_x");
 155   if (SCM_VECTOR_LENGTH (table) == 0)
 156     return SCM_EOL;
 157   k = hash_fn (obj, SCM_VECTOR_LENGTH (table), closure);
 158   if (k >= SCM_VECTOR_LENGTH (table))
 159     scm_out_of_range ("hash_fn_remove_x", scm_ulong2num (k));
 160   h = assoc_fn (obj, SCM_VELTS (table)[k], closure);
 161   SCM_VELTS(table)[k] = delete_fn (h, SCM_VELTS(table)[k]);
 162   return h;
 163 }
 164
 165
 166 \f
 167
 168 SCM_DEFINE (scm_hashq_get_handle, "hashq-get-handle", 2, 0, 0,
 169             (SCM table, SCM key),
 170             "This procedure returns the @code{(key . value)} pair from the\n"
 171             "hash table @var{table}.  If @var{table} does not hold an\n"
 172             "associated value for @var{key}, @code{#f} is returned.\n"
 173             "Uses @code{eq?} for equality testing.")
 174 #define FUNC_NAME s_scm_hashq_get_handle
 175 {
 176   return scm_hash_fn_get_handle (table, key, scm_ihashq, scm_sloppy_assq, 0);
 177 }
 178 #undef FUNC_NAME
 179
 180
 181 SCM_DEFINE (scm_hashq_create_handle_x, "hashq-create-handle!", 3, 0, 0,
 182             (SCM table, SCM key, SCM init),
 183             "This function looks up @var{key} in @var{table} and returns its handle.\n"
 184             "If @var{key} is not already present, a new handle is created which\n"
 185             "associates @var{key} with @var{init}.")
 186 #define FUNC_NAME s_scm_hashq_create_handle_x
 187 {
 188   return scm_hash_fn_create_handle_x (table, key, init, scm_ihashq, scm_sloppy_assq, 0);
 189 }
 190 #undef FUNC_NAME
 191
 192
 193 SCM_DEFINE (scm_hashq_ref, "hashq-ref", 2, 1, 0,
 194             (SCM table, SCM key, SCM dflt),
 195             "Look up @var{key} in the hash table @var{table}, and return the\n"
 196             "value (if any) associated with it.  If @var{key} is not found,\n"
 197             "return @var{default} (or @code{#f} if no @var{default} argument\n"
 198             "is supplied).  Uses @code{eq?} for equality testing.")
 199 #define FUNC_NAME s_scm_hashq_ref
 200 {
 201   if (SCM_UNBNDP (dflt))
 202     dflt = SCM_BOOL_F;
 203   return scm_hash_fn_ref (table, key, dflt, scm_ihashq, scm_sloppy_assq, 0);
 204 }
 205 #undef FUNC_NAME
 206
 207
 208
 209 SCM_DEFINE (scm_hashq_set_x, "hashq-set!", 3, 0, 0,
 210             (SCM table, SCM key, SCM val),
 211             "Find the entry in @var{table} associated with @var{key}, and\n"
 212             "store @var{value} there. Uses @code{eq?} for equality testing.")
 213 #define FUNC_NAME s_scm_hashq_set_x
 214 {
 215   return scm_hash_fn_set_x (table, key, val, scm_ihashq, scm_sloppy_assq, 0);
 216 }
 217 #undef FUNC_NAME
 218
 219
 220
 221 SCM_DEFINE (scm_hashq_remove_x, "hashq-remove!", 2, 0, 0,
 222             (SCM table, SCM key),
 223             "Remove @var{key} (and any value associated with it) from\n"
 224             "@var{table}.  Uses @code{eq?} for equality tests.")
 225 #define FUNC_NAME s_scm_hashq_remove_x
 226 {
 227   return scm_hash_fn_remove_x (table, key, scm_ihashq, scm_sloppy_assq,
 228                                scm_delq_x, 0);
 229 }
 230 #undef FUNC_NAME
 231
 232
 233 \f
 234
 235 SCM_DEFINE (scm_hashv_get_handle, "hashv-get-handle", 2, 0, 0,
 236             (SCM table, SCM key),
 237             "This procedure returns the @code{(key . value)} pair from the\n"
 238             "hash table @var{table}.  If @var{table} does not hold an\n"
 239             "associated value for @var{key}, @code{#f} is returned.\n"
 240             "Uses @code{eqv?} for equality testing.")
 241 #define FUNC_NAME s_scm_hashv_get_handle
 242 {
 243   return scm_hash_fn_get_handle (table, key, scm_ihashv, scm_sloppy_assv, 0);
 244 }
 245 #undef FUNC_NAME
 246
 247
 248 SCM_DEFINE (scm_hashv_create_handle_x, "hashv-create-handle!", 3, 0, 0,
 249             (SCM table, SCM key, SCM init),
 250             "This function looks up @var{key} in @var{table} and returns its handle.\n"
 251             "If @var{key} is not already present, a new handle is created which\n"
 252             "associates @var{key} with @var{init}.")
 253 #define FUNC_NAME s_scm_hashv_create_handle_x
 254 {
 255   return scm_hash_fn_create_handle_x (table, key, init, scm_ihashv,
 256                                       scm_sloppy_assv, 0);
 257 }
 258 #undef FUNC_NAME
 259
 260
 261 SCM_DEFINE (scm_hashv_ref, "hashv-ref", 2, 1, 0,
 262             (SCM table, SCM key, SCM dflt),
 263             "Look up @var{key} in the hash table @var{table}, and return the\n"
 264             "value (if any) associated with it.  If @var{key} is not found,\n"
 265             "return @var{default} (or @code{#f} if no @var{default} argument\n"
 266             "is supplied).  Uses @code{eqv?} for equality testing.")
 267 #define FUNC_NAME s_scm_hashv_ref
 268 {
 269   if (SCM_UNBNDP (dflt))
 270     dflt = SCM_BOOL_F;
 271   return scm_hash_fn_ref (table, key, dflt, scm_ihashv, scm_sloppy_assv, 0);
 272 }
 273 #undef FUNC_NAME
 274
 275
 276
 277 SCM_DEFINE (scm_hashv_set_x, "hashv-set!", 3, 0, 0,
 278             (SCM table, SCM key, SCM val),
 279             "Find the entry in @var{table} associated with @var{key}, and\n"
 280             "store @var{value} there. Uses @code{eqv?} for equality testing.")
 281 #define FUNC_NAME s_scm_hashv_set_x
 282 {
 283   return scm_hash_fn_set_x (table, key, val, scm_ihashv, scm_sloppy_assv, 0);
 284 }
 285 #undef FUNC_NAME
 286
 287
 288 SCM_DEFINE (scm_hashv_remove_x, "hashv-remove!", 2, 0, 0,
 289             (SCM table, SCM key),
 290             "Remove @var{key} (and any value associated with it) from\n"
 291             "@var{table}.  Uses @code{eqv?} for equality tests.")
 292 #define FUNC_NAME s_scm_hashv_remove_x
 293 {
 294   return scm_hash_fn_remove_x (table, key, scm_ihashv, scm_sloppy_assv,
 295                                scm_delv_x, 0);
 296 }
 297 #undef FUNC_NAME
 298
 299 \f
 300
 301 SCM_DEFINE (scm_hash_get_handle, "hash-get-handle", 2, 0, 0,
 302             (SCM table, SCM key),
 303             "This procedure returns the @code{(key . value)} pair from the\n"
 304             "hash table @var{table}.  If @var{table} does not hold an\n"
 305             "associated value for @var{key}, @code{#f} is returned.\n"
 306             "Uses @code{equal?} for equality testing.")
 307 #define FUNC_NAME s_scm_hash_get_handle
 308 {
 309   return scm_hash_fn_get_handle (table, key, scm_ihash, scm_sloppy_assoc, 0);
 310 }
 311 #undef FUNC_NAME
 312
 313
 314 SCM_DEFINE (scm_hash_create_handle_x, "hash-create-handle!", 3, 0, 0,
 315             (SCM table, SCM key, SCM init),
 316             "This function looks up @var{key} in @var{table} and returns its handle.\n"
 317             "If @var{key} is not already present, a new handle is created which\n"
 318             "associates @var{key} with @var{init}.")
 319 #define FUNC_NAME s_scm_hash_create_handle_x
 320 {
 321   return scm_hash_fn_create_handle_x (table, key, init, scm_ihash, scm_sloppy_assoc, 0);
 322 }
 323 #undef FUNC_NAME
 324
 325
 326 SCM_DEFINE (scm_hash_ref, "hash-ref", 2, 1, 0,
 327             (SCM table, SCM key, SCM dflt),
 328             "Look up @var{key} in the hash table @var{table}, and return the\n"
 329             "value (if any) associated with it.  If @var{key} is not found,\n"
 330             "return @var{default} (or @code{#f} if no @var{default} argument\n"
 331             "is supplied).  Uses @code{equal?} for equality testing.")
 332 #define FUNC_NAME s_scm_hash_ref
 333 {
 334   if (SCM_UNBNDP (dflt))
 335     dflt = SCM_BOOL_F;
 336   return scm_hash_fn_ref (table, key, dflt, scm_ihash, scm_sloppy_assoc, 0);
 337 }
 338 #undef FUNC_NAME
 339
 340
 341
 342 SCM_DEFINE (scm_hash_set_x, "hash-set!", 3, 0, 0,
 343             (SCM table, SCM key, SCM val),
 344             "Find the entry in @var{table} associated with @var{key}, and\n"
 345             "store @var{value} there. Uses @code{equal?} for equality\n"
 346             "testing.")
 347 #define FUNC_NAME s_scm_hash_set_x
 348 {
 349   return scm_hash_fn_set_x (table, key, val, scm_ihash, scm_sloppy_assoc, 0);
 350 }
 351 #undef FUNC_NAME
 352
 353
 354
 355 SCM_DEFINE (scm_hash_remove_x, "hash-remove!", 2, 0, 0,
 356             (SCM table, SCM key),
 357             "Remove @var{key} (and any value associated with it) from\n"
 358             "@var{table}.  Uses @code{equal?} for equality tests.")
 359 #define FUNC_NAME s_scm_hash_remove_x
 360 {
 361   return scm_hash_fn_remove_x (table, key, scm_ihash, scm_sloppy_assoc,
 362                                scm_delete_x, 0);
 363 }
 364 #undef FUNC_NAME
 365
 366 \f
 367
 368
 369 typedef struct scm_t_ihashx_closure
 370 {
 371   SCM hash;
 372   SCM assoc;
 373   SCM delete;
 374 } scm_t_ihashx_closure;
 375
 376
 377
 378 static unsigned long
 379 scm_ihashx (SCM obj, unsigned long n, scm_t_ihashx_closure *closure)
 380 {
 381   SCM answer;
 382   SCM_DEFER_INTS;
 383   answer = scm_call_2 (closure->hash, obj, scm_ulong2num ((unsigned long) n));
 384   SCM_ALLOW_INTS;
 385   return SCM_INUM (answer);
 386 }
 387
 388
 389
 390 static SCM
 391 scm_sloppy_assx (SCM obj, SCM alist, scm_t_ihashx_closure *closure)
 392 {
 393   SCM answer;
 394   SCM_DEFER_INTS;
 395   answer = scm_call_2 (closure->assoc, obj, alist);
 396   SCM_ALLOW_INTS;
 397   return answer;
 398 }
 399
 400
 401
 402
 403 static SCM
 404 scm_delx_x (SCM obj, SCM alist, scm_t_ihashx_closure *closure)
 405 {
 406   SCM answer;
 407   SCM_DEFER_INTS;
 408   answer = scm_call_2 (closure->delete, obj, alist);
 409   SCM_ALLOW_INTS;
 410   return answer;
 411 }
 412
 413
 414
 415 SCM_DEFINE (scm_hashx_get_handle, "hashx-get-handle", 4, 0, 0,
 416             (SCM hash, SCM assoc, SCM table, SCM key),
 417             "This behaves the same way as the corresponding\n"
 418             "@code{-get-handle} function, but uses @var{hash} as a hash\n"
 419             "function and @var{assoc} to compare keys.  @code{hash} must be\n"
 420             "a function that takes two arguments, a key to be hashed and a\n"
 421             "table size.  @code{assoc} must be an associator function, like\n"
 422             "@code{assoc}, @code{assq} or @code{assv}.")
 423 #define FUNC_NAME s_scm_hashx_get_handle
 424 {
 425   scm_t_ihashx_closure closure;
 426   closure.hash = hash;
 427   closure.assoc = assoc;
 428   return scm_hash_fn_get_handle (table, key, scm_ihashx, scm_sloppy_assx,
 429                                  (void *)&closure);
 430 }
 431 #undef FUNC_NAME
 432
 433
 434 SCM_DEFINE (scm_hashx_create_handle_x, "hashx-create-handle!", 5, 0, 0,
 435             (SCM hash, SCM assoc, SCM table, SCM key, SCM init),
 436             "This behaves the same way as the corresponding\n"
 437             "@code{-create-handle} function, but uses @var{hash} as a hash\n"
 438             "function and @var{assoc} to compare keys.  @code{hash} must be\n"
 439             "a function that takes two arguments, a key to be hashed and a\n"
 440             "table size.  @code{assoc} must be an associator function, like\n"
 441             "@code{assoc}, @code{assq} or @code{assv}.")
 442 #define FUNC_NAME s_scm_hashx_create_handle_x
 443 {
 444   scm_t_ihashx_closure closure;
 445   closure.hash = hash;
 446   closure.assoc = assoc;
 447   return scm_hash_fn_create_handle_x (table, key, init, scm_ihashx,
 448                                       scm_sloppy_assx, (void *)&closure);
 449 }
 450 #undef FUNC_NAME
 451
 452
 453
 454 SCM_DEFINE (scm_hashx_ref, "hashx-ref", 4, 1, 0,
 455             (SCM hash, SCM assoc, SCM table, SCM key, SCM dflt),
 456             "This behaves the same way as the corresponding @code{ref}\n"
 457             "function, but uses @var{hash} as a hash function and\n"
 458             "@var{assoc} to compare keys.  @code{hash} must be a function\n"
 459             "that takes two arguments, a key to be hashed and a table size.\n"
 460             "@code{assoc} must be an associator function, like @code{assoc},\n"
 461             "@code{assq} or @code{assv}.\n"
 462             "\n"
 463             "By way of illustration, @code{hashq-ref table key} is\n"
 464             "equivalent to @code{hashx-ref hashq assq table key}.")
 465 #define FUNC_NAME s_scm_hashx_ref
 466 {
 467   scm_t_ihashx_closure closure;
 468   if (SCM_UNBNDP (dflt))
 469     dflt = SCM_BOOL_F;
 470   closure.hash = hash;
 471   closure.assoc = assoc;
 472   return scm_hash_fn_ref (table, key, dflt, scm_ihashx, scm_sloppy_assx,
 473                           (void *)&closure);
 474 }
 475 #undef FUNC_NAME
 476
 477
 478
 479
 480 SCM_DEFINE (scm_hashx_set_x, "hashx-set!", 5, 0, 0,
 481             (SCM hash, SCM assoc, SCM table, SCM key, SCM val),
 482             "This behaves the same way as the corresponding @code{set!}\n"
 483             "function, but uses @var{hash} as a hash function and\n"
 484             "@var{assoc} to compare keys.  @code{hash} must be a function\n"
 485             "that takes two arguments, a key to be hashed and a table size.\n"
 486             "@code{assoc} must be an associator function, like @code{assoc},\n"
 487             "@code{assq} or @code{assv}.\n"
 488             "\n"
 489             " By way of illustration, @code{hashq-set! table key} is\n"
 490             "equivalent to @code{hashx-set!  hashq assq table key}.")
 491 #define FUNC_NAME s_scm_hashx_set_x
 492 {
 493   scm_t_ihashx_closure closure;
 494   closure.hash = hash;
 495   closure.assoc = assoc;
 496   return scm_hash_fn_set_x (table, key, val, scm_ihashx, scm_sloppy_assx,
 497                             (void *)&closure);
 498 }
 499 #undef FUNC_NAME
 500
 501
 502
 503 SCM
 504 scm_hashx_remove_x (SCM hash, SCM assoc, SCM delete, SCM table, SCM obj)
 505 {
 506   scm_t_ihashx_closure closure;
 507   closure.hash = hash;
 508   closure.assoc = assoc;
 509   closure.delete = delete;
 510   return scm_hash_fn_remove_x (table, obj, scm_ihashx, scm_sloppy_assx, scm_delx_x, 0);
 511 }
 512
 513 static SCM
 514 fold_proc (void *proc, SCM key, SCM data, SCM value)
 515 {
 516   return scm_call_3 (SCM_PACK (proc), key, data, value);
 517 }
 518
 519 SCM_DEFINE (scm_hash_fold, "hash-fold", 3, 0, 0,
 520             (SCM proc, SCM init, SCM table),
 521             "An iterator over hash-table elements.\n"
 522             "Accumulates and returns a result by applying PROC successively.\n"
 523             "The arguments to PROC are \"(key value prior-result)\" where key\n"
 524             "and value are successive pairs from the hash table TABLE, and\n"
 525             "prior-result is either INIT (for the first application of PROC)\n"
 526             "or the return value of the previous application of PROC.\n"
 527             "For example, @code{(hash-fold acons '() tab)} will convert a hash\n"
 528             "table into an a-list of key-value pairs.")
 529 #define FUNC_NAME s_scm_hash_fold
 530 {
 531   SCM_VALIDATE_PROC (1,proc);
 532   SCM_VALIDATE_VECTOR (3,table);
 533   return scm_internal_hash_fold (fold_proc, (void *) SCM_UNPACK (proc), init, table);
 534 }
 535 #undef FUNC_NAME
 536
 537 SCM
 538 scm_internal_hash_fold (SCM (*fn) (), void *closure, SCM init, SCM table)
 539 {
 540   long i, n = SCM_VECTOR_LENGTH (table);
 541   SCM result = init;
 542   for (i = 0; i < n; ++i)
 543     {
 544       SCM ls = SCM_VELTS (table)[i], handle;
 545       while (!SCM_NULLP (ls))
 546         {
 547           SCM_ASSERT (SCM_CONSP (ls),
 548                       table, SCM_ARG3, s_scm_hash_fold);
 549           handle = SCM_CAR (ls);
 550           SCM_ASSERT (SCM_CONSP (handle),
 551                       table, SCM_ARG3, s_scm_hash_fold);
 552           result = fn (closure, SCM_CAR (handle), SCM_CDR (handle), result);
 553           ls = SCM_CDR (ls);
 554         }
 555     }
 556   return result;
 557 }
 558
 559 \f
 560
 561
 562 void
 563 scm_init_hashtab ()
 564 {
 565 #ifndef SCM_MAGIC_SNARFER
 566 #include "libguile/hashtab.x"
 567 #endif
 568 }
 569
 570 /*
 571   Local Variables:
 572   c-file-style: "gnu"
 573   End:
 574 */