s_clib.c

Go to the documentation of this file.

/* gEDA - GPL Electronic Design Automation
 * libgeda - gEDA's library
 * Copyright (C) 1998-2010 gEDA Contributors (see ChangeLog for details)
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include <config.h>
#include <missing.h>

#include <stdio.h>
#include <glib.h>

#ifdef HAVE_STRING_H
#include <string.h>
#endif

#ifdef HAVE_LIBDMALLOC
#include <dmalloc.h>
#endif

#ifdef HAVE_SYS_WAIT_H
#include <sys/wait.h>
#else
#define WIFSIGNALED(x) 0
#define WTERMSIG(x)    0
#define WIFEXITED(x)   1
#define WEXITSTATUS(x) 0
#endif

#include <time.h>

#include "libgeda_priv.h"

/* Constant definitions
 * ===================
 */

#define SYM_FILENAME_FILTER ".sym"

#define CLIB_LIST_CMD       "list"

#define CLIB_DATA_CMD       "get"

#define CLIB_MAX_SYMBOL_CACHE 128

#define CLIB_MIN_SYMBOL_CACHE 96

/* Type definitions
 * ================
 */

enum CLibSourceType { 
  CLIB_NONE = 0,
  CLIB_DIR, 
  CLIB_CMD,
  CLIB_SCM,
};

struct _CLibSource {
  enum CLibSourceType type;
  gchar *name;
  GList *symbols;

  gchar *directory;

  gchar *list_cmd;
  gchar *get_cmd;

  SCM list_fn;
  SCM get_fn;
};

struct _CLibSymbol {
  CLibSource *source;
  gchar *name;
};

typedef struct _CacheEntry CacheEntry;
struct _CacheEntry {
  CLibSymbol *ptr;
  gchar *data;
  time_t accessed;
};

/* Static variables
 * ================
 */

static GList *clib_sources = NULL;

static GHashTable *clib_search_cache = NULL;

static GHashTable *clib_symbol_cache = NULL;

/* Local static functions
 * ======================
 */
static void free_symbol (gpointer data, gpointer user_data);
static void free_symbol_cache_entry (gpointer data);
static void free_source (gpointer data, gpointer user_data);
static gint compare_source_name (gconstpointer a, gconstpointer b);
static gint compare_symbol_name (gconstpointer a, gconstpointer b);
static void cache_find_oldest (gpointer key, gpointer value, gpointer user_data);
static gchar *run_source_command (const gchar *command);
static CLibSymbol *source_has_symbol (const CLibSource *source, 
                      const gchar *name);
static gchar *uniquify_source_name (const gchar *name);
static void refresh_directory (CLibSource *source);
static void refresh_command (CLibSource *source);
static void refresh_scm (CLibSource *source);
static gchar *get_data_directory (const CLibSymbol *symbol);
static gchar *get_data_command (const CLibSymbol *symbol);
static gchar *get_data_scm (const CLibSymbol *symbol);

void s_clib_init ()
{
  if (clib_sources != NULL) {
    s_clib_free ();
  }

  if (clib_search_cache != NULL) {
    s_clib_flush_search_cache();
  } else {
    clib_search_cache = g_hash_table_new_full ((GHashFunc) g_str_hash,
                                               (GEqualFunc)g_str_equal,
                                               (GDestroyNotify) g_free,
                                               (GDestroyNotify) g_list_free);
  }

  if (clib_symbol_cache != NULL) {
    s_clib_flush_symbol_cache();
  } else {
    clib_symbol_cache =
      g_hash_table_new_full ((GHashFunc) g_direct_hash,
                             (GEqualFunc) g_direct_equal,
                             NULL,
                             (GDestroyNotify) free_symbol_cache_entry);
  }
}

static void free_symbol (gpointer data, gpointer user_data)
{
  CLibSymbol *symbol = data;
  if (symbol != NULL) {
    if (symbol->source != NULL) {
      symbol->source = NULL;
    }
    if (symbol->name != NULL) {
      g_free (symbol->name);
      symbol->name = NULL;
    }
    g_free(symbol);
  }
}

