Commit 1ab0f17a authored by Götz Lindenmaier's avatar Götz Lindenmaier
Browse files

Added interprocedural view

[r411]
parent b3a34b6e
/* -------------------------------------------------------------------
* $Id$
* -------------------------------------------------------------------
* Datentyp: Vereinfachte Menge (hash-set) zum Speichern von
* Zeigern/Adressen.
*
* Erstellt: Hubert Schmid, 09.06.2002
* ---------------------------------------------------------------- */
#include "eset.h"
#include "set.h"
struct eset {
int dummy; /* dummy entry */
};
static const int INITIAL_SLOTS = 64;
static int pcmp(const void * * p1, const void * * p2, size_t size) {
return *p1 == *p2 ? 0 : 1;
}
eset * eset_create(void) {
return (eset *) new_set((set_cmp_fun) pcmp, INITIAL_SLOTS);
}
eset * eset_copy(eset * source) {
eset * ret = eset_create();
void * p;
for (p = eset_first(source); p; p = eset_next(source)) {
eset_insert(ret, p);
}
return ret;
}
void eset_destroy(eset * s) {
del_set((set *) s);
}
void eset_insert(eset * s, void * p) {
if (!eset_contains(s, p)) {
set_insert((set *) s, &p, sizeof(void *), (unsigned) p);
}
}
bool eset_contains(eset * s, void * p) {
return set_find((set *) s, &p, sizeof(void *), (unsigned) p) != NULL;
}
void * eset_first(eset * s) {
void * p = set_first((set *) s);
return p == NULL ? NULL : *((void * *) p);
}
void * eset_next(eset *s) {
void * p = set_next((set *) s);
return p == NULL ? NULL : *((void * *) p);
}
void eset_insert_all(eset * target, eset * source) {
void * p;
for (p = eset_first(source); p; p = eset_next(source)) {
eset_insert(target, p);
}
}
/* -------------------------------------------------------------------
* $Id$
* -------------------------------------------------------------------
* Datentyp: Vereinfachte Menge (hash-set) zum Speichern von
* Zeigern/Adressen.
*
* Erstellt: Hubert Schmid, 09.06.2002
* ---------------------------------------------------------------- */
#ifndef _ESET_H_
#define _ESET_H_
#include "bool.h"
/* "eset" ist eine Menge von Adressen. Der Vergleich und das Hashen
* wird über die Adresse gemacht. "NULL" sollte nicht gespeichert
* werden. */
typedef struct eset eset;
/* Erzeugt eine neue leere Menge. */
eset * eset_create(void);
/* Erzeugt eine Kopie der übergebenen Menge. Das Kopieren funktioniert
* nur, wenn in der übergebenen Menge "NULL" nicht enthalten ist. */
eset * eset_copy(eset *);
/* Löscht die Menge. */
void eset_destroy(eset *);
/* Fügt ein Adresse in die Menge ein, wenn es nicht bereits in der
* Menge enthalten ist. */
void eset_insert(eset *, void *);
/* Prüft ob eine Adresse in der Menge enthalten ist. */
bool eset_contains(eset *, void *);
/* Mit den Funktionen "eset_first" und "eset_next" kann man durch die
* Menge iterieren. Die Funktion gibt jeweils die Adresse zurück. Wenn
* keine weiteren Adressen in der Menge sind, geben die Funktionen
* "NULL" zurück. Warnung: Man sollte deshalb "NULL" nicht in der
* Menge speichern, weil man sonst nicht durch die Menge iterieren
* kann. */
void * eset_first(eset *);
void * eset_next(eset *);
/* Fügt alle Elemente der Menge "source" der Menge "target"
* hinzu. Diese Funktion funktioniert nur, wenn in der Menge "source"
* die "NULL"-Adresse nicht enthalten ist. */
void eset_insert_all(eset * target, eset * source);
#endif /* _ESET_H_ */
/* -------------------------------------------------------------------
* $Id$
* -------------------------------------------------------------------
* Datentyp: Vereinfachte Map (hash-map) zum Speichern von
* Zeigern/Adressen -> Zeigern/Adressen.
*
* Erstellt: Hubert Schmid, 09.06.2002
* ---------------------------------------------------------------- */
#include "pmap.h"
#include <assert.h>
#include "set.h"
struct pmap {
int dummy; /* dummy entry */
};
static const int INITIAL_SLOTS = 64;
static int pmap_entry_cmp(const pmap_entry * entry1, const pmap_entry * entry2, size_t size) {
return entry1->key == entry2->key ? 0 : 1;
}
pmap * pmap_create(void) {
return (pmap *) new_set((set_cmp_fun) pmap_entry_cmp, INITIAL_SLOTS);
}
void pmap_destroy(pmap * map) {
del_set((set *) map);
}
void pmap_insert(pmap * map, void * key, void * value) {
if (pmap_contains(map, key)) {
pmap_entry * entry = pmap_find(map, key);
entry->value = value;
} else {
pmap_entry entry;
entry.key = key;
entry.value = value;
set_insert((set *) map, &entry, sizeof(pmap_entry), (unsigned) key);
}
}
bool pmap_contains(pmap * map, void * key) {
return set_find((set *) map, &key, sizeof(pmap_entry), (unsigned) key) != NULL;
}
pmap_entry * pmap_find(pmap * map, void * key) {
return (pmap_entry *) set_find((set *) map, &key, sizeof(pmap_entry), (unsigned) key);
}
void * pmap_get(pmap * map, void * key) {
pmap_entry * entry = pmap_find(map, key);
return entry == NULL ? NULL : entry->value;
}
pmap_entry * pmap_first(pmap * map) {
return (pmap_entry *) set_first((set *) map);
}
pmap_entry * pmap_next(pmap * map) {
return (pmap_entry *) set_next((set *) map);
}
/* -------------------------------------------------------------------
* $Id$
* -------------------------------------------------------------------
* Datentyp: Vereinfachte Map (hash-map) zum Speichern von
* Zeigern/Adressen -> Zeigern/Adressen.
*
* Erstellt: Hubert Schmid, 09.06.2002
* ---------------------------------------------------------------- */
#ifndef _PMAP_H_
#define _PMAP_H_
#include "bool.h"
/* Map die Adressen auf Adressen abbildet. Der Vergleich und das
* Hashen findet über die Adresse statt. */
typedef struct pmap pmap;
typedef struct pmap_entry {
void * key;
void * value;
} pmap_entry;
/* Erzeugt eine neue leere Map. */
pmap * pmap_create(void);
/* Löscht eine Map. */
void pmap_destroy(pmap *);
/* Fügt ein Paar (key,value) in die Map ein. Gibt es bereits einen
* Eintrag mit "key" in er Map, so wird der entsprechende "value"
* überschrieben. */
void pmap_insert(pmap *, void * key, void * value);
/* Prüft ob ein Eintrag zu "key" exisitiert. */
bool pmap_contains(pmap *, void * key);
/* Gibt den Eintrag zu "key" zurück. */
pmap_entry * pmap_find(pmap *, void * key);
/* Gibt für den Eintrag zu "key" den "value" zurück. */
void * pmap_get(pmap *, void * key);
/* Mit den Funktionen "pmap_first" und "pmap_next" kann man durch die
* Map iterieren. Die Funktionen geben einen Zeiger auf einen Eintrag
* zurück (key,value). Die Funktionen geben "NULL" zurück, wenn kein
* weiterer Eintrag existiert. */
pmap_entry * pmap_first(pmap *);
pmap_entry * pmap_next(pmap *);
#endif /* _PMAP_H_ */
Supports Markdown
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment