ruletagger 0.0.1

data/ext/rule_tagger/rbtagger.c

@@ -0,0 +1,252 @@
+/** 
+ * Copyright (c) 2008 Todd A. Fisher
+ * see LICENSE
+ */
+#include "ruby.h"
+#include "tagger.h"
+#include "ruby-compat.h"
+
+static VALUE rb_Tagger;
+static VALUE rb_BrillTagger;
+
+static
+VALUE BrillTagger_alloc(VALUE klass)
+{
+  VALUE object;
+  TaggerContext *tc = tagger_context_new();
+  object = Data_Wrap_Struct( klass, NULL, tagger_context_free, tc );
+  return object;
+}
+
+static VALUE
+BrillTagger_add_to_lexicon( VALUE self, VALUE word, VALUE tag )
+{
+  TaggerContext *tc;
+  Data_Get_Struct( self, TaggerContext, tc );
+  tagger_context_add_to_lexicon( tc, RSTRING_PTR(word), RSTRING_PTR(tag) );
+  return Qnil;
+}
+static VALUE
+BrillTagger_add_to_lexicon_tags( VALUE self, VALUE bigram )
+{
+  TaggerContext *tc;
+  Data_Get_Struct( self, TaggerContext, tc );
+  tagger_context_add_to_lexicon_tags( tc, RSTRING_PTR(bigram) );
+  return Qnil;
+}
+static VALUE
+BrillTagger_add_contextual_rule( VALUE self, VALUE rule )
+{
+  TaggerContext *tc;
+  Data_Get_Struct( self, TaggerContext, tc );
+  tagger_context_add_contextual_rule( tc, RSTRING_PTR(rule) );
+  return Qnil;
+}
+static VALUE
+BrillTagger_add_lexical_rule( VALUE self, VALUE rule )
+{
+  TaggerContext *tc;
+  Data_Get_Struct( self, TaggerContext, tc );
+  tagger_context_add_lexical_rule( tc, RSTRING_PTR(rule) );
+  return Qnil;
+}
+static VALUE
+BrillTagger_add_word_to_wordlist( VALUE self, VALUE word )
+{
+  TaggerContext *tc;
+  Data_Get_Struct( self, TaggerContext, tc );
+  tagger_context_add_word_to_wordlist( tc, RSTRING_PTR(word) );
+  return Qnil;
+}
+
+static VALUE
+BrillTagger_add_goodleft( VALUE self, VALUE word )
+{
+  TaggerContext *tc;
+  Data_Get_Struct( self, TaggerContext, tc );
+  tagger_context_add_goodleft( tc, RSTRING_PTR(word) );
+  return Qnil;
+}
+
+static VALUE
+BrillTagger_add_goodright( VALUE self, VALUE word )
+{
+  TaggerContext *tc;
+  Data_Get_Struct( self, TaggerContext, tc );
+  tagger_context_add_goodright( tc, RSTRING_PTR(word) );
+  return Qnil;
+}
+
+static VALUE
+BrillTagger_apply_lexical_rules( VALUE self, VALUE tokens, VALUE tags, VALUE wordlist, VALUE extrawds )
+{
+  TaggerContext *tc;
+  int i = 0;
+  int token_length = RARRAY(tokens)->len;
+  int tags_length = RARRAY(tags)->len;
+  int rules_length;
+  VALUE fetched;
+  int EXTRAWDS = NUM2INT( extrawds );
+  Data_Get_Struct( self, TaggerContext, tc );
+
+  if( token_length != tags_length ){
+    rb_raise(rb_eArgError, "Error: tags and tokens must be of equal length!");
+    return Qnil;
+  }
+      
+  Darray text_array = Darray_create();
+  Darray tag_array  = Darray_create();
+
+  Darray_hint( text_array, token_length, token_length );
+  Darray_hint( tag_array, token_length, token_length );
+
+  for( i = 0; i < token_length; ++i ){
+    fetched = rb_ary_entry(tokens,i);
+    if( fetched == Qnil ){
+      fprintf(stderr, "token missing %d of %d\n", i, token_length );
+      rb_raise(rb_eArgError, "Token was missing unexpectedly");
+      return Qnil;
+    }
+    Darray_addh(text_array, (VOIDP)strdup(RSTRING_PTR(fetched)) );
+    fetched = rb_ary_entry(tags,i);
+    if( fetched == Qnil ){
+      fprintf(stderr, "tag missing %d of %d\n", i, token_length );
+      rb_raise(rb_eArgError, "Tag was missing unexpectedly");
+      return Qnil;
+    }
+    Darray_addh(tag_array, (VOIDP)strdup(RSTRING_PTR(fetched)) );
+  }
+  rules_length = Darray_len(tc->rule_array);
+  /* Apply the rules */
+  for( i = 0; i < rules_length; ++i ) {
+    apply_lexical_rule( Darray_get(tc->rule_array, i),
+                        text_array, tag_array,
+                        tc->lexicon_hash,
+                        tc->wordlist_hash,
+                        tc->bigram_hash,
+                        EXTRAWDS );
+  }
+  /* Stuff the results back into the ruby arrays */
+  for( i = 0; i < token_length; ++i ) {
+    char *text_strref = (char*)Darray_get( text_array, i );
+    char *tag_strref = (char*)Darray_get( tag_array, i );
+
+    // copy into ruby space
+    rb_ary_store( tokens, i, rb_str_new2(text_strref) );
+    rb_ary_store( tags, i, rb_str_new2( tag_strref ) );
+
+    free( text_strref );
+    free( tag_strref );
+  }
+
+  Darray_destroy(text_array);
+  Darray_destroy(tag_array);
+
+  return Qnil;
+}
+static VALUE
+BrillTagger_default_tag_finish( VALUE self, VALUE tokens, VALUE tags )
+{
+  int i;
+  VALUE fetched, word;
+  char *tempstr;
+  int token_length = RARRAY(tokens)->len;
+  int tags_length = RARRAY(tags)->len;
+  TaggerContext *tc;
+
+  Data_Get_Struct( self, TaggerContext, tc );
+
+  if( token_length != tags_length ){
+    rb_raise(rb_eArgError, "Error: tags and tokens must be of equal length!");
+    return Qnil;
+  }
+
+  for( i = 0; i < token_length; ++i ){
+    fetched = rb_ary_entry(tokens,i);
+    if( fetched == Qnil ){
+      rb_raise(rb_eArgError, "Token was missing unexpectedly");
+      return Qnil;
+    }
+    word = fetched;
+
+    if( (tempstr = Registry_get(tc->lexicon_hash, RSTRING_PTR(word))) != NULL ){
+      //fetched = rb_ary_entry(tags,i);
+      //printf( "'%s'/%s -> %s\n", RSTRING_PTR(word), RSTRING_PTR(fetched), tempstr );
+      rb_ary_store( tags, i, rb_str_new2(tempstr) );
+    }
+  }
+  return Qnil;
+}
+
+static VALUE
+BrillTagger_apply_contextual_rules( VALUE self, VALUE tokens, VALUE tags, VALUE rmove )
+{
+  int i;
+  int token_length = RARRAY(tokens)->len;
+  int tags_length = RARRAY(tags)->len;
+  int rules_length;
+  int restrict_move = NUM2INT( rmove );
+  char **text_tags, **text_tokens;
+  VALUE fetched;
+  TaggerContext *tc;
+  Data_Get_Struct( self, TaggerContext, tc );
+
+  if( token_length != tags_length ){
+    rb_raise(rb_eArgError, "Error: tags and tokens must be of equal length!");
+    return Qnil;
+  }
+  if( restrict_move && Registry_entry_count( tc->lexicon_hash ) == 0 ){
+    rb_raise(rb_eArgError, "Must load a leicon before applying contextual rules");
+    return Qnil;
+  }
+
+  text_tags = (char**)malloc(sizeof(char*) * tags_length );
+  text_tokens = (char**)malloc(sizeof(char*) * token_length );
+
+  // load the tokens and tags into the char * arrays
+  for( i = 0; i < token_length; ++i ){
+    fetched = rb_ary_entry(tokens,i);
+    text_tokens[i] = strdup(RSTRING_PTR(fetched));
+    fetched = rb_ary_entry(tags,i);
+    text_tags[i] = strdup(RSTRING_PTR(fetched));
+  }
+
+  rules_length = Darray_len(tc->contextual_rule_array);
+  // Apply the rules
+  for( i = 0; i < rules_length; ++i ){
+    apply_contextual_rule(Darray_get(tc->contextual_rule_array, i),
+                          text_tokens, text_tags, token_length,
+                          restrict_move, tc->lexicon_hash, tc->lexicon_tag_hash);
+  }
+
+  // load the results back into ruby arrays
+  for( i = 0; i < token_length; ++i ){
+    rb_ary_store( tags, i, rb_str_new2(text_tags[i]) );
+    free(text_tags[i]);
+    free(text_tokens[i]);
+  }
+
+  free( text_tags );
+  free( text_tokens );
+
+  return Qnil;
+}
+
+void Init_rule_tagger()
+{
+  rb_Tagger = rb_define_module( "Tagger" );
+  rb_BrillTagger = rb_define_class_under( rb_Tagger, "BrillTagger", rb_cObject );
+  
+  rb_define_alloc_func( rb_BrillTagger, BrillTagger_alloc );
+
+  rb_define_method( rb_BrillTagger, "add_to_lexicon", BrillTagger_add_to_lexicon, 2 );
+  rb_define_method( rb_BrillTagger, "add_to_lexicon_tags", BrillTagger_add_to_lexicon_tags, 1 );
+  rb_define_method( rb_BrillTagger, "add_lexical_rule", BrillTagger_add_lexical_rule, 1 );
+  rb_define_method( rb_BrillTagger, "add_contextual_rule", BrillTagger_add_contextual_rule, 1 );
+  rb_define_method( rb_BrillTagger, "add_word_to_wordlist", BrillTagger_add_word_to_wordlist, 1 );
+  rb_define_method( rb_BrillTagger, "add_goodleft", BrillTagger_add_goodleft, 1 );
+  rb_define_method( rb_BrillTagger, "add_goodright", BrillTagger_add_goodright, 1 );
+  rb_define_method( rb_BrillTagger, "apply_lexical_rules", BrillTagger_apply_lexical_rules, 4 );
+  rb_define_method( rb_BrillTagger, "default_tag_finish", BrillTagger_default_tag_finish, 2 );
+  rb_define_method( rb_BrillTagger, "apply_contextual_rules", BrillTagger_apply_contextual_rules, 3 );
+}