static void free_symbol_cache_entry (gpointer data)
{
  CacheEntry *entry = data;
  g_return_if_fail (entry != NULL);
  g_free (entry->data);
  g_free (entry);
}

static void free_source (gpointer data, gpointer user_data)
{
  CLibSource *source = data;
  if (source != NULL) {
    if (source->name != NULL) {
      g_free (source->name);
      source->name = NULL;
    }
    if (source->symbols != NULL) {
      g_list_foreach (source->symbols, (GFunc) free_symbol, NULL);
      g_list_free (source->symbols);
      source->symbols = NULL;
    }
    if (source->directory != NULL) {
      g_free (source->directory);
      source->directory = NULL;
    }
    if (source->list_cmd != NULL) {
      g_free (source->list_cmd);
      source->list_cmd = NULL;
    }
    if (source->get_cmd != NULL) {
      g_free (source->get_cmd);
      source->get_cmd = NULL;
    }
    if (source->type == CLIB_SCM) {
      scm_gc_unprotect_object (source->list_fn);
      scm_gc_unprotect_object (source->get_fn);
    }
  }
}

void s_clib_free ()
{
  if (clib_sources != NULL) {
    g_list_foreach (clib_sources, (GFunc) free_source, NULL);
    g_list_free (clib_sources);
    clib_sources = NULL;
  }
}

static gint compare_source_name (gconstpointer a, gconstpointer b)
{
  const CLibSource *src1 = a;
  const CLibSource *src2 = b;

  g_return_val_if_fail ((src1 != NULL), 0);
  g_return_val_if_fail ((src2 != NULL), 0);

  g_return_val_if_fail ((src1->name != NULL), 0);
  g_return_val_if_fail ((src2->name != NULL), 0);

  return strcasecmp(src1->name, src2->name);
}

static gint compare_symbol_name (gconstpointer a, gconstpointer b)
{
  const CLibSymbol *sym1 = a;
  const CLibSymbol *sym2 = b;

  g_return_val_if_fail ((sym1 != NULL), 0);
  g_return_val_if_fail ((sym2 != NULL), 0);

  g_return_val_if_fail ((sym1->name != NULL), 0);
  g_return_val_if_fail ((sym2->name != NULL), 0);

  return strcasecmp(sym1->name, sym2->name);
}

static void cache_find_oldest (gpointer key,
                               gpointer value,
                               gpointer user_data)
{
  CacheEntry *current = value;
  CacheEntry **oldest = user_data;

  if (current->accessed < (*oldest)->accessed) {
    *oldest = current;
  }
}

static gchar *run_source_command (const gchar *command)
{
  gchar *standard_output = NULL;
  gchar *standard_error = NULL;
  gint exit_status;
  GError *e = NULL;
  gboolean success = FALSE;

  g_return_val_if_fail((command != NULL), NULL);

  g_spawn_command_line_sync (command,
                             &standard_output,
                             &standard_error,
                             &exit_status,
                             &e);

  if (e != NULL) {
    s_log_message (_("Library command failed [%s]: %s\n"), command,
           e->message);
    g_error_free (e);

  } else if (WIFSIGNALED(exit_status)) {
    s_log_message (_("Library command failed [%s]: Uncaught signal %i.\n"),
                   command, WTERMSIG(exit_status));
    
  } else if (WIFEXITED(exit_status) && WEXITSTATUS(exit_status)) {
    s_log_message (_("Library command failed [%s]\n"), command);
    s_log_message(_("Error output was:\n%s\n"), standard_error);

  } else {
    success = TRUE;
  }

  /* forward library command messages */
  if (success && standard_error != NULL)
    s_log_message ("%s", standard_error);

  g_free (standard_error);
  
  if (success) return standard_output;

  g_free (standard_output);
  return NULL;
}

GList *s_clib_get_sources (const gboolean sorted)
{
  GList *l = g_list_copy(clib_sources);
  if (sorted) {
    l = g_list_sort (l, (GCompareFunc) compare_source_name);
  }
  return l;
}

