openflow build environment setup

2025-11-11 16:45:43 +08:00
parent be0a7ad9b3
commit 50ecb9a23f
2767 changed files with 62766 additions and 649828 deletions
--- a/openflow/include/clicktool/routert.hh
+++ b/openflow/include/clicktool/routert.hh
@ -0,0 +1,672 @@
+// -*- c-basic-offset: 4 -*-
+#ifndef CLICK_ROUTERT_HH
+#define CLICK_ROUTERT_HH
+#include "elementt.hh"
+#include "eclasst.hh"
+#include <click/error.hh>
+#include <click/hashtable.hh>
+#include <click/archive.hh>
+#include <click/variableenv.hh>
+typedef HashTable<String, int> StringMap;
+
+class RouterT : public ElementClassT { public:
+
+    RouterT();
+    RouterT(const String &name, const LandmarkT &landmark, RouterT *declaration_scope = 0);
+    virtual ~RouterT();
+
+    // ELEMENTS
+    int nelements() const		{ return _elements.size(); }
+    int n_live_elements() const		{ return _n_live_elements; }
+
+    inline const ElementT *element(const String &) const;
+    inline ElementT *element(const String &);
+    int eindex(const String &name) const { return _element_name_map[name]; }
+
+    const ElementT *element(int i) const{ return _elements[i]; }
+    ElementT *element(int i)		{ return _elements[i]; }
+
+    class iterator;
+    class const_iterator;
+    class type_iterator;
+    class const_type_iterator;
+    inline iterator begin_elements();
+    inline const_iterator begin_elements() const;
+    inline type_iterator begin_elements(ElementClassT *);
+    inline const_type_iterator begin_elements(ElementClassT *) const;
+    inline iterator end_elements();
+    inline const_iterator end_elements() const;
+
+    bool elive(int i) const		{ return _elements[i]->live(); }
+    bool edead(int i) const		{ return _elements[i]->dead(); }
+    inline String ename(int) const;
+    inline ElementClassT *etype(int) const;
+    inline String etype_name(int) const;
+
+    ElementT *get_element(const String &name, ElementClassT *eclass, const String &configuration, const LandmarkT &landmark);
+    ElementT *add_anon_element(ElementClassT *eclass, const String &configuration = String(), const LandmarkT &landmark = LandmarkT::empty_landmark());
+    void change_ename(int, const String &);
+    int __map_element_name(const String &name, int new_eindex);
+    void assign_element_names();
+    void free_element(ElementT *);
+    void free_dead_elements();
+
+    void set_new_eindex_collector(Vector<int> *v) { _new_eindex_collector=v; }
+
+    // TYPES
+    ElementClassT *locally_declared_type(const String &) const;
+    inline ElementClassT *declared_type(const String &) const;
+    void add_declared_type(ElementClassT *, bool anonymous);
+
+    void collect_types(HashTable<ElementClassT *, int> &) const;
+    void collect_locally_declared_types(Vector<ElementClassT *> &) const;
+    void collect_overloads(Vector<ElementClassT *> &) const;
+
+    // CONNECTIONS
+    enum { end_to = ConnectionT::end_to, end_from = ConnectionT::end_from };
+
+    class conn_iterator;
+    inline conn_iterator begin_connections() const;
+    inline conn_iterator end_connections() const;
+
+    conn_iterator find_connections_touching(int eindex, int port, bool isoutput) const;
+    inline conn_iterator find_connections_touching(const PortT &port, bool isoutput) const;
+    inline conn_iterator find_connections_touching(ElementT *e, bool isoutput) const;
+    inline conn_iterator find_connections_touching(ElementT *e, int port, bool isoutput) const;
+
+    inline conn_iterator find_connections_from(const PortT &port) const;
+    inline conn_iterator find_connections_from(ElementT *e) const;
+    inline conn_iterator find_connections_from(ElementT *e, int port) const;
+    inline conn_iterator find_connections_to(const PortT &port) const;
+    inline conn_iterator find_connections_to(ElementT *e) const;
+    inline conn_iterator find_connections_to(ElementT *e, int port) const;
+
+    bool has_connection(const PortT &from, const PortT &to) const;
+
+    void find_connections_touching(const PortT &port, bool isoutput, Vector<PortT> &v, bool clear = true) const;
+    inline void find_connections_from(const PortT &output, Vector<PortT> &v, bool clear = true) const {
+	find_connections_touching(output, end_from, v, clear);
+    }
+    void find_connections_to(const PortT &input, Vector<PortT> &v) const {
+	find_connections_touching(input, end_to, v);
+    }
+
+    void find_connection_vector_touching(const ElementT *e, bool isoutput, Vector<conn_iterator> &x) const;
+    inline void find_connection_vector_from(const ElementT *e, Vector<conn_iterator> &x) const {
+	find_connection_vector_touching(e, end_from, x);
+    }
+    inline void find_connection_vector_to(const ElementT *e, Vector<conn_iterator> &x) const {
+	find_connection_vector_touching(e, end_to, x);
+    }
+
+    void add_tunnel(const String &namein, const String &nameout, const LandmarkT &landmark, ErrorHandler *errh);
+
+    bool add_connection(const PortT &, const PortT &, const LandmarkT &landmark = LandmarkT::empty_landmark());
+    inline bool add_connection(ElementT *, int, ElementT *, int, const LandmarkT &landmark = LandmarkT::empty_landmark());
+    conn_iterator erase(conn_iterator it);
+    void kill_bad_connections();
+
+    conn_iterator change_connection_to(conn_iterator it, PortT new_to);
+    conn_iterator change_connection_from(conn_iterator it, PortT new_from);
+
+    bool insert_before(const PortT &, const PortT &);
+    bool insert_after(const PortT &, const PortT &);
+    inline bool insert_before(ElementT *, const PortT &);
+    inline bool insert_after(ElementT *, const PortT &);
+
+    // REQUIREMENTS
+    void add_requirement(const String &type, const String &value);
+    void remove_requirement(const String &type, const String &value);
+    const Vector<String> &requirements() const	{ return _requirements; }
+
+    // ARCHIVE
+    void add_archive(const ArchiveElement &);
+    int narchive() const			{ return _archive.size(); }
+    int archive_index(const String &s) const	{ return _archive_map[s]; }
+    const Vector<ArchiveElement> &archive() const{ return _archive; }
+    ArchiveElement &archive(int i)		{ return _archive[i]; }
+    const ArchiveElement &archive(int i) const	{ return _archive[i]; }
+    inline ArchiveElement &archive(const String &s);
+    inline const ArchiveElement &archive(const String &s) const;
+
+    void add_components_to(RouterT *, const String &prefix = String()) const;
+
+    // CHECKING, FLATTENING AND EXPANDING
+    void check() const;
+
+    void remove_duplicate_connections();
+    void remove_dead_elements();
+
+    void remove_compound_elements(ErrorHandler *, bool expand_vars);
+    void remove_tunnels(ErrorHandler *errh = 0);
+    void compact();
+
+    void expand_into(RouterT *dest, const String &prefix, VariableEnvironment &env, ErrorHandler *errh);
+    void flatten(ErrorHandler *errh, bool expand_vars = false);
+
+    // UNPARSING
+    void unparse(StringAccum &, const String & = String()) const;
+    void unparse_requirements(StringAccum &, const String & = String()) const;
+    void unparse_defines(StringAccum &, const String & = String()) const;
+    void unparse_declarations(StringAccum &, const String & = String()) const;
+    void unparse_connections(StringAccum &, const String & = String()) const;
+    String configuration_string() const;
+
+    // COMPOUND ELEMENTS
+    String landmark() const		{ return _type_landmark.str(); }
+    String decorated_landmark() const	{ return _type_landmark.decorated_str(); }
+    void set_landmarkt(const LandmarkT &l) { _type_landmark = l; }
+    const ElementTraits *find_traits(ElementMap *emap) const;
+
+    bool primitive() const		{ return false; }
+    bool overloaded() const;
+
+    inline bool defines(const String &name) const;
+
+    int nformals() const		{ return _formals.size(); }
+    inline bool add_formal(const String &name, const String &type);
+    const String &formal_name(int i) const { return _formals[i]; }
+    const String &formal_type(int i) const { return _formal_types[i]; }
+
+    const VariableEnvironment &scope() const { return _scope; }
+    inline bool define(const String &name, const String &value);
+    inline void redefine(const VariableEnvironment &);
+    int ninputs() const			{ return _ninputs; }
+    int noutputs() const		{ return _noutputs; }
+
+    RouterT *declaration_scope() const	{ return _declaration_scope; }
+    ElementClassT *overload_type() const { return _overload_type; }
+    void set_overload_type(ElementClassT *);
+
+    int check_pseudoelement(const ElementT *e, bool isoutput, const char *name, ErrorHandler *errh) const;
+    int finish_type(ErrorHandler *errh);
+
+    bool need_resolve() const;
+    ElementClassT *resolve(int, int, Vector<String> &, ErrorHandler *, const LandmarkT &landmark);
+    void create_scope(const Vector<String> &args, const VariableEnvironment &env, VariableEnvironment &new_env);
+    ElementT *complex_expand_element(ElementT *, const Vector<String> &, RouterT *, const String &prefix, const VariableEnvironment &, ErrorHandler *);
+
+    String unparse_signature() const;
+    void unparse_declaration(StringAccum &, const String &, UnparseKind, ElementClassT *);
+
+    RouterT *cast_router()		{ return this; }
+
+  private:
+
+    struct ElementType {
+	ElementClassT * const type;
+	int scope_cookie;
+	int prev_name;
+	ElementType(ElementClassT *c, int sc, int pn) : type(c), scope_cookie(sc), prev_name(pn) { assert(type); type->use(); }
+	ElementType(const ElementType &o) : type(o.type), scope_cookie(o.scope_cookie), prev_name(o.prev_name) { type->use(); }
+	~ElementType()			{ type->unuse(); }
+	const String &name() const	{ return type->name(); }
+      private:
+	ElementType &operator=(const ElementType &);
+    };
+
+    enum { end_all = 2 };
+
+    struct ConnectionX : public ConnectionT {
+	ConnectionX **_pprev;
+	ConnectionX *_next[3];
+	ConnectionX(const PortT &from, const PortT &to,
+		    const LandmarkT &landmark)
+	    : ConnectionT(from, to, landmark) {
+	}
+	ConnectionX *next_from() const {
+	    return _next[end_from];
+	}
+	ConnectionX *next_to() const {
+	    return _next[end_to];
+	}
+    };
+
+    struct ConnectionSet {
+	ConnectionSet *next;
+	ConnectionX c[1];
+    };
+
+    struct Pair {
+	ConnectionX *end[2];
+	Pair() { end[0] = end[1] = 0; }
+	Pair(ConnectionX *from, ConnectionX *to) { end[end_from] = from; end[end_to] = to; }
+	ConnectionX *&operator[](int i) { assert(i >= 0 && i <= 1); return end[i]; }
+	ConnectionX *operator[](int i) const { assert(i >= 0 && i <= 1); return end[i]; }
+    };
+
+    StringMap _element_name_map;
+    Vector<ElementT *> _elements;
+    ElementT *_free_element;
+    int _n_live_elements;
+    Vector<int> *_new_eindex_collector;
+
+    ConnectionSet *_connsets;
+    int _nconnx;
+    Vector<Pair> _first_conn;
+    ConnectionX *_conn_head;
+    ConnectionX **_conn_tail;
+    ConnectionX *_free_conn;
+
+    StringMap _declared_type_map;
+    Vector<ElementType> _declared_types;
+
+    Vector<String> _requirements;
+
+    StringMap _archive_map;
+    Vector<ArchiveElement> _archive;
+
+    RouterT *_declaration_scope;
+    int _declaration_scope_cookie;
+    int _scope_cookie;
+
+    VariableEnvironment _scope;
+    Vector<String> _formals;
+    Vector<String> _formal_types;
+    int _ninputs;
+    int _noutputs;
+    bool _scope_order_error;
+    bool _circularity_flag;
+    bool _potential_duplicate_connections;
+    ElementClassT *_overload_type;
+    LandmarkT _type_landmark;
+    mutable ElementTraits _traits;
+
+    RouterT(const RouterT &);
+    RouterT &operator=(const RouterT &);
+
+    ElementClassT *declared_type(const String &, int scope_cookie) const;
+    void update_noutputs(int);
+    void update_ninputs(int);
+    ElementT *add_element(const ElementT &);
+    void assign_element_name(int);
+    void free_connection(ConnectionX *c);
+    void unlink_connection_from(ConnectionX *c);
+    void unlink_connection_to(ConnectionX *c);
+    void expand_tunnel(Vector<PortT> *port_expansions, const Vector<PortT> &ports, bool is_output, int which, ErrorHandler *) const;
+    int assign_arguments(const Vector<String> &, Vector<String> *) const;
+
+    friend class RouterUnparserT;
+    friend class conn_iterator;
+
+};
+
+class RouterT::const_iterator { public:
+    typedef int (const_iterator::*unspecified_bool_type)() const;
+    operator unspecified_bool_type() const { return _e ? &const_iterator::eindex : 0; }
+    int eindex() const			{ return _e->eindex(); }
+    void operator++()			{ if (_e) step(_e->router(), eindex()+1);}
+    void operator++(int)		{ ++(*this); }
+    const ElementT *operator->() const	{ return _e; }
+    const ElementT *get() const		{ return _e; }
+    const ElementT &operator*() const	{ return *_e; }
+  private:
+    const ElementT *_e;
+    const_iterator()			: _e(0) { }
+    const_iterator(const RouterT *r, int ei) { step(r, ei); }
+    void step(const RouterT *, int);
+    friend class RouterT;
+    friend class RouterT::iterator;
+};
+
+class RouterT::iterator : public RouterT::const_iterator { public:
+    ElementT *operator->() const	{ return const_cast<ElementT *>(_e); }
+    ElementT *get() const		{ return const_cast<ElementT *>(_e); }
+    ElementT &operator*() const		{ return const_cast<ElementT &>(*_e); }
+  private:
+    iterator()				: const_iterator() { }
+    iterator(RouterT *r, int ei)	: const_iterator(r, ei) { }
+    friend class RouterT;
+};
+
+class RouterT::const_type_iterator { public:
+    typedef int (const_type_iterator::*unspecified_bool_type)() const;
+    operator unspecified_bool_type() const { return _e ? &const_type_iterator::eindex : 0; }
+    int eindex() const			{ return _e->eindex(); }
+    inline void operator++();
+    inline void operator++(int);
+    const ElementT *operator->() const	{ return _e; }
+    const ElementT *get() const		{ return _e; }
+    const ElementT &operator*() const	{ return *_e; }
+  private:
+    const ElementT *_e;
+    ElementClassT *_t;
+    const_type_iterator()		: _e(0), _t(0) { }
+    const_type_iterator(const RouterT *r, ElementClassT *t, int i) : _t(t) { step(r, i); }
+    void step(const RouterT *, int);
+    friend class RouterT;
+    friend class RouterT::type_iterator;
+};
+
+class RouterT::type_iterator : public RouterT::const_type_iterator { public:
+    ElementT *operator->() const	{ return const_cast<ElementT *>(_e); }
+    ElementT *get() const		{ return const_cast<ElementT *>(_e); }
+    ElementT &operator*() const		{ return const_cast<ElementT &>(*_e); }
+  private:
+    type_iterator()			: const_type_iterator() { }
+    type_iterator(RouterT *r, ElementClassT *t, int ei)	: const_type_iterator(r, t, ei) { }
+    friend class RouterT;
+};
+
+class RouterT::conn_iterator { public:
+    inline conn_iterator()			: _conn(0), _by(0) { }
+    typedef bool (conn_iterator::*unspecified_bool_type)() const;
+    operator unspecified_bool_type() const	{ return _conn ? &conn_iterator::empty : 0; }
+    inline bool empty() const			{ return !_conn; }
+    inline bool is_back() const;
+    inline conn_iterator &operator++();
+    inline void operator++(int);
+    const ConnectionT *operator->() const	{ return _conn; }
+    const ConnectionT *get() const		{ return _conn; }
+    const ConnectionT &operator*() const	{ return *_conn; }
+  private:
+    const ConnectionX *_conn;
+    int _by;
+    inline conn_iterator(const ConnectionX *conn, int by);
+    void assign(const ConnectionX *conn, int by) {
+	_conn = conn;
+	_by = by;
+    }
+    void complex_step();
+    friend class RouterT;
+};
+
+
+inline RouterT::iterator
+RouterT::begin_elements()
+{
+    return iterator(this, 0);
+}
+
+inline RouterT::const_iterator
+RouterT::begin_elements() const
+{
+    return const_iterator(this, 0);
+}
+
+inline RouterT::type_iterator
+RouterT::begin_elements(ElementClassT *t)
+{
+    return type_iterator(this, t, 0);
+}
+
+inline RouterT::const_type_iterator
+RouterT::begin_elements(ElementClassT *t) const
+{
+    return const_type_iterator(this, t, 0);
+}
+
+inline RouterT::const_iterator
+RouterT::end_elements() const
+{
+    return const_iterator();
+}
+
+inline RouterT::iterator
+RouterT::end_elements()
+{
+    return iterator();
+}
+
+inline void
+RouterT::const_type_iterator::operator++()
+{
+    if (_e)
+	step(_e->router(), _e->eindex() + 1);
+}
+
+inline void
+RouterT::const_type_iterator::operator++(int)
+{
+    ++(*this);
+}
+
+inline
+RouterT::conn_iterator::conn_iterator(const ConnectionX *conn, int by)
+    : _conn(conn), _by(by)
+{
+}
+
+inline RouterT::conn_iterator
+RouterT::begin_connections() const
+{
+    return conn_iterator(_conn_head, end_all);
+}
+
+inline RouterT::conn_iterator
+RouterT::end_connections() const
+{
+    return conn_iterator();
+}
+
+inline RouterT::conn_iterator RouterT::find_connections_touching(const PortT &port, bool isoutput) const
+{
+    assert(port.router() == this);
+    return find_connections_touching(port.eindex(), port.port, isoutput);
+}
+
+inline RouterT::conn_iterator RouterT::find_connections_touching(ElementT *e, bool isoutput) const
+{
+    assert(e->router() == this);
+    return find_connections_touching(e->eindex(), -1, isoutput);
+}
+
+inline RouterT::conn_iterator RouterT::find_connections_touching(ElementT *e, int port, bool isoutput) const
+{
+    assert(e->router() == this);
+    return find_connections_touching(e->eindex(), port, isoutput);
+}
+
+inline RouterT::conn_iterator RouterT::find_connections_from(const PortT &port) const
+{
+    return find_connections_touching(port, end_from);
+}
+
+inline RouterT::conn_iterator RouterT::find_connections_from(ElementT *e) const
+{
+    return find_connections_touching(e, end_from);
+}
+
+inline RouterT::conn_iterator RouterT::find_connections_from(ElementT *e, int port) const
+{
+    return find_connections_touching(e, port, end_from);
+}
+
+inline RouterT::conn_iterator RouterT::find_connections_to(const PortT &port) const
+{
+    return find_connections_touching(port, end_to);
+}
+
+inline RouterT::conn_iterator RouterT::find_connections_to(ElementT *e) const
+{
+    return find_connections_touching(e, end_to);
+}
+
+inline RouterT::conn_iterator RouterT::find_connections_to(ElementT *e, int port) const
+{
+    return find_connections_touching(e, port, end_to);
+}
+
+inline RouterT::conn_iterator &
+RouterT::conn_iterator::operator++()
+{
+    if (_conn && unsigned(_by) <= end_all)
+	_conn = _conn->_next[_by];
+    else
+	complex_step();
+    return *this;
+}
+
+inline void
+RouterT::conn_iterator::operator++(int)
+{
+    ++(*this);
+}
+
+inline bool
+RouterT::conn_iterator::is_back() const
+{
+    conn_iterator x(*this);
+    return x && !++x;
+}
+
+inline const ElementT *
+RouterT::element(const String &s) const
+{
+    int i = _element_name_map[s];
+    return (i >= 0 ? _elements[i] : 0);
+}
+
+inline ElementT *
+RouterT::element(const String &s)
+{
+    int i = _element_name_map.get(s);
+    return (i >= 0 ? _elements[i] : 0);
+}
+
+inline String
+RouterT::ename(int e) const
+{
+    return _elements[e]->name();
+}
+
+inline ElementClassT *
+RouterT::etype(int e) const
+{
+    return _elements[e]->type();
+}
+
+inline String
+RouterT::etype_name(int e) const
+{
+    return _elements[e]->type()->name();
+}
+
+inline ElementClassT *
+RouterT::declared_type(const String &name) const
+{
+    return declared_type(name, 0x7FFFFFFF);
+}
+
+inline bool
+RouterT::add_connection(ElementT *from_elt, int from_port, ElementT *to_elt,
+			int to_port, const LandmarkT &landmark)
+{
+    return add_connection(PortT(from_elt, from_port), PortT(to_elt, to_port), landmark);
+}
+
+inline bool
+RouterT::insert_before(ElementT *e, const PortT &h)
+{
+    return insert_before(PortT(e, 0), h);
+}
+
+inline bool
+RouterT::insert_after(ElementT *e, const PortT &h)
+{
+    return insert_after(PortT(e, 0), h);
+}
+
+inline bool
+RouterT::defines(const String &name) const
+{
+    for (const String *f = _formals.begin(); f != _formals.end(); ++f)
+	if (*f == name)
+	    return true;
+    return _scope.defines(name);
+}
+
+inline bool
+RouterT::add_formal(const String &name, const String &type)
+{
+    if (defines(name))
+	return false;
+    _formals.push_back(name);
+    _formal_types.push_back(type);
+    return true;
+}
+
+inline bool
+RouterT::define(const String &name, const String &value)
+{
+    if (defines(name))
+	return false;
+    return _scope.define(name, value, false);
+}
+
+inline void
+RouterT::redefine(const VariableEnvironment &ve)
+{
+    for (int i = 0; i < ve.size(); i++)
+	_scope.define(ve.name(i), ve.value(i), true);
+}
+
+inline ArchiveElement &
+RouterT::archive(const String &name)
+{
+    return _archive[_archive_map.get(name)];
+}
+
+inline const ArchiveElement &
+RouterT::archive(const String &name) const
+{
+    return _archive[_archive_map[name]];
+}
+
+inline bool
+operator==(const RouterT::const_iterator &i, const RouterT::const_iterator &j)
+{
+    return i.get() == j.get();
+}
+
+inline bool
+operator!=(const RouterT::const_iterator &i, const RouterT::const_iterator &j)
+{
+    return i.get() != j.get();
+}
+
+inline bool
+operator==(const RouterT::const_type_iterator &i, const RouterT::const_type_iterator &j)
+{
+    return i.get() == j.get();
+}
+
+inline bool
+operator!=(const RouterT::const_type_iterator &i, const RouterT::const_type_iterator &j)
+{
+    return i.get() != j.get();
+}
+
+inline bool
+operator==(const RouterT::const_type_iterator &i, const RouterT::const_iterator &j)
+{
+    return i.get() == j.get();
+}
+
+inline bool
+operator!=(const RouterT::const_type_iterator &i, const RouterT::const_iterator &j)
+{
+    return i.get() != j.get();
+}
+
+inline bool
+operator==(const RouterT::conn_iterator &i, const RouterT::conn_iterator &j)
+{
+    return i.get() == j.get();
+}
+
+inline bool
+operator!=(const RouterT::conn_iterator &i, const RouterT::conn_iterator &j)
+{
+    return i.get() != j.get();
+}
+
+inline RouterT::conn_iterator
+operator+(RouterT::conn_iterator it, int x)
+{
+    while (x-- > 0)
+	++it;
+    return it;
+}
+
+#endif