summaryrefslogtreecommitdiffstatshomepage
path: root/src/emu/netlist/nl_lists.h
diff options
context:
space:
mode:
Diffstat (limited to 'src/emu/netlist/nl_lists.h')
-rw-r--r--src/emu/netlist/nl_lists.h596
1 files changed, 298 insertions, 298 deletions
diff --git a/src/emu/netlist/nl_lists.h b/src/emu/netlist/nl_lists.h
index 685081d941a..0de20ea55ab 100644
--- a/src/emu/netlist/nl_lists.h
+++ b/src/emu/netlist/nl_lists.h
@@ -22,133 +22,133 @@ class netlist_list_t
{
public:
- ATTR_COLD netlist_list_t(int numElements = _NumElem)
- {
- m_num_elements = numElements;
- m_list = new _ListClass[m_num_elements];
- m_count = 0;
- }
-
- ATTR_COLD netlist_list_t(const netlist_list_t &rhs)
- {
- m_num_elements = rhs.capacity();
- m_list = new _ListClass[m_num_elements];
- m_count = 0;
- for (int i=0; i<rhs.count(); i++)
- {
- this->add(rhs[i]);
- }
- }
-
- ATTR_COLD netlist_list_t &operator=(const netlist_list_t &rhs)
- {
- this->reset();
- for (int i=0; i<rhs.count(); i++)
- {
- this->add(rhs[i]);
- }
- return *this;
- }
-
-
- ATTR_COLD ~netlist_list_t()
- {
- delete[] m_list;
- }
-
- ATTR_HOT inline void add(const _ListClass &elem)
- {
- if (m_count >= m_num_elements)
- resize(m_num_elements * 2);
-
- m_list[m_count++] = elem;
- }
-
- ATTR_HOT inline void resize(const int new_size)
- {
- int cnt = count();
- _ListClass *m_new = new _ListClass[new_size];
- _ListClass *pd = m_new;
-
- for (_ListClass *ps = m_list; ps < m_list + cnt; ps++, pd++)
- *pd = *ps;
- delete[] m_list;
- m_list = m_new;
- m_count = cnt;
- m_num_elements = new_size;
- }
-
- ATTR_HOT inline void remove(const _ListClass &elem)
- {
- for (int i = 0; i < m_count; i++)
- {
- if (m_list[i] == elem)
- {
- m_count --;
- while (i < m_count)
- {
- m_list[i] = m_list[i+1];
- i++;
- }
- return;
- }
- }
- }
-
- ATTR_HOT inline void remove_at(const int pos)
- {
- assert((pos>=0) && (pos<m_count));
- m_count--;
- for (int i = pos; i < m_count; i++)
- {
- m_list[i] = m_list[i+1];
- }
- }
-
- ATTR_HOT inline bool contains(const _ListClass &elem) const
- {
- for (_ListClass *i = m_list; i < m_list + m_count; i++)
- {
- if (*i == elem)
- return true;
- }
- return false;
- }
-
- ATTR_HOT inline int indexof(const _ListClass &elem) const
- {
- for (int i = 0; i < m_count; i++)
- {
- if (m_list[i] == elem)
- return i;
- }
- return -1;
- }
-
- ATTR_HOT inline const _ListClass *first() const { return ((m_count > 0) ? &m_list[0] : NULL ); }
- ATTR_HOT inline const _ListClass *next(const _ListClass *lc) const { return ((lc < last()) ? lc + 1 : NULL ); }
- ATTR_HOT inline const _ListClass *last() const { return &m_list[m_count -1]; }
- ATTR_HOT inline int count() const { return m_count; }
- ATTR_HOT inline bool empty() const { return (m_count == 0); }
- ATTR_HOT inline void clear() { m_count = 0; }
- ATTR_HOT inline int capacity() const { return m_num_elements; }
-
- ATTR_COLD void clear_and_free()
- {
- for (_ListClass *i = m_list; i < m_list + m_count; i++)
- {
- delete *i;
- }
- clear();
- }
-
- ATTR_HOT inline _ListClass& operator[](const int & index) { return m_list[index]; }
- ATTR_HOT inline const _ListClass& operator[](const int & index) const { return m_list[index]; }
+ ATTR_COLD netlist_list_t(int numElements = _NumElem)
+ {
+ m_num_elements = numElements;
+ m_list = new _ListClass[m_num_elements];
+ m_count = 0;
+ }
+
+ ATTR_COLD netlist_list_t(const netlist_list_t &rhs)
+ {
+ m_num_elements = rhs.capacity();
+ m_list = new _ListClass[m_num_elements];
+ m_count = 0;
+ for (int i=0; i<rhs.count(); i++)
+ {
+ this->add(rhs[i]);
+ }
+ }
+
+ ATTR_COLD netlist_list_t &operator=(const netlist_list_t &rhs)
+ {
+ this->reset();
+ for (int i=0; i<rhs.count(); i++)
+ {
+ this->add(rhs[i]);
+ }
+ return *this;
+ }
+
+
+ ATTR_COLD ~netlist_list_t()
+ {
+ delete[] m_list;
+ }
+
+ ATTR_HOT inline void add(const _ListClass &elem)
+ {
+ if (m_count >= m_num_elements)
+ resize(m_num_elements * 2);
+
+ m_list[m_count++] = elem;
+ }
+
+ ATTR_HOT inline void resize(const int new_size)
+ {
+ int cnt = count();
+ _ListClass *m_new = new _ListClass[new_size];
+ _ListClass *pd = m_new;
+
+ for (_ListClass *ps = m_list; ps < m_list + cnt; ps++, pd++)
+ *pd = *ps;
+ delete[] m_list;
+ m_list = m_new;
+ m_count = cnt;
+ m_num_elements = new_size;
+ }
+
+ ATTR_HOT inline void remove(const _ListClass &elem)
+ {
+ for (int i = 0; i < m_count; i++)
+ {
+ if (m_list[i] == elem)
+ {
+ m_count --;
+ while (i < m_count)
+ {
+ m_list[i] = m_list[i+1];
+ i++;
+ }
+ return;
+ }
+ }
+ }
+
+ ATTR_HOT inline void remove_at(const int pos)
+ {
+ assert((pos>=0) && (pos<m_count));
+ m_count--;
+ for (int i = pos; i < m_count; i++)
+ {
+ m_list[i] = m_list[i+1];
+ }
+ }
+
+ ATTR_HOT inline bool contains(const _ListClass &elem) const
+ {
+ for (_ListClass *i = m_list; i < m_list + m_count; i++)
+ {
+ if (*i == elem)
+ return true;
+ }
+ return false;
+ }
+
+ ATTR_HOT inline int indexof(const _ListClass &elem) const
+ {
+ for (int i = 0; i < m_count; i++)
+ {
+ if (m_list[i] == elem)
+ return i;
+ }
+ return -1;
+ }
+
+ ATTR_HOT inline const _ListClass *first() const { return ((m_count > 0) ? &m_list[0] : NULL ); }
+ ATTR_HOT inline const _ListClass *next(const _ListClass *lc) const { return ((lc < last()) ? lc + 1 : NULL ); }
+ ATTR_HOT inline const _ListClass *last() const { return &m_list[m_count -1]; }
+ ATTR_HOT inline int count() const { return m_count; }
+ ATTR_HOT inline bool empty() const { return (m_count == 0); }
+ ATTR_HOT inline void clear() { m_count = 0; }
+ ATTR_HOT inline int capacity() const { return m_num_elements; }
+
+ ATTR_COLD void clear_and_free()
+ {
+ for (_ListClass *i = m_list; i < m_list + m_count; i++)
+ {
+ delete *i;
+ }
+ clear();
+ }
+
+ ATTR_HOT inline _ListClass& operator[](const int & index) { return m_list[index]; }
+ ATTR_HOT inline const _ListClass& operator[](const int & index) const { return m_list[index]; }
private:
- int m_count;
- _ListClass * m_list;
- int m_num_elements;
+ int m_count;
+ _ListClass * m_list;
+ int m_num_elements;
};
// ----------------------------------------------------------------------------------------
@@ -158,81 +158,81 @@ private:
template <class _Element, class _Time, int _Size>
class netlist_timed_queue
{
- NETLIST_PREVENT_COPYING(netlist_timed_queue)
+ NETLIST_PREVENT_COPYING(netlist_timed_queue)
public:
- class entry_t
- {
- public:
- ATTR_HOT inline entry_t()
- : m_exec_time(), m_object() {}
- ATTR_HOT inline entry_t(const _Time atime, const _Element elem) : m_exec_time(atime), m_object(elem) {}
- ATTR_HOT inline const _Time exec_time() const { return m_exec_time; }
- ATTR_HOT inline const _Element object() const { return m_object; }
-
- private:
- _Time m_exec_time;
- _Element m_object;
- };
-
- netlist_timed_queue()
- {
- //m_list = global_alloc_array(entry_t, SIZE);
- clear();
- }
-
- ATTR_HOT inline int capacity() const { return _Size; }
- ATTR_HOT inline bool is_empty() const { return (m_end == &m_list[0]); }
- ATTR_HOT inline bool is_not_empty() const { return (m_end > &m_list[0]); }
-
- ATTR_HOT ATTR_ALIGN void push(const entry_t &e)
- {
- entry_t * i = m_end++;
- const _Time e_time = e.exec_time();
- while ((i > &m_list[0]) && (e_time > (i - 1)->exec_time()) )
- {
- *(i) = *(i-1);
- i--;
- inc_stat(m_prof_sortmove);
- }
- *i = e;
- inc_stat(m_prof_sort);
- assert(m_end - m_list < _Size);
- }
-
- ATTR_HOT inline const entry_t *pop()
- {
- return --m_end;
- }
-
- ATTR_HOT inline const entry_t *peek() const
- {
- return (m_end-1);
- }
-
- ATTR_COLD void clear()
- {
- m_end = &m_list[0];
- }
-
- // save state support & mame disasm
-
- ATTR_COLD inline const entry_t *listptr() const { return &m_list[0]; }
- ATTR_HOT inline int count() const { return m_end - m_list; }
- ATTR_HOT inline const entry_t & operator[](const int & index) const { return m_list[index]; }
+ class entry_t
+ {
+ public:
+ ATTR_HOT inline entry_t()
+ : m_exec_time(), m_object() {}
+ ATTR_HOT inline entry_t(const _Time atime, const _Element elem) : m_exec_time(atime), m_object(elem) {}
+ ATTR_HOT inline const _Time exec_time() const { return m_exec_time; }
+ ATTR_HOT inline const _Element object() const { return m_object; }
+
+ private:
+ _Time m_exec_time;
+ _Element m_object;
+ };
+
+ netlist_timed_queue()
+ {
+ //m_list = global_alloc_array(entry_t, SIZE);
+ clear();
+ }
+
+ ATTR_HOT inline int capacity() const { return _Size; }
+ ATTR_HOT inline bool is_empty() const { return (m_end == &m_list[0]); }
+ ATTR_HOT inline bool is_not_empty() const { return (m_end > &m_list[0]); }
+
+ ATTR_HOT ATTR_ALIGN void push(const entry_t &e)
+ {
+ entry_t * i = m_end++;
+ const _Time e_time = e.exec_time();
+ while ((i > &m_list[0]) && (e_time > (i - 1)->exec_time()) )
+ {
+ *(i) = *(i-1);
+ i--;
+ inc_stat(m_prof_sortmove);
+ }
+ *i = e;
+ inc_stat(m_prof_sort);
+ assert(m_end - m_list < _Size);
+ }
+
+ ATTR_HOT inline const entry_t *pop()
+ {
+ return --m_end;
+ }
+
+ ATTR_HOT inline const entry_t *peek() const
+ {
+ return (m_end-1);
+ }
+
+ ATTR_COLD void clear()
+ {
+ m_end = &m_list[0];
+ }
+
+ // save state support & mame disasm
+
+ ATTR_COLD inline const entry_t *listptr() const { return &m_list[0]; }
+ ATTR_HOT inline int count() const { return m_end - m_list; }
+ ATTR_HOT inline const entry_t & operator[](const int & index) const { return m_list[index]; }
#if (NL_KEEP_STATISTICS)
- // profiling
- INT32 m_prof_start;
- INT32 m_prof_end;
- INT32 m_prof_sortmove;
- INT32 m_prof_sort;
+ // profiling
+ INT32 m_prof_start;
+ INT32 m_prof_end;
+ INT32 m_prof_sortmove;
+ INT32 m_prof_sort;
#endif
private:
- entry_t * m_end;
- entry_t m_list[_Size];
+ entry_t * m_end;
+ entry_t m_list[_Size];
};
@@ -246,58 +246,58 @@ class netlist_stack_t
{
public:
- ATTR_COLD netlist_stack_t(int numElements = _NumElem)
- : m_list(numElements)
- {
- }
-
- ATTR_COLD netlist_stack_t(const netlist_stack_t &rhs)
- : m_list(rhs.m_list)
- {
- }
-
- ATTR_COLD netlist_stack_t &operator=(const netlist_stack_t &rhs)
- {
- m_list = rhs.m_list;
- return *this;
- }
-
-
- ATTR_COLD ~netlist_stack_t()
- {
- }
-
- ATTR_HOT inline void push(const _StackClass &elem)
- {
- m_list.add(elem);
- }
-
- ATTR_HOT inline _StackClass peek() const
- {
- return m_list[m_list.count() - 1];
- }
-
- ATTR_HOT inline _StackClass pop()
- {
- _StackClass ret = peek();
- m_list.remove_at(m_list.count() - 1);
- return ret;
- }
-
- ATTR_HOT inline int count() const { return m_list.count(); }
- ATTR_HOT inline bool empty() const { return (m_list.count() == 0); }
- ATTR_HOT inline void reset() { m_list.reset(); }
- ATTR_HOT inline int capacity() const { return m_list.capacity(); }
+ ATTR_COLD netlist_stack_t(int numElements = _NumElem)
+ : m_list(numElements)
+ {
+ }
+
+ ATTR_COLD netlist_stack_t(const netlist_stack_t &rhs)
+ : m_list(rhs.m_list)
+ {
+ }
+
+ ATTR_COLD netlist_stack_t &operator=(const netlist_stack_t &rhs)
+ {
+ m_list = rhs.m_list;
+ return *this;
+ }
+
+
+ ATTR_COLD ~netlist_stack_t()
+ {
+ }
+
+ ATTR_HOT inline void push(const _StackClass &elem)
+ {
+ m_list.add(elem);
+ }
+
+ ATTR_HOT inline _StackClass peek() const
+ {
+ return m_list[m_list.count() - 1];
+ }
+
+ ATTR_HOT inline _StackClass pop()
+ {
+ _StackClass ret = peek();
+ m_list.remove_at(m_list.count() - 1);
+ return ret;
+ }
+
+ ATTR_HOT inline int count() const { return m_list.count(); }
+ ATTR_HOT inline bool empty() const { return (m_list.count() == 0); }
+ ATTR_HOT inline void reset() { m_list.reset(); }
+ ATTR_HOT inline int capacity() const { return m_list.capacity(); }
private:
- netlist_list_t<_StackClass, _NumElem> m_list;
+ netlist_list_t<_StackClass, _NumElem> m_list;
};
template <class _ListClass>
struct plinked_list_element
{
- plinked_list_element() : m_next(NULL) {}
- _ListClass * m_next;
+ plinked_list_element() : m_next(NULL) {}
+ _ListClass * m_next;
};
@@ -306,69 +306,69 @@ class plinked_list
{
public:
- plinked_list() : m_head(NULL) {}
-
- ATTR_HOT inline void insert(const _ListClass &before, _ListClass &elem)
- {
- if (m_head == &before)
- {
- elem.m_next = m_head;
- m_head = elem;
- }
- else
- {
- _ListClass *p = m_head;
- while (p != NULL)
- {
- if (p->m_next == &before)
- {
- elem->m_next = &before;
- p->m_next = &elem;
- return;
- }
- p = p->m_next;
- }
- assert_always(false, "element not found");
- }
- }
-
- ATTR_HOT inline void insert(_ListClass &elem)
- {
- elem.m_next = m_head;
- m_head = &elem;
- }
-
- ATTR_HOT inline void add(_ListClass &elem)
- {
- _ListClass **p = &m_head;
- while (*p != NULL)
- {
- p = &((*p)->m_next);
- }
- *p = &elem;
- elem.m_next = NULL;
- }
-
- ATTR_HOT inline void remove(const _ListClass &elem)
- {
- _ListClass **p = &m_head;
- while (*p != &elem)
- {
- assert(*p != NULL);
- p = &((*p)->m_next);
- }
- (*p) = elem.m_next;
- }
-
-
- ATTR_HOT static inline _ListClass *next(const _ListClass &elem) { return elem.m_next; }
- ATTR_HOT static inline _ListClass *next(const _ListClass *elem) { return elem->m_next; }
- ATTR_HOT inline _ListClass *first() const { return m_head; }
- ATTR_HOT inline void clear() { m_head = NULL; }
- ATTR_HOT inline bool is_empty() const { return (m_head == NULL); }
+ plinked_list() : m_head(NULL) {}
+
+ ATTR_HOT inline void insert(const _ListClass &before, _ListClass &elem)
+ {
+ if (m_head == &before)
+ {
+ elem.m_next = m_head;
+ m_head = elem;
+ }
+ else
+ {
+ _ListClass *p = m_head;
+ while (p != NULL)
+ {
+ if (p->m_next == &before)
+ {
+ elem->m_next = &before;
+ p->m_next = &elem;
+ return;
+ }
+ p = p->m_next;
+ }
+ assert_always(false, "element not found");
+ }
+ }
+
+ ATTR_HOT inline void insert(_ListClass &elem)
+ {
+ elem.m_next = m_head;
+ m_head = &elem;
+ }
+
+ ATTR_HOT inline void add(_ListClass &elem)
+ {
+ _ListClass **p = &m_head;
+ while (*p != NULL)
+ {
+ p = &((*p)->m_next);
+ }
+ *p = &elem;
+ elem.m_next = NULL;
+ }
+
+ ATTR_HOT inline void remove(const _ListClass &elem)
+ {
+ _ListClass **p = &m_head;
+ while (*p != &elem)
+ {
+ assert(*p != NULL);
+ p = &((*p)->m_next);
+ }
+ (*p) = elem.m_next;
+ }
+
+
+ ATTR_HOT static inline _ListClass *next(const _ListClass &elem) { return elem.m_next; }
+ ATTR_HOT static inline _ListClass *next(const _ListClass *elem) { return elem->m_next; }
+ ATTR_HOT inline _ListClass *first() const { return m_head; }
+ ATTR_HOT inline void clear() { m_head = NULL; }
+ ATTR_HOT inline bool is_empty() const { return (m_head == NULL); }
private:
- _ListClass *m_head;
+ _ListClass *m_head;
};
#endif /* NLLISTS_H_ */