static CLibSymbol *source_has_symbol (const CLibSource *source, 
                      const gchar *name)
{
  GList *symlist;
  CLibSymbol *symbol;

  for (symlist = g_list_first(source->symbols); 
       symlist != NULL; 
       symlist = g_list_next(symlist)) {
    
    symbol = (CLibSymbol *) symlist->data;

    if (strcmp (symbol->name, name) == 0) return symbol;
  }

  return NULL;
}

static gchar *uniquify_source_name (const gchar *name)
{
  gchar *newname = NULL;
  gint i = 0;

  if (s_clib_get_source_by_name (name) == NULL) {
    return g_strdup (name);
  }

  do {
    g_free (newname);
    i++;
    newname = g_strdup_printf ("%s<%i>", name, i);
  } while (s_clib_get_source_by_name (newname) != NULL);

  s_log_message (_("Library name [%s] already in use.  Using [%s].\n"),
                 name, newname);

  return newname;
}

static void refresh_directory (CLibSource *source)
{
  CLibSymbol *symbol;
  GDir *dir;
  const gchar *entry;
  gchar *low_entry;
  gchar *fullpath;
  gboolean isfile;
  GError *e = NULL;

  g_return_if_fail (source != NULL);
  g_return_if_fail (source->type == CLIB_DIR);

  /* Clear the current symbol list */
  g_list_foreach (source->symbols, (GFunc) free_symbol, NULL);
  g_list_free (source->symbols);
  source->symbols = NULL;  

  /* Open the directory for reading. */
  dir = g_dir_open (source->directory, 0, &e);

  if (e != NULL) {
    s_log_message (_("Failed to open directory [%s]: %s\n"),
           source->directory, e->message);
    g_error_free (e);
    return;
  }

  while ((entry = g_dir_read_name (dir)) != NULL) {
    /* skip ".", ".." & hidden files */
    if (entry[0] == '.') continue;

    /* skip subdirectories (for now) */
    fullpath = g_build_filename (source->directory, entry, NULL);
    isfile = g_file_test (fullpath, G_FILE_TEST_IS_REGULAR);
    g_free (fullpath);
    if (!isfile) continue;

    /* skip filenames that we already know about. */
    if (source_has_symbol (source, entry) != NULL) continue;
    
    /* skip filenames which don't have the right suffix. */
    low_entry = g_utf8_strdown (entry, -1);
    if (!g_str_has_suffix (low_entry, SYM_FILENAME_FILTER)) {
      g_free (low_entry);
      continue;
    }
    g_free (low_entry);

    /* Create and add new symbol record */
    symbol = g_new0 (CLibSymbol, 1);
    symbol->source = source;
    symbol->name = g_strdup(entry);

    /* Prepend because it's faster and it doesn't matter what order we
     * add them. */
    source->symbols = g_list_prepend (source->symbols, symbol);
  }

  entry = NULL;
  g_dir_close (dir);

  /* Now sort the list of symbols by name. */
  source->symbols = g_list_sort (source->symbols, 
                 (GCompareFunc) compare_symbol_name);

  s_clib_flush_search_cache();
  s_clib_flush_symbol_cache();
}

static void refresh_command (CLibSource *source)
{
  gchar *cmdout;
  TextBuffer *tb;
  const gchar *line;
  CLibSymbol *symbol;
  gchar *name;

  g_return_if_fail (source != NULL);
  g_return_if_fail (source->type == CLIB_CMD);

  /* Clear the current symbol list */
  g_list_foreach (source->symbols, (GFunc) free_symbol, NULL);
  g_list_free (source->symbols);
  source->symbols = NULL;  

  /* Run the command to get the list of symbols */
  cmdout = run_source_command (source->list_cmd);
  if (cmdout == NULL) return;

  /* Use a TextBuffer to help reading out the lines of the output */
  tb = s_textbuffer_new (cmdout, -1);

  while (1) {
    line = s_textbuffer_next_line (tb);
    if (line == NULL) break;
    if (line[0] == '.') continue;  /* TODO is this sane? */

    name = remove_nl(g_strdup(line));

    /* skip symbols already known about */
    if (source_has_symbol (source, name) != NULL) {
      g_free (name);
      continue;
    }

    symbol = g_new0 (CLibSymbol, 1);
    symbol->source = source;
    symbol->name = name;

    /* Prepend because it's faster and it doesn't matter what order we
     * add them. */
    source->symbols = g_list_prepend (source->symbols, symbol);    
  }

  s_textbuffer_free (tb);
  g_free (cmdout);

  /* Sort all symbols by name. */
  source->symbols = g_list_sort (source->symbols, 
                 (GCompareFunc) compare_symbol_name);

  s_clib_flush_search_cache();
  s_clib_flush_symbol_cache();
}

