mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-29 13:29:28 +00:00
icc (#1170). Patch by Erick Tryzelaar. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@81104 91177308-0d34-0410-b5e6-96231b3b80d8
222 lines
5.9 KiB
C++
222 lines
5.9 KiB
C++
//=== Registry.h - Linker-supported plugin registries -----------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// Defines a registry template for discovering pluggable modules.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_SUPPORT_REGISTRY_H
|
|
#define LLVM_SUPPORT_REGISTRY_H
|
|
|
|
namespace llvm {
|
|
/// A simple registry entry which provides only a name, description, and
|
|
/// no-argument constructor.
|
|
template <typename T>
|
|
class SimpleRegistryEntry {
|
|
const char *Name, *Desc;
|
|
T *(*Ctor)();
|
|
|
|
public:
|
|
SimpleRegistryEntry(const char *N, const char *D, T *(*C)())
|
|
: Name(N), Desc(D), Ctor(C)
|
|
{}
|
|
|
|
const char *getName() const { return Name; }
|
|
const char *getDesc() const { return Desc; }
|
|
T *instantiate() const { return Ctor(); }
|
|
};
|
|
|
|
|
|
/// Traits for registry entries. If using other than SimpleRegistryEntry, it
|
|
/// is necessary to define an alternate traits class.
|
|
template <typename T>
|
|
class RegistryTraits {
|
|
RegistryTraits(); // Do not implement.
|
|
|
|
public:
|
|
typedef SimpleRegistryEntry<T> entry;
|
|
|
|
/// nameof/descof - Accessors for name and description of entries. These are
|
|
// used to generate help for command-line options.
|
|
static const char *nameof(const entry &Entry) { return Entry.getName(); }
|
|
static const char *descof(const entry &Entry) { return Entry.getDesc(); }
|
|
};
|
|
|
|
|
|
/// A global registry used in conjunction with static constructors to make
|
|
/// pluggable components (like targets or garbage collectors) "just work" when
|
|
/// linked with an executable.
|
|
template <typename T, typename U = RegistryTraits<T> >
|
|
class Registry {
|
|
public:
|
|
typedef U traits;
|
|
typedef typename U::entry entry;
|
|
|
|
class node;
|
|
class listener;
|
|
class iterator;
|
|
|
|
private:
|
|
Registry(); // Do not implement.
|
|
|
|
static void Announce(const entry &E) {
|
|
for (listener *Cur = ListenerHead; Cur; Cur = Cur->Next)
|
|
Cur->registered(E);
|
|
}
|
|
|
|
friend class node;
|
|
static node *Head, *Tail;
|
|
|
|
friend class listener;
|
|
static listener *ListenerHead, *ListenerTail;
|
|
|
|
public:
|
|
/// Node in linked list of entries.
|
|
///
|
|
class node {
|
|
friend class iterator;
|
|
|
|
node *Next;
|
|
const entry& Val;
|
|
|
|
public:
|
|
node(const entry& V) : Next(0), Val(V) {
|
|
if (Tail)
|
|
Tail->Next = this;
|
|
else
|
|
Head = this;
|
|
Tail = this;
|
|
|
|
Announce(V);
|
|
}
|
|
};
|
|
|
|
|
|
/// Iterators for registry entries.
|
|
///
|
|
class iterator {
|
|
const node *Cur;
|
|
|
|
public:
|
|
explicit iterator(const node *N) : Cur(N) {}
|
|
|
|
bool operator==(const iterator &That) const { return Cur == That.Cur; }
|
|
bool operator!=(const iterator &That) const { return Cur != That.Cur; }
|
|
iterator &operator++() { Cur = Cur->Next; return *this; }
|
|
const entry &operator*() const { return Cur->Val; }
|
|
const entry *operator->() const { return &Cur->Val; }
|
|
};
|
|
|
|
static iterator begin() { return iterator(Head); }
|
|
static iterator end() { return iterator(0); }
|
|
|
|
|
|
/// Abstract base class for registry listeners, which are informed when new
|
|
/// entries are added to the registry. Simply subclass and instantiate:
|
|
///
|
|
/// class CollectorPrinter : public Registry<Collector>::listener {
|
|
/// protected:
|
|
/// void registered(const Registry<Collector>::entry &e) {
|
|
/// cerr << "collector now available: " << e->getName() << "\n";
|
|
/// }
|
|
///
|
|
/// public:
|
|
/// CollectorPrinter() { init(); } // Print those already registered.
|
|
/// };
|
|
///
|
|
/// CollectorPrinter Printer;
|
|
///
|
|
class listener {
|
|
listener *Prev, *Next;
|
|
|
|
friend void Registry::Announce(const entry &E);
|
|
|
|
protected:
|
|
/// Called when an entry is added to the registry.
|
|
///
|
|
virtual void registered(const entry &) = 0;
|
|
|
|
/// Calls 'registered' for each pre-existing entry.
|
|
///
|
|
void init() {
|
|
for (iterator I = begin(), E = end(); I != E; ++I)
|
|
registered(*I);
|
|
}
|
|
|
|
public:
|
|
listener() : Prev(ListenerTail), Next(0) {
|
|
if (Prev)
|
|
Prev->Next = this;
|
|
else
|
|
ListenerHead = this;
|
|
ListenerTail = this;
|
|
}
|
|
|
|
virtual ~listener() {
|
|
if (Next)
|
|
Next->Prev = Prev;
|
|
else
|
|
ListenerTail = Prev;
|
|
if (Prev)
|
|
Prev->Next = Next;
|
|
else
|
|
ListenerHead = Next;
|
|
}
|
|
};
|
|
|
|
|
|
/// A static registration template. Use like such:
|
|
///
|
|
/// Registry<Collector>::Add<FancyGC>
|
|
/// X("fancy-gc", "Newfangled garbage collector.");
|
|
///
|
|
/// Use of this template requires that:
|
|
///
|
|
/// 1. The registered subclass has a default constructor.
|
|
//
|
|
/// 2. The registry entry type has a constructor compatible with this
|
|
/// signature:
|
|
///
|
|
/// entry(const char *Name, const char *ShortDesc, T *(*Ctor)());
|
|
///
|
|
/// If you have more elaborate requirements, then copy and modify.
|
|
///
|
|
template <typename V>
|
|
class Add {
|
|
entry Entry;
|
|
node Node;
|
|
|
|
static T *CtorFn() { return new V(); }
|
|
|
|
public:
|
|
Add(const char *Name, const char *Desc)
|
|
: Entry(Name, Desc, CtorFn), Node(Entry) {}
|
|
};
|
|
|
|
/// Registry::Parser now lives in llvm/Support/RegistryParser.h.
|
|
|
|
};
|
|
|
|
|
|
template <typename T, typename U>
|
|
typename Registry<T,U>::node *Registry<T,U>::Head;
|
|
|
|
template <typename T, typename U>
|
|
typename Registry<T,U>::node *Registry<T,U>::Tail;
|
|
|
|
template <typename T, typename U>
|
|
typename Registry<T,U>::listener *Registry<T,U>::ListenerHead;
|
|
|
|
template <typename T, typename U>
|
|
typename Registry<T,U>::listener *Registry<T,U>::ListenerTail;
|
|
|
|
}
|
|
|
|
#endif
|