data/ext/rule_tagger/registry.c

@@ -0,0 +1,326 @@
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include "sysdep.h"
+#include "memory.h"
+#include "bool.h"
+#include "useful.h"
+
+#include "registryP.h"
+
+/* Creates and returns and empty directory */
+
+Registry Registry_create(compare_func, hash_func)
+     Registry_CompareFunc compare_func;
+     Registry_HashFunc hash_func;
+{
+  Registry_rep *temp = create();
+  
+  temp->hash_table = NULL;
+  temp->ht_size = (unsigned int)0;
+  temp->comp_fun = compare_func;
+  temp->hash_fun = hash_func;
+  temp->record_count = (unsigned int)0;
+  Registry_size_hint(raise(temp), DEFAULT_HT_SIZE);
+  return raise(temp);
+}
+
+/* Deal with the expected size value.  */
+
+NORET Registry_size_hint(dir, size_hint_value)
+     Registry dir;
+     unsigned int size_hint_value;
+{
+  int i;
+  if (lower(dir)->record_count != (unsigned int)0) return;
+  if (lower(dir)->ht_size != (unsigned int)0) 
+    Memory_free((VOIDP)lower(dir)->hash_table);
+  lower(dir)->ht_size = size_hint_value;
+  lower(dir)->hash_table = 
+    (RegistryRecord **)Memory_allocate(sizeof(RegistryRecord *)
+				   * size_hint_value);
+  for (i=0; i < size_hint_value; ++i)
+    *(lower(dir)->hash_table + i) = (RegistryRecord *)NULL;
+}
+
+/* Finds a named object in a directory.  Returns NULL if the named 
+ * object is not in the directory */
+
+VOIDP Registry_get(dir, key)
+     Registry dir;
+     CONSTVOIDP key;
+{
+  RegistryRecord *p;
+  Registry_CompareFunc comp_func = lower(dir)->comp_fun;
+  Registry_HashFunc hash_func = lower(dir)->hash_fun;
+
+  assert(comp_func);
+  for (p = *(lower(dir)->hash_table + (*hash_func)(key, lower(dir)->ht_size));
+       p != NULL; 
+       p = p->next) {
+    if ((*comp_func)(key, p->name) == 0) 
+	return p->obj;
+  }
+  return NULL;			/* not found */
+}
+
+/* Finds a named object in a directory and returnd the original key */
+ /* used to index that object.  Returns NULL if the named  object is */
+ /* not in the directory.  This is useful for getting the original */
+ /* string used to make an entry into a registry in order to free it. */
+ /* In this case, a pointer to the name should be storred, then the */
+ /* entry should be removed using Registry_remove, then the key may be */
+ /* freed */
+
+VOIDP Registry_get_original_key(dir, key)
+     Registry dir;
+     CONSTVOIDP key;
+{
+  RegistryRecord *p;
+  Registry_CompareFunc comp_func = lower(dir)->comp_fun;
+  Registry_HashFunc hash_func = lower(dir)->hash_fun;
+
+  for (p = *(lower(dir)->hash_table + (*hash_func)(key, lower(dir)->ht_size));
+       p != NULL; 
+       p = p->next) {
+    if ((*comp_func)(key, p->name) == 0) 
+      return p->name;
+  }
+  return NULL;			/* not found */
+}
+
+/* Adds a named object to a directory. Returns Bool_TRUE unless an error occurs.
+ * An error will occur if Registry_get(dir, name) would succeed (return
+ * non-NULL) */
+
+Bool Registry_add(dir, name, obj)
+     Registry dir;
+     VOIDP name;
+     VOIDP obj;
+{
+  RegistryRecord *p;
+  RegistryRecord **table_entry;
+  Registry_HashFunc hash_func = lower(dir)->hash_fun;
+  Registry_CompareFunc comp_func = lower(dir)->comp_fun;
+
+  table_entry = lower(dir)->hash_table + (*hash_func)(name, lower(dir)->ht_size);
+  
+  for (p = *table_entry;
+       p != NULL; 
+       p = p->next) {
+    if ((*comp_func)(name, p->name) == 0) 
+	return Bool_FALSE;
+  }
+
+  p = (RegistryRecord *)Memory_allocate(sizeof(RegistryRecord));
+  p->next = *table_entry;
+  p->name = name;
+  p->obj = obj;
+  *table_entry = p;
+  ++(lower(dir)->record_count);
+  return Bool_TRUE;
+}
+
+/* Removes a named object from the directory. Returns Bool_TRUE unless an 
+ * error occurs (Bool_FALSE if an error does occur).  The object is 
+ * not freed.  It is the responsibility of the 
+ * caller to do so if necessary.
+ */
+
+Bool Registry_remove(dir, key)
+     Registry dir;
+     CONSTVOIDP key;
+{
+  RegistryRecord *p, **prev_p;
+  Registry_rep *ldir = lower(dir);
+  Registry_CompareFunc comp_func = ldir->comp_fun;
+  Registry_HashFunc hash_func = lower(dir)->hash_fun;
+
+  prev_p = lower(dir)->hash_table + (*hash_func)(key, lower(dir)->ht_size);
+  while ((p = *prev_p) != NULL) {
+    if ((*comp_func)(key, p->name) == 0) {
+      *prev_p = p->next;
+      Memory_free((VOIDP)p);
+      --(ldir->record_count);
+      return Bool_TRUE;
+    }
+    prev_p = &(p->next);
+  }
+  return Bool_FALSE;
+}
+
+/* Replaces an association in the registry.  If an association with the
+ * given key already exists, the value is changed to new_value, and the 
+ * old value is returned.  If no association already exists, one is added
+ * and NULL is returned. */
+
+VOIDP Registry_replace_value(dir, key, new_value)
+     Registry dir;
+     VOIDP key;
+     VOIDP new_value;
+{
+  RegistryRecord *p;
+  Registry_CompareFunc comp_func = lower(dir)->comp_fun;
+  Registry_HashFunc hash_func = lower(dir)->hash_fun;
+
+  VOIDP temp_obj;
+  for (p = *(lower(dir)->hash_table + (*hash_func)(key, lower(dir)->ht_size));
+       p != NULL; 
+       p = p->next) {
+    if ((*comp_func)(key, p->name) == 0)  {
+      temp_obj = p->obj;
+      p->obj = new_value;
+      return temp_obj;
+    }
+  }
+  Registry_add(dir, key, new_value);
+  return NULL;			/* not found */
+}
+
+NORET Registry_traverse(dir, action, priv_ptr)
+     Registry dir;
+     Registry_ActionProc action;
+     VOIDP priv_ptr;
+{
+  RegistryRecord *p;
+  int i;
+
+  for (i = 0; i < lower(dir)->ht_size; ++i)
+    for (p = *(lower(dir)->hash_table + i);
+	 p != NULL; 
+	 p = p->next) {
+      (*action)(p->name, p->obj, priv_ptr);
+    }
+  return;
+}
+
+unsigned int Registry_entry_count(dir)
+     Registry dir;
+{
+  return lower(dir)->record_count;
+}
+
+static NORET add_to_darrays(key, value, priv_ptr)
+     VOIDP key;
+     VOIDP value;
+     VOIDP priv_ptr;
+{
+  struct darray_pair *dapp = (struct darray_pair *) priv_ptr;
+  
+  if (dapp->key_darray != NULL)
+    Darray_addh(dapp->key_darray, (VOIDP)key);	/* Specs forbid mods to key */
+  if (dapp->value_darray != NULL)
+    Darray_addh(dapp->value_darray, value);
+}
+
+NORET Registry_fetch_contents(dir, key_darray, value_darray)
+     Registry dir;
+     Darray key_darray, value_darray;
+{
+  struct darray_pair dap;
+
+  assert (key_darray == NULL || Darray_len(key_darray) == 0);
+  assert (value_darray == NULL || Darray_len(value_darray) == 0);
+
+  dap.key_darray = key_darray;
+  dap.value_darray = value_darray;
+
+  Registry_traverse(dir, add_to_darrays, (VOIDP)&dap);
+}
+
+NORET Registry_destroy(dir)
+     Registry dir;
+{
+  RegistryRecord *p, *next;
+  int i;
+
+  for (i = 0; i < lower(dir)->ht_size; ++i)
+    for (p = *(lower(dir)->hash_table + i);
+	 p != NULL; 
+	 p = next) {
+      next = p->next;
+      Memory_free((VOIDP)p);
+    }
+  Memory_free((VOIDP)lower(dir)->hash_table);
+  destroy(lower(dir));
+}
+
+unsigned int Registry_ptrhash(ptr, htsize)
+     CONSTVOIDP ptr;
+     unsigned int htsize;
+{
+  unsigned int uns_int_ptr = (unsigned int)ptr;
+
+  if ((int)uns_int_ptr > 0)
+    return htsize ? (int)uns_int_ptr % (int)htsize : 0;
+  else
+    return htsize ? uns_int_ptr % htsize : 0;
+}
+
+unsigned int Registry_strhash(strp, htsize)
+     CONSTVOIDP strp;
+     unsigned int htsize;
+{
+  char *cp = (char *)strp;
+  int hash_temp = 0;
+
+  while (*cp != '\0') {
+    if (hash_temp < 0)
+      hash_temp = (hash_temp << 1) +1;
+    else
+      hash_temp = hash_temp << 1;
+    hash_temp ^= *cp;
+    ++cp;
+  }
+  return htsize ? ((unsigned int)hash_temp) % htsize : 0;
+}
+
+unsigned int Registry_strcasehash(strp, htsize)
+     CONSTVOIDP strp;
+     unsigned int htsize;
+{
+  char *cp = (char *)strp;
+  int hash_temp = 0;
+
+  while (*cp != '\0') {
+    if (hash_temp < 0)
+      hash_temp = (hash_temp << 1) +1;
+    else
+      hash_temp = hash_temp << 1;
+    if (isalpha(*cp) && isupper(*cp))
+      hash_temp ^= tolower(*cp);
+    else
+      hash_temp ^= *cp;
+    ++cp;
+  }
+  return htsize ? ((unsigned int)hash_temp) % htsize : 0;
+}
+
+int Registry_strcmp(str1, str2)
+     CONSTVOIDP str1;
+     CONSTVOIDP str2;
+{
+  return strcmp((char *)str1, (char *)str2);
+}
+
+int Registry_strcasecmp(str1, str2)
+     CONSTVOIDP str1;
+     CONSTVOIDP str2;
+{
+  return strcasecmp((char *)str1, (char *)str2);
+}
+
+int Registry_ptrcmp(ptr1, ptr2)
+     CONSTVOIDP ptr1;
+     CONSTVOIDP ptr2;
+{
+  if (ptr1==ptr2)
+    return 0;
+  else
+    return 1;
+}    
+     

data/ext/rule_tagger/registry.h

@@ -0,0 +1,129 @@
+#ifndef _registry_h_
+#define _registry_h_
+
+#include "sysdep.h"
+#include "bool.h"
+#include "darray.h"
+
+typedef struct Registry_st *Registry;
+
+#ifdef __STDC__
+typedef unsigned int (*Registry_HashFunc)(CONSTVOIDP, unsigned int);
+typedef int (*Registry_CompareFunc)(CONSTVOIDP, CONSTVOIDP);
+typedef NORET (*Registry_ActionProc)(VOIDP, VOIDP, VOIDP);
+extern Registry Registry_create(Registry_CompareFunc, Registry_HashFunc);
+extern NORET Registry_size_hint(Registry, unsigned int);
+extern Bool Registry_add(Registry, VOIDP, VOIDP);
+extern Bool Registry_remove(Registry, CONSTVOIDP);
+extern VOIDP Registry_get(Registry, CONSTVOIDP);
+extern VOIDP Registry_get_original_key(Registry, CONSTVOIDP);
+extern VOIDP Registry_replace_value(Registry, VOIDP, VOIDP);
+extern NORET Registry_traverse(Registry, Registry_ActionProc, VOIDP);
+extern unsigned int Registry_entry_count(Registry);
+extern NORET Registry_fetch_contents(Registry, Darray, Darray);
+extern NORET Registry_destroy(Registry);
+extern int Registry_ptrcmp(CONSTVOIDP, CONSTVOIDP);
+extern unsigned int Registry_ptrhash(CONSTVOIDP, unsigned int);
+extern int Registry_strcmp(CONSTVOIDP, CONSTVOIDP);
+extern unsigned int Registry_strhash(CONSTVOIDP, unsigned int);
+extern int Registry_strcasecmp(CONSTVOIDP, CONSTVOIDP);
+extern unsigned int Registry_strcasehash(CONSTVOIDP, unsigned int);
+#else
+typedef unsigned int (*Registry_HashFunc)();
+typedef int (*Registry_CompareFunc)();
+typedef void (*Registry_ActionProc)();
+extern Registry Registry_create();
+extern NORET Registry_size_hint();
+extern int Registry_add();
+extern int Registry_remove();
+extern VOIDP Registry_get();
+extern VOIDP Registry_get_original_key();
+extern VOIDP Registry_replace_value();
+extern NORET Registry_traverse();
+extern unsigned int Registry_entry_count();
+extern NORET Registry_fetch_contents();
+extern NORET Registry_destroy();
+extern int Registry_ptrcmp();
+extern unsigned int Registry_ptrhash();
+extern int Registry_strcmp();
+extern unsigned int Registry_strhash();
+extern int Registry_strcasecmp();
+extern unsigned int Registry_strcasehash();
+#endif /* __STDC__ */
+
+
+/* 
+ * Registry_create(compare_func, hash_func)
+ * Creates and returns an empty registry.  compare_func is used
+ * to compare items in the registry.  It should return 0 if its 
+ * arguments are to be considered equal.  hash_func should return
+ * a number between 0 and its second argument, and should attempt
+ * an even distribution.  If compare_func
+ * would return 0 for a pair of objects, hash_fuct should return 
+ * the same value for those objects.  For registries of abstract
+ * objects (pointers), Registry_ptrcmp() and Registry_ptrhash() should
+ * be passed as the compare_func and hash_func.  Registry_strcmp and
+ * Registry_strhash() may be used for strings.  Registry_strcasecmp and
+ * Registry_strcasehash() may be used for strings where case is not 
+ * significant (case-insensitive).
+ * 
+ * Registry_size_hint(registry, size_hint_value)
+ * The registry may operate more efficiently if this operator is called
+ * and size_hint is close to the maximum number of elements to be in 
+ * the Registry, at the possible cost of additional memory use.  Likely
+ * to be effective only on an empty registry.
+ * 
+ * Registry_add(registry, key, value)
+ * Adds the association between key and value to the registry.  Neither
+ * key nor value are copied, and neither may be freed before being removed
+ * from the registry.  The key should not be modified in way that would
+ * change the value of the compare_func or the hash_func until this
+ * association is removed from the registry.
+ * Will return Bool_FALSE if an association with the 
+ * same key is already in the registry (in which case the add will not be 
+ * performed), Bool_TRUE otherwise (on successful completion).
+ * 
+ * Registry_remove(registry, key)
+ * Removes the association with key from the registry.  Returns Bool_FALSE
+ * if no such association exists, Bool_TRUE otherwise (on successful
+ * completion) 
+ *
+ * Registry_get(registry, key)
+ * Returns the value associated with key in the registry.  Returns NULL
+ * if there is no such association.
+ * 
+ * Registry_get_original_key(registry, key)   (added by Rich Pito 7/91)
+ * Finds a named object in a directory and returnd the original key 
+ * used to index that object.  Returns NULL if the named  object is 
+ * not in the directory.  This is useful for getting the original 
+ * string used to make an entry into a registry in order to free it. 
+ * In this case, a pointer to the name should be storred, then the 
+ * entry should be removed using Registry_remove, then the key may be 
+ * freed 
+ *
+ * Registry_traverse(registry, action_proc, private_pointer)
+ * Calls action_proc once for each entry in the registry.  private_pointer
+ * is a VOIDP which is passed to the action_proc, but not otherwise used.
+ * action_proc should not modify the registry in any way.  action_proc takes
+ * three arguments, the key, the value, and private_pointer.  
+ * 
+ * Registry_entry_count(registry)
+ * Returns the number of associations in the registry.
+ *
+ * Registry_fetch_contents(registry, key_darray, value_darray)
+ * Stores the contents of the registry as follows:  In no particular 
+ * order, each association is processed in turn by storing (using Darray_addh)
+ * the key into key_darray and the value into value_darray.  Either 
+ * or both key_darray and/or value_darray may be NULL, in which case
+ * the corresponding data will not be processed.  Actual Darrays passed
+ * (not NULL) must be empty.  Any objects added to key_darray must be 
+ * treated as read-only as long as they remain in the registry.
+ * 
+ * Registry_destroy(registry)
+ * Deallocates all resources needed by the registry.  Should be the last
+ * operation performed on the registry.  Does not deallocate the objects
+ * (keys and values) contained in the registry (this should be done after 
+ * the registry is destroyed).  Implicitly removes all associations
+ * from the registry.
+ */
+#endif /* _resgistry_h_ */