Added interprocedural view

[r411]

diff --git a/ir/adt/eset.c b/ir/adt/eset.c
new file mode 100644 (file)
index 0000000..33ddd38
--- /dev/null
+++ b/ir/adt/eset.c
@@ -0,0 +1,78 @@
+/* -------------------------------------------------------------------
+ * $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);
+  }
+}

diff --git a/ir/adt/eset.h b/ir/adt/eset.h
new file mode 100644 (file)
index 0000000..13d9e70
--- /dev/null
+++ b/ir/adt/eset.h
@@ -0,0 +1,57 @@
+/* -------------------------------------------------------------------
+ * $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_ */

diff --git a/ir/adt/pmap.c b/ir/adt/pmap.c
new file mode 100644 (file)
index 0000000..961a2c7
--- /dev/null
+++ b/ir/adt/pmap.c
@@ -0,0 +1,76 @@
+/* -------------------------------------------------------------------
+ * $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);
+}

diff --git a/ir/adt/pmap.h b/ir/adt/pmap.h
new file mode 100644 (file)
index 0000000..41ab920
--- /dev/null
+++ b/ir/adt/pmap.h
@@ -0,0 +1,57 @@
+/* -------------------------------------------------------------------
+ * $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_ */