Remove common/queue.h
authorTom Tromey <tom@tromey.com>
Sun, 7 Apr 2019 22:32:54 +0000 (16:32 -0600)
committerTom Tromey <tom@tromey.com>
Fri, 19 Apr 2019 20:29:34 +0000 (14:29 -0600)
gdb no longer needs common/queue.h, so this removes it.

gdb/ChangeLog
2019-04-19  Tom Tromey  <tom@tromey.com>

* common/queue.h: Remove.

gdb/ChangeLog
gdb/common/queue.h [deleted file]

index 67ba8b1..80f18cd 100644 (file)
@@ -1,5 +1,9 @@
 2019-04-19  Tom Tromey  <tom@tromey.com>
 
+       * common/queue.h: Remove.
+
+2019-04-19  Tom Tromey  <tom@tromey.com>
+
        * event-loop.c: Don't include "common/queue.h".
 
 2019-04-19  Tom Tromey  <tom@tromey.com>
diff --git a/gdb/common/queue.h b/gdb/common/queue.h
deleted file mode 100644 (file)
index 3bc9c7e..0000000
+++ /dev/null
@@ -1,298 +0,0 @@
-/* General queue data structure for GDB, the GNU debugger.
-
-   Copyright (C) 2012-2019 Free Software Foundation, Inc.
-
-   This file is part of GDB.
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 3 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
-
-#ifndef COMMON_QUEUE_H
-#define COMMON_QUEUE_H
-
-/* These macros implement functions and structs for a general queue.
-   Macro 'DEFINE_QUEUE_P(TYPEDEF)' is to define the new queue type for
-   TYPEDEF', and macro 'DECLARE_QUEUE_P' is to declare external queue
-   APIs.  The character P indicates TYPEDEF is a pointer (P).  The
-   counterpart on object (O) and integer (I) are not implemented.
-
-   An example of their use would be,
-
-   typedef struct foo
-   {} *foo_p;
-
-   DEFINE_QUEUE_P (foo_p);
-   // A pointer to a queue of foo pointers.  FOO_XFREE is a destructor
-   // function for foo instances in queue.
-   QUEUE(foo_p) *foo_queue = QUEUE_alloc (foo_p, foo_xfree);
-
-   foo_p foo_var_p;
-   // Enqueue and Dequeue
-   QUEUE_enque (foo_p, foo_queue, foo_var_p);
-   foo_var_p = QUEUE_deque (foo_p, foo_queue);
-
-   static int visit_foo (QUEUE (foo_p) *q, QUEUE_ITER (foo_p) *iter,
-                       foo_p f, void *data)
-   {
-     return 1;
-   }
-   // Iterate over queue.
-   QUEUE_iterate (foo_p, foo_queue, visit_foo, &param);
-
-   QUEUE_free (foo_p, foo_queue);  // Free queue.  */
-
-/* Typical enqueue operation.  Put V into queue Q.  */
-#define QUEUE_enque(TYPE, Q, V) queue_ ## TYPE ## _enque ((Q), (V))
-
-/* Typical dequeue operation.  Return head element of queue Q and
-   remove it.  Q must not be empty.  */
-#define QUEUE_deque(TYPE, Q) queue_ ## TYPE ## _deque (Q)
-
-/* Return the head element, but don't remove it from the queue.
-   Q must not be empty.  */
-#define QUEUE_peek(TYPE, Q) queue_ ## TYPE ## _peek (Q)
-
-/* Return true if queue Q is empty.  */
-#define QUEUE_is_empty(TYPE, Q) queue_ ## TYPE ## _is_empty (Q)
-
-/* Allocate memory for queue.  FREE_FUNC is a function to release the
-   data put in each queue element.  */
-#define QUEUE_alloc(TYPE, FREE_FUNC) queue_ ## TYPE ## _alloc (FREE_FUNC)
-
-/* Length of queue Q.  */
-#define QUEUE_length(TYPE, Q) queue_ ## TYPE ## _length (Q)
-
-/* Free queue Q.  Q's free_func is called once for each element.  */
-#define QUEUE_free(TYPE, Q) queue_ ## TYPE ## _free (Q)
-
-/* Iterate over elements in the queue Q and call function OPERATE on
-   each element.  It is allowed to remove element by OPERATE.  OPERATE
-   returns false to terminate the iteration and true to continue the
-   iteration.  Return false if iteration is terminated by function
-   OPERATE, otherwise return true.  */
-#define QUEUE_iterate(TYPE, Q, OPERATE, PARAM) \
-  queue_ ## TYPE ## _iterate ((Q), (OPERATE), (PARAM))
-
-/* Remove the element per the state of iterator ITER from queue Q.
-   Leave the caller to release the data in the queue element.  */
-#define QUEUE_remove_elem(TYPE, Q, ITER) \
-  queue_ ## TYPE ## _remove_elem ((Q), (ITER))
-
-/* Define a new queue implementation.  */
-
-#define QUEUE(TYPE) struct queue_ ## TYPE
-#define QUEUE_ELEM(TYPE) struct queue_elem_ ## TYPE
-#define QUEUE_ITER(TYPE) struct queue_iter_ ## TYPE
-#define QUEUE_ITER_FUNC(TYPE) queue_ ## TYPE ## _operate_func
-
-#define DEFINE_QUEUE_P(TYPE)                   \
-QUEUE_ELEM (TYPE)                              \
-{                                              \
-  QUEUE_ELEM (TYPE) *next;                     \
-                                               \
-  TYPE data;                                   \
-};                                             \
-                                               \
-/* Queue iterator.  */                         \
-QUEUE_ITER (TYPE)                              \
-{                                              \
-  /* The current element during traverse.  */  \
-  QUEUE_ELEM (TYPE) *p;                        \
-  /* The previous element of P.  */            \
-  QUEUE_ELEM (TYPE) *prev;                     \
-};                                             \
-                                               \
-QUEUE(TYPE)                                    \
-{                                              \
-  /*  The head and tail of the queue.  */      \
-  QUEUE_ELEM (TYPE) *head;                     \
-  QUEUE_ELEM (TYPE) *tail;                     \
-  /* Function to release the data put in each  \
-     queue element.  */                        \
-  void (*free_func) (TYPE);                    \
-};                                             \
-                                               \
-void                                                                   \
-queue_ ## TYPE ## _enque (QUEUE (TYPE) *q, TYPE v)                     \
-{                                                                      \
-  QUEUE_ELEM (TYPE) *p = XNEW (QUEUE_ELEM (TYPE));                     \
-                                                                       \
-  gdb_assert (q != NULL);                                              \
-  p->data = v;                                                         \
-  p->next = NULL;                                                      \
-  if (q->tail == NULL)                                                 \
-    {                                                                  \
-      q->tail = p;                                                     \
-      q->head = p;                                                     \
-    }                                                                  \
-  else                                                                 \
-    {                                                                  \
-      q->tail->next = p;                                               \
-      q->tail = p;                                                     \
-    }                                                                  \
-}                                                                      \
-                                                                       \
-TYPE                                                                   \
-queue_ ## TYPE ## _deque (QUEUE (TYPE) *q)                             \
-{                                                                      \
-  QUEUE_ELEM (TYPE) *p;                                                \
-  TYPE v;                                                              \
-                                                                       \
-  gdb_assert (q != NULL);                                              \
-  p = q->head;                                                         \
-  gdb_assert (p != NULL);                                              \
-                                                                       \
-  if (q->head == q->tail)                                              \
-    {                                                                  \
-      q->head = NULL;                                                  \
-      q->tail = NULL;                                                  \
-    }                                                                  \
-  else                                                                 \
-    q->head = q->head->next;                                           \
-                                                                       \
-  v = p->data;                                                         \
-                                                                       \
-  xfree (p);                                                           \
-  return v;                                                            \
-}                                                                      \
-                                                                       \
-TYPE                                                                   \
-queue_ ## TYPE ## _peek (QUEUE (TYPE) *q)                              \
-{                                                                      \
-  gdb_assert (q != NULL);                                              \
-  gdb_assert (q->head != NULL);                                        \
-  return q->head->data;                                                \
-}                                                                      \
-                                                                       \
-int                                                                    \
-queue_ ## TYPE ## _is_empty (QUEUE (TYPE) *q)                          \
-{                                                                      \
-  gdb_assert (q != NULL);                                              \
-  return q->head == NULL;                                              \
-}                                                                      \
-                                                                       \
-void                                                                   \
-queue_ ## TYPE ## _remove_elem (QUEUE (TYPE) *q,                       \
-                               QUEUE_ITER (TYPE) *iter)                \
-{                                                                      \
-  gdb_assert (q != NULL);                                              \
-  gdb_assert (iter != NULL && iter->p != NULL);                        \
-                                                                       \
-  if (iter->p == q->head || iter->p == q->tail)                        \
-    {                                                                  \
-      if (iter->p == q->head)                                          \
-       q->head = iter->p->next;                                        \
-      if (iter->p == q->tail)                                          \
-       q->tail = iter->prev;                                           \
-    }                                                                  \
-  else                                                                 \
-    iter->prev->next = iter->p->next;                                  \
-                                                                       \
-  xfree (iter->p);                                                     \
-  /* Indicate that ITER->p has been deleted from QUEUE q.  */          \
-  iter->p = NULL;                                                      \
-}                                                                      \
-                                                                       \
-int                                                                    \
-queue_ ## TYPE ## _iterate (QUEUE (TYPE) *q,                           \
-                           QUEUE_ITER_FUNC (TYPE) operate,             \
-                           void *data)                         \
-{                                                                      \
-  QUEUE_ELEM (TYPE) *next = NULL;                                      \
-  QUEUE_ITER (TYPE) iter = { NULL, NULL };                             \
-                                                                       \
-  gdb_assert (q != NULL);                                              \
-                                                                       \
-  for (iter.p = q->head; iter.p != NULL; iter.p = next)                \
-    {                                                                  \
-      next = iter.p->next;                                             \
-      if (!operate (q, &iter, iter.p->data, data))                     \
-       return 0;                                                       \
-      /* ITER.P was not deleted by function OPERATE.  */               \
-      if (iter.p != NULL)                                              \
-       iter.prev = iter.p;                                             \
-    }                                                                  \
-  return 1;                                                            \
-}                                                                      \
-                                                                       \
-QUEUE (TYPE) *                                                         \
-queue_ ## TYPE ## _alloc (void (*free_func) (TYPE))                    \
-{                                                                      \
-  QUEUE (TYPE) *q = XNEW (QUEUE (TYPE));                               \
-                                                                       \
-  q->head = NULL;                                                      \
-  q->tail = NULL;                                                      \
-  q->free_func = free_func;                                            \
-  return q;                                                            \
-}                                                                      \
-                                                                       \
-int                                                                    \
-queue_ ## TYPE ## _length (QUEUE (TYPE) *q)                            \
-{                                                                      \
-  QUEUE_ELEM (TYPE) *p;                                                \
-  int len = 0;                                                         \
-                                                                       \
-  gdb_assert (q != NULL);                                              \
-                                                                       \
-  for (p = q->head; p != NULL; p = p->next)                            \
-    len++;                                                             \
-                                                                       \
-  return len;                                                          \
-}                                                                      \
-                                                                       \
-void                                                                   \
-queue_ ## TYPE ## _free (QUEUE (TYPE) *q)                              \
-{                                                                      \
-  QUEUE_ELEM (TYPE) *p, *next;                                         \
-                                                                       \
-  gdb_assert (q != NULL);                                              \
-                                                                       \
-  for (p = q->head; p != NULL; p = next)                               \
-    {                                                                  \
-      next = p->next;                                                  \
-      if (q->free_func)                                                \
-       q->free_func (p->data);                                 \
-      xfree (p);                                                       \
-    }                                                                  \
-  xfree (q);                                                           \
-}                                                                      \
-
-/* External declarations for queue functions.  */
-#define DECLARE_QUEUE_P(TYPE)                                  \
-QUEUE (TYPE);                                                  \
-QUEUE_ELEM (TYPE);                                             \
-QUEUE_ITER (TYPE);                                             \
-extern void                                                    \
-  queue_ ## TYPE ## _enque (QUEUE (TYPE) *q, TYPE v);          \
-extern TYPE                                                    \
-  queue_ ## TYPE ## _deque (QUEUE (TYPE) *q);                  \
-extern int queue_ ## TYPE ## _is_empty (QUEUE (TYPE) *q);      \
-extern QUEUE (TYPE) *                                          \
-  queue_ ## TYPE ## _alloc (void (*free_func) (TYPE));         \
-extern int queue_ ## TYPE ## _length (QUEUE (TYPE) *q);        \
-extern TYPE                                                    \
-  queue_ ## TYPE ## _peek (QUEUE (TYPE) *q);                   \
-extern void queue_ ## TYPE ## _free (QUEUE (TYPE) *q);         \
-typedef int QUEUE_ITER_FUNC(TYPE) (QUEUE (TYPE) *,             \
-                                  QUEUE_ITER (TYPE) *, \
-                                  TYPE,                        \
-                                  void *);                     \
-extern int                                                     \
-  queue_ ## TYPE ## _iterate (QUEUE (TYPE) *q,                 \
-                             QUEUE_ITER_FUNC (TYPE) operate,   \
-                             void *);                          \
-extern void                                                    \
-  queue_ ## TYPE ## _remove_elem (QUEUE (TYPE) *q,             \
-                                 QUEUE_ITER (TYPE) *iter);     \
-
-#endif /* COMMON_QUEUE_H */