isl_id.c

Go to the documentation of this file.

/*
 * Copyright 2008-2009 Katholieke Universiteit Leuven
 *
 * Use of this software is governed by the MIT license
 *
 * Written by Sven Verdoolaege, K.U.Leuven, Departement
 * Computerwetenschappen, Celestijnenlaan 200A, B-3001 Leuven, Belgium
 */
 
#include <string.h>
#include <isl_ctx_private.h>
#include <isl_id_private.h>
 
#undef EL_BASE
#define EL_BASE id
 
#include <isl_list_templ.c>
#include <isl_list_read_templ.c>
 
/* A special, static isl_id to use as domains (and ranges)
 * of sets and parameters domains.
 * The user should never get a hold on this isl_id.
 */
isl_id isl_id_none = {
  .ref = -1,
  .ctx = NULL,
  .name = "#none",
  .user = NULL
};
 
isl_ctx *isl_id_get_ctx(__isl_keep isl_id *id)
{
  return id ? id->ctx : NULL;
}
 
void *isl_id_get_user(__isl_keep isl_id *id)
{
  return id ? id->user : NULL;
}
 
const char *isl_id_get_name(__isl_keep isl_id *id)
{
  return id ? id->name : NULL;
}
 
static __isl_give isl_id *id_alloc(isl_ctx *ctx, const char *name, void *user)
{
  const char *copy = name ? strdup(name) : NULL;
  isl_id *id;
 
  if (name && !copy)
    return NULL;
  id = isl_calloc_type(ctx, struct isl_id);
  if (!id)
    goto error;
 
  id->ctx = ctx;
  isl_ctx_ref(id->ctx);
  id->ref = 1;
  id->name = copy;
  id->user = user;
 
  id->hash = isl_hash_init();
  if (name)
    id->hash = isl_hash_string(id->hash, name);
  else
    id->hash = isl_hash_builtin(id->hash, user);
 
  return id;
error:
  free((char *)copy);
  return NULL;
}
 
uint32_t isl_id_get_hash(__isl_keep isl_id *id)
{
  return id ? id->hash : 0;
}
 
struct isl_name_and_user {
  const char *name;
  void *user;
};
 
static isl_bool isl_id_has_name_and_user(const void *entry, const void *val)
{
  isl_id *id = (isl_id *)entry;
  struct isl_name_and_user *nu = (struct isl_name_and_user *) val;
 
  if (id->user != nu->user)
    return isl_bool_false;
  if (id->name == nu->name)
    return isl_bool_true;
  if (!id->name || !nu->name)
    return isl_bool_false;
 
  return isl_bool_ok(!strcmp(id->name, nu->name));
}
 
__isl_give isl_id *isl_id_alloc(isl_ctx *ctx, const char *name, void *user)
{
  struct isl_hash_table_entry *entry;
  uint32_t id_hash;
  struct isl_name_and_user nu = { name, user };
 
  if (!ctx)
    return NULL;
 
  id_hash = isl_hash_init();
  if (name)
    id_hash = isl_hash_string(id_hash, name);
  else
    id_hash = isl_hash_builtin(id_hash, user);
  entry = isl_hash_table_find(ctx, &ctx->id_table, id_hash,
          isl_id_has_name_and_user, &nu, 1);
  if (!entry)
    return NULL;
  if (entry->data)
    return isl_id_copy(entry->data);
  entry->data = id_alloc(ctx, name, user);
  if (!entry->data)
    ctx->id_table.n--;
  return entry->data;
}
 
/* If the id has a negative refcount, then it is a static isl_id
 * which should not be changed.
 */
__isl_give isl_id *isl_id_copy(isl_id *id)
{
  if (!id)
    return NULL;
 
  if (id->ref < 0)
    return id;
 
  id->ref++;
  return id;
}
 
/* Compare two isl_ids.
 *
 * The order is fairly arbitrary.  We do keep the comparison of
 * the user pointers as a last resort since these pointer values
 * may not be stable across different systems or even different runs.
 */
