Add a helper class (APSInt) which can represent an APInt along with sign

[oota-llvm.git] / include / llvm / ADT / ilist

diff --git a/include/llvm/ADT/ilist b/include/llvm/ADT/ilist
index 7f4d2659d5f1ce4ade1bf8457758fdac4bdd0ece..1d01b63fe73647e4ca28172658bdcba6f1ab0520 100644 (file)
--- a/include/llvm/ADT/ilist
+++ b/include/llvm/ADT/ilist
@@ -1,4 +1,4 @@
-//===-- Support/ilist - Intrusive Linked List Template ----------*- C++ -*-===//
+//===-- llvm/ADT/ilist - Intrusive Linked List Template ---------*- C++ -*-===//
 // 
 //                     The LLVM Compiler Infrastructure
 //
@@ -35,10 +35,10 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef SUPPORT_ILIST
-#define SUPPORT_ILIST
+#ifndef LLVM_ADT_ILIST
+#define LLVM_ADT_ILIST
 
-#include <Support/iterator>
+#include "llvm/ADT/iterator"
 #include <cassert>
 
 namespace llvm {
@@ -58,9 +58,10 @@ struct ilist_traits {
   static void setPrev(NodeTy *N, NodeTy *Prev) { N->setPrev(Prev); }
   static void setNext(NodeTy *N, NodeTy *Next) { N->setNext(Next); }
 
-  static NodeTy *createNode() { return new NodeTy(); }
   static NodeTy *createNode(const NodeTy &V) { return new NodeTy(V); }
 
+  static NodeTy *createSentinel() { return new NodeTy(); }
+  static void destroySentinel(NodeTy *N) { delete N; }
 
   void addNodeToList(NodeTy *NTy) {}
   void removeNodeFromList(NodeTy *NTy) {}
@@ -152,15 +153,42 @@ public:
     return tmp;
   }
 
-
-  // Dummy operators to make errors apparent...
-  template<class X> void operator+(X Val) {}
-  template<class X> void operator-(X Val) {}
-
   // Internal interface, do not use...
   pointer getNodePtrUnchecked() const { return NodePtr; }
 };
 
+// do not implement. this is to catch errors when people try to use
+// them as random access iterators
+template<typename T>
+void operator-(int, ilist_iterator<T>);
+template<typename T>
+void operator-(ilist_iterator<T>,int);
+
+template<typename T>
+void operator+(int, ilist_iterator<T>);
+template<typename T>
+void operator+(ilist_iterator<T>,int);
+
+// operator!=/operator== - Allow mixed comparisons without dereferencing
+// the iterator, which could very likely be pointing to end().
+template<typename T>
+bool operator!=(const T* LHS, const ilist_iterator<const T> &RHS) {
+  return LHS != RHS.getNodePtrUnchecked();
+}
+template<typename T>
+bool operator==(const T* LHS, const ilist_iterator<const T> &RHS) {
+  return LHS == RHS.getNodePtrUnchecked();
+}
+template<typename T>
+bool operator!=(T* LHS, const ilist_iterator<T> &RHS) {
+  return LHS != RHS.getNodePtrUnchecked();
+}
+template<typename T>
+bool operator==(T* LHS, const ilist_iterator<T> &RHS) {
+  return LHS == RHS.getNodePtrUnchecked();
+}
+
+
 // Allow ilist_iterators to convert into pointers to a node automatically when
 // used by the dyn_cast, cast, isa mechanisms...
 
@@ -207,25 +235,26 @@ public:
   typedef std::reverse_iterator<const_iterator>  const_reverse_iterator;
   typedef std::reverse_iterator<iterator>  reverse_iterator;
 
-  iplist() : Head(this->createNode()), Tail(Head) {
+  iplist() : Head(Traits::createSentinel()), Tail(Head) {
     setNext(Head, 0);
     setPrev(Head, 0);
   }
-  ~iplist() { clear(); delete Tail; }
+  ~iplist() { clear(); Traits::destroySentinel(Tail); }
 
-  // Iterator creation methods...
+  // Iterator creation methods.
   iterator begin()             { return iterator(Head); }
   const_iterator begin() const { return const_iterator(Head); }
   iterator end()               { return iterator(Tail); }
   const_iterator end() const   { return const_iterator(Tail); }
 
-  // reverse iterator creation methods...
+  // reverse iterator creation methods.
   reverse_iterator rbegin()            { return reverse_iterator(end()); }
   const_reverse_iterator rbegin() const{ return const_reverse_iterator(end()); }
   reverse_iterator rend()              { return reverse_iterator(begin()); }
   const_reverse_iterator rend() const  {return const_reverse_iterator(begin());}
 
-  // Miscellaneous inspection routines...
+
+  // Miscellaneous inspection routines.
   size_type max_size() const { return size_type(-1); }
   bool empty() const { return Head == Tail; }
 
@@ -280,7 +309,7 @@ public:
       Head = NextNode;
     setPrev(NextNode, PrevNode);
     IT = NextNode;
-    removeNodeFromList(Node);  // Notify traits that we added a node...
+    removeNodeFromList(Node);  // Notify traits that we removed a node...
     return Node;
   }
 
@@ -338,13 +367,14 @@ public:
   //
 
   size_type size() const {
-#if __GNUC__ == 3
-    size_type Result = std::distance(begin(), end());
-#else
+#if __GNUC__ == 2
+    // GCC 2.95 has a broken std::distance
     size_type Result = 0;
     std::distance(begin(), end(), Result);
-#endif
     return Result;
+#else
+    return std::distance(begin(), end());
+#endif
   }
 
   iterator erase(iterator first, iterator last) {