static void refresh_scm (CLibSource *source)
{
  SCM symlist;
  SCM symname;
  CLibSymbol *symbol;
  char *tmp;

  g_return_if_fail (source != NULL);
  g_return_if_fail (source->type == CLIB_SCM);

  /* Clear the current symbol list */
  g_list_foreach (source->symbols, (GFunc) free_symbol, NULL);
  g_list_free (source->symbols);
  source->symbols = NULL;

  symlist = scm_call_0 (source->list_fn);

  if (SCM_NCONSP (symlist) && (symlist != SCM_EOL)) {
    s_log_message (_("Failed to scan library [%s]: Scheme function returned non-list\n"),
           source->name);
    return;
  }

  while (symlist != SCM_EOL) {
    symname = SCM_CAR (symlist);
    if (!scm_is_string (symname)) {
      s_log_message (_("Non-string symbol name while scanning library [%s]\n"),
             source->name);
    } else {
      symbol = g_new0 (CLibSymbol, 1);
      symbol->source = source;

      /* Need to make sure that the correct free() function is called
       * on strings allocated by Guile. */
      tmp = scm_to_utf8_string (symname);
      symbol->name = g_strdup(tmp);
      free (tmp);

      /* Prepend because it's faster and it doesn't matter what order we
       * add them. */
      source->symbols = g_list_prepend (source->symbols, symbol);
    }
 
    symlist = SCM_CDR (symlist);
  }

  /* Now sort the list of symbols by name. */
  source->symbols = g_list_sort (source->symbols, 
                 (GCompareFunc) compare_symbol_name);

  s_clib_flush_search_cache();
  s_clib_flush_symbol_cache();
}

void s_clib_refresh ()
{
  GList *sourcelist;
  CLibSource *source;

  for (sourcelist = clib_sources; 
       sourcelist != NULL; 
       sourcelist = g_list_next(sourcelist)) {
    
    source = (CLibSource *) sourcelist->data;
    switch (source->type)
      {
      case CLIB_DIR:
    refresh_directory(source);
    break;
      case CLIB_CMD:
    refresh_command (source);
    break;
      case CLIB_SCM:
    refresh_scm (source);
    break;
      default:
    g_critical("s_clib_refresh: source %p has bad source type %i\n",
                   source, (gint) source->type);
        break;
      }
  }
}

const CLibSource *s_clib_get_source_by_name (const gchar *name)
{
  GList *sourcelist;
  CLibSource *source;

  for (sourcelist = clib_sources; 
       sourcelist != NULL; 
       sourcelist = g_list_next(sourcelist)) {

    source = (CLibSource *) sourcelist->data;
    if (strcmp (source->name, name) == 0) {
      return source;
    }
  }

  return NULL;
}

const CLibSource *s_clib_add_directory (const gchar *directory, 
                    const gchar *name)
{
  CLibSource *source;
  gchar *intname, *realname;

  if (directory == NULL) {
    return NULL;
  }
  
  if (name == NULL) {
    intname = g_path_get_basename (directory);
    realname = uniquify_source_name (intname);
    g_free (intname);
  } else {
    realname = uniquify_source_name (name);
  }  

  source = g_new0 (CLibSource, 1);
  source->type = CLIB_DIR;
  source->directory = g_strdup (directory);
  source->name = realname;

  refresh_directory (source);

  /* Sources added later get scanned earlier */
  clib_sources = g_list_prepend (clib_sources, source);

  return source;
}

const CLibSource *s_clib_add_command (const gchar *list_cmd,
                                      const gchar *get_cmd,
                      const gchar *name)
{
  CLibSource *source;
  gchar *realname;
  
  if (name == NULL) {
    s_log_message (_("Cannot add library: name not specified\n"));
    return NULL;
  }
  
  realname = uniquify_source_name (name);

  if (list_cmd == NULL || get_cmd == NULL) {
    s_log_message (_("Cannot add library [%s]: both 'list' and "
                     "'get' commands must be specified.\n"),
           realname);
  }

  source = g_new0 (CLibSource, 1);
  source->type = CLIB_CMD;
  source->name = realname;

  source->list_cmd = g_strdup (list_cmd);
  source->get_cmd = g_strdup (get_cmd);

  refresh_command (source);

  /* Sources added later get sacnned earlier */
  clib_sources = g_list_prepend (clib_sources, source);

  return source;
}

const CLibSource *s_clib_add_scm (SCM listfunc, SCM getfunc, const gchar *name)
{
  CLibSource *source;
  gchar *realname;

  if (name == NULL) {
    s_log_message (_("Cannot add library: name not specified\n"));
    return NULL;
  }  
  
  realname = uniquify_source_name (name);

  if (scm_is_false (scm_procedure_p (listfunc)) 
      && scm_is_false (scm_procedure_p (getfunc))) {
    s_log_message (_("Cannot add Scheme-library [%s]: callbacks must be closures\n"),
           realname);
    return NULL;
  }

  source = g_new0 (CLibSource, 1);
  source->type = CLIB_SCM;
  source->name = realname;
  source->list_fn = scm_gc_protect_object (listfunc);
  source->get_fn = scm_gc_protect_object (getfunc);

  refresh_scm (source);

  clib_sources = g_list_prepend (clib_sources, source);

  return source;
}

const gchar *s_clib_source_get_name (const CLibSource *source)
{
  if (source == NULL) return NULL;
  return source->name;
}

GList *s_clib_source_get_symbols (const CLibSource *source)
{
  if (source == NULL) return NULL;
  return g_list_copy(source->symbols);
}


const gchar *s_clib_symbol_get_name (const CLibSymbol *symbol)
{
  if (symbol == NULL) return NULL;
  return symbol->name;
}

gchar *s_clib_symbol_get_filename (const CLibSymbol *symbol)
{
  if (symbol == NULL) return NULL;

  if (symbol->source->type != CLIB_DIR) return NULL;

  return g_build_filename(symbol->source->directory, symbol->name, NULL);
}

const CLibSource *s_clib_symbol_get_source (const CLibSymbol *symbol)
{
  if (symbol == NULL) return NULL;
  return symbol->source;
}

static gchar *get_data_directory (const CLibSymbol *symbol)
{
  gchar *filename = NULL;
  gchar *data = NULL;
  GError *e = NULL;

  g_return_val_if_fail ((symbol != NULL), NULL);
  g_return_val_if_fail ((symbol->source->type == CLIB_DIR), NULL);

  filename = g_build_filename(symbol->source->directory, 
                  symbol->name, NULL);

  g_file_get_contents (filename, &data, NULL, &e);

  if (e != NULL) {
    s_log_message (_("Failed to load symbol from file [%s]: %s\n"),
           filename, e->message);
    g_error_free (e);
  }

  g_free (filename);
  return data;
}

static gchar *get_data_command (const CLibSymbol *symbol)
{
  gchar *command;
  gchar *result;

  g_return_val_if_fail ((symbol != NULL), NULL);
  g_return_val_if_fail ((symbol->source->type == CLIB_CMD), NULL);
  
  command = g_strdup_printf ("%s %s", symbol->source->get_cmd, 
                          symbol->name);

  result = run_source_command ( command );

  g_free (command);

  return result;
}