int isl_id_cmp(__isl_keep isl_id *id1, __isl_keep isl_id *id2)
{
  if (id1 == id2)
    return 0;
  if (!id1)
    return -1;
  if (!id2)
    return 1;
  if (!id1->name != !id2->name)
    return !id1->name - !id2->name;
  if (id1->name) {
    int cmp = strcmp(id1->name, id2->name);
    if (cmp != 0)
      return cmp;
  }
  if (id1->user < id2->user)
    return -1;
  else
    return 1;
}
 
static isl_bool isl_id_eq(const void *entry, const void *name)
{
  return isl_bool_ok(entry == name);
}
 
uint32_t isl_hash_id(uint32_t hash, __isl_keep isl_id *id)
{
  if (id)
    isl_hash_hash(hash, id->hash);
 
  return hash;
}
 
/* Replace the free_user callback by "free_user".
 */
__isl_give isl_id *isl_id_set_free_user(__isl_take isl_id *id,
  void (*free_user)(void *user))
{
  if (!id)
    return NULL;
 
  id->free_user = free_user;
 
  return id;
}
 
/* Retrieve the callback set by isl_id_set_free_user,
 * or NULL if no such callback was set.
 */
void (*isl_id_get_free_user(__isl_keep isl_id *id))(void *user)
{
  if (!id)
    return NULL;
  return id->free_user;
}
 
/* If the id has a negative refcount, then it is a static isl_id
 * and should not be freed.
 */
__isl_null isl_id *isl_id_free(__isl_take isl_id *id)
{
  struct isl_hash_table_entry *entry;
 
  if (!id)
    return NULL;
 
  if (id->ref < 0)
    return NULL;
 
  if (--id->ref > 0)
    return NULL;
 
  entry = isl_hash_table_find(id->ctx, &id->ctx->id_table, id->hash,
          isl_id_eq, id, 0);
  if (!entry)
    return NULL;
  if (entry == isl_hash_table_entry_none)
    isl_die(id->ctx, isl_error_unknown,
      "unable to find id", (void)0);
  else
    isl_hash_table_remove(id->ctx, &id->ctx->id_table, entry);
 
  if (id->free_user)
    id->free_user(id->user);
 
  free((char *)id->name);
  isl_ctx_deref(id->ctx);
  free(id);
 
  return NULL;
}
 
__isl_give isl_printer *isl_printer_print_id(__isl_take isl_printer *p,
  __isl_keep isl_id *id)
{
  if (!id)
    goto error;
 
  if (id->name)
    p = isl_printer_print_str(p, id->name);
  if (id->user) {
    char buffer[50];
    snprintf(buffer, sizeof(buffer), "@%p", id->user);
    p = isl_printer_print_str(p, buffer);
  }
  return p;
error:
  isl_printer_free(p);
  return NULL;
}
 
/* Read an isl_id from "s" based on its name.
 */
__isl_give isl_id *isl_stream_read_id(__isl_keep isl_stream *s)
{
  struct isl_token *tok;
  char *str;
  isl_ctx *ctx;
  isl_id *id;
 
  if (!s)
    return NULL;
  tok = isl_stream_next_token(s);
  if (!tok) {
    isl_stream_error(s, NULL, "unexpected EOF");
    return NULL;
  }
  ctx = isl_stream_get_ctx(s);
  str = isl_token_get_str(ctx, tok);
  isl_token_free(tok);
  if (!str)
    return NULL;
  id = isl_id_alloc(ctx, str, NULL);
  free(str);
 
  return id;
}
 
#undef TYPE_BASE
#define TYPE_BASE id
#include "isl_read_from_str_templ.c"
 
/* Is "id1" (obviously) equal to "id2"?
 *
 * isl_id objects can be compared by pointer value, but
 * isl_multi_*_plain_is_equal needs an isl_*_plain_is_equal.
 */
static isl_bool isl_id_plain_is_equal(__isl_keep isl_id *id1,
  __isl_keep isl_id *id2)
{
  if (!id1 || !id2)
    return isl_bool_error;
  return id1 == id2;
}
 
#undef BASE
#define BASE id
 
#include <isl_multi_no_domain_templ.c>
#include <isl_multi_no_explicit_domain.c>
#include <isl_multi_templ.c>