static gchar *get_data_scm (const CLibSymbol *symbol)
{
  SCM symdata;
  char *tmp;
  gchar *result;

  g_return_val_if_fail ((symbol != NULL), NULL);
  g_return_val_if_fail ((symbol->source->type == CLIB_SCM), NULL);

  symdata = scm_call_1 (symbol->source->get_fn, 
            scm_from_utf8_string (symbol->name));

  if (!scm_is_string (symdata)) {
    s_log_message (_("Failed to load symbol data [%s] from source [%s]\n"),
           symbol->name, symbol->source->name);
    return NULL;
  }

  /* Need to make sure that the correct free() function is called
   * on strings allocated by Guile. */
  tmp = scm_to_utf8_string (symdata);
  result = g_strdup(tmp);
  free (tmp);

  return result;
}

gchar *s_clib_symbol_get_data (const CLibSymbol *symbol)
{
  CacheEntry *cached;
  gchar *data;
  gpointer symptr;
  gint n;

  g_return_val_if_fail ((symbol != NULL), NULL);
  g_return_val_if_fail ((symbol->source != NULL), NULL);

  /* Trickery to bypass effects of const */
  symptr = (gpointer) symbol;

  /* First, try the cache. */
  cached = g_hash_table_lookup (clib_symbol_cache, symptr);
  if (cached != NULL) {
    cached->accessed = time(NULL);
    return g_strdup(cached->data);
  }

  /* If the symbol wasn't found in the cache, get it directly. */
  switch (symbol->source->type)
    {
    case CLIB_DIR:
      data = get_data_directory (symbol);
      break;
    case CLIB_CMD:
      data = get_data_command (symbol);
      break;
    case CLIB_SCM:
      data = get_data_scm (symbol);
      break;
    default:
      g_critical("s_clib_symbol_get_data: source %p has bad source type %i\n",
                 symbol->source, (gint) symbol->source->type);
      return NULL;
    }

  if (data == NULL) return NULL;

  /* Cache the symbol data */
  cached = g_new (CacheEntry, 1);
  cached->ptr = (CLibSymbol *) symptr;
  cached->data = g_strdup (data);
  cached->accessed = time (NULL);
  g_hash_table_insert (clib_symbol_cache, symptr, cached);

  /* Clean out the cache if it's too full */
  n = g_hash_table_size (clib_symbol_cache);
  if (n > CLIB_MAX_SYMBOL_CACHE) {
    for ( ; n > CLIB_MIN_SYMBOL_CACHE; n--) {
      g_hash_table_foreach (clib_symbol_cache,
                            (GHFunc) cache_find_oldest,
                            &cached);
      g_hash_table_remove (clib_symbol_cache, cached->ptr);
    }
  }

  return data;
}

GList *s_clib_search (const gchar *pattern, const CLibSearchMode mode)
{  
  GList *sourcelist;
  GList *symlist;
  GList *result = NULL;
  CLibSource *source;
  CLibSymbol *symbol;
  GPatternSpec *globpattern = NULL;
  gchar *key;
  gchar keytype;

  if (pattern == NULL) return NULL;

  /* Use different cache keys depending on what sort of search is being done */
  switch (mode)
    {
    case CLIB_GLOB:
      keytype = 'g';
      break;
    case CLIB_EXACT:
      keytype = 's';
      break;
    default:
      g_critical ("s_clib_search: Bad search mode %i\n", mode);
      return NULL;
    }
  key = g_strdup_printf("%c%s", keytype, pattern);

  /* Check to see if the query is already in the cache */
  result = (GList *) g_hash_table_lookup (clib_search_cache, key);
  if (result != NULL) {
    g_free (key);
    return g_list_copy (result);
  }

  if (mode == CLIB_GLOB) {
    globpattern = g_pattern_spec_new(pattern);
  }

  for (sourcelist = clib_sources; 
       sourcelist != NULL; 
       sourcelist = g_list_next(sourcelist)) {

    source = (CLibSource *) sourcelist->data;

    for (symlist = source->symbols;
     symlist != NULL;
     symlist = g_list_next(symlist)) {
    
      symbol = (CLibSymbol *) symlist->data;

      switch (mode)
    {
    case CLIB_EXACT:
      if (strcmp (pattern, symbol->name) == 0) {
        result = g_list_prepend (result, symbol);
      }
      break;
    case CLIB_GLOB:
      if (g_pattern_match_string (globpattern, symbol->name)) {
        result = g_list_prepend (result, symbol);
      }
      break;
    }
    }
  }

  result = g_list_reverse (result);

  if (globpattern != NULL) {
    g_pattern_spec_free (globpattern);
  }

  g_hash_table_insert (clib_search_cache, key, g_list_copy (result));
  /* __don't__ free key here, it's stored by the hash table! */

  return result;
}




void s_clib_flush_search_cache ()
{
  g_hash_table_remove_all (clib_search_cache);  /* Introduced in glib 2.12 */
}


void s_clib_flush_symbol_cache ()
{
  g_hash_table_remove_all (clib_symbol_cache);  /* Introduced in glib 2.12 */
}

void
s_clib_symbol_invalidate_data (const CLibSymbol *symbol)
{
  g_hash_table_remove (clib_symbol_cache, (gpointer) symbol);
}

const CLibSymbol *s_clib_get_symbol_by_name (const gchar *name)
{
  GList *symlist = NULL;
  const CLibSymbol *retval;

  symlist = s_clib_search (name, CLIB_EXACT);

  if (symlist == NULL) {
    s_log_message (_("Component [%s] was not found in the component library\n"),
                   name);
    return NULL;
  }

  if (g_list_next (symlist) != NULL) { /* More than one symbol */
    s_log_message (_("More than one component found with name [%s]\n"),
                   name);
  }

  retval = (CLibSymbol *) symlist->data;
  g_list_free (symlist);

  return retval;
}

gchar *s_clib_symbol_get_data_by_name (const gchar *name)
{
  const CLibSymbol *symbol;

  symbol = s_clib_get_symbol_by_name (name);
  if (symbol == NULL) return NULL;
  return s_clib_symbol_get_data (symbol);
}

GList *s_toplevel_get_symbols (const TOPLEVEL *toplevel)
{
  GList *result = NULL;
  GList *iter = NULL;
  OBJECT *o = NULL;
  PAGE *page;
  GList *symlist = NULL;
  CLibSymbol *sym = NULL;
  const GList *p_iter;
  const GList *o_iter;

  g_return_val_if_fail ((toplevel != NULL), NULL);

  for ( p_iter = geda_list_get_glist( toplevel->pages );
        p_iter != NULL;
        p_iter = g_list_next( p_iter )) {
    page = (PAGE *)p_iter->data;
    for (o_iter = s_page_objects (page);
         o_iter != NULL;
         o_iter = g_list_next (o_iter)) {
      o = (OBJECT *)o_iter->data;
      if (o->type != OBJ_COMPLEX) continue;
      if (o->complex_basename == NULL)  continue;
      
      /* Since we're not looking at embedded symbols, the first
       * component with the given name will be the one we need.
       * N.b. we don't use s_clib_get_symbol_by_name() because it's
       * spammeh. */
      symlist = s_clib_search (o->complex_basename, CLIB_EXACT);
      if (symlist == NULL) continue;
      sym = (CLibSymbol *) symlist->data;
      g_list_free (symlist);
      
      /* We do the list insertion by evilly comparing pointers.  This
       * is okay, because we always take the first symbol with the
       * given name, and symbol pointers don't change while this
       * function is running (we hope).  Note that this creates a
       * sorted list.*/
      for (iter = result;
           iter != NULL;
           iter = g_list_next(iter)) {
        if (iter->data == sym) {
          break; /* Already in list */
        }
        if (compare_symbol_name (iter->data, sym) > 0) {
          /* not in list yet, and gone past point where it should go */
          result = g_list_insert_before (result, iter, sym);
          break;
        }
      }
      if (iter == NULL) {
        /* not in list yet, and at end of list */
        result = g_list_append (result, sym);    
      }
    }
  }

  return result;
}