diff -r 37117ebbabe2 -r 272a5677bd6d src/include/oldgraph.h
--- a/src/include/oldgraph.h	Thu Dec 11 07:24:53 2003 +0000
+++ b/src/include/oldgraph.h	Sat Dec 13 15:44:50 2003 +0000
@@ -111,51 +111,52 @@
  public:
   int NodeNum() {return nodenum;};
   int EdgeNum();
-  int MaxNode() {return nodes_size;};
-  int FirstNode() {return firstnode;};
-  int NextNode(int n) {return nodes[n].next;};
-  int PrevNode(int n) {return nodes[n].prev;};
-  N& operator()(int n) {return *(N*)(nodes[n].data);};
-  N& Data      (int n) {return *(N*)(nodes[n].data);};
+  int MaxNode() const {return nodes_size;};
+  int FirstNode() const {return firstnode;};
+  int NextNode(int n) const {return nodes[n].next;};
+  int PrevNode(int n) const {return nodes[n].prev;};
+  N& operator()(int n) const {return *(N*)(nodes[n].data);};
+  N& Data      (int n) const {return *(N*)(nodes[n].data);};
   int AddNode();
-  void AddNodeBlock(int n) {for(int i=0;i<n;i++) AddNode();}
+  void AddNodeBlock(int n) const {for(int i=0;i<n;i++) AddNode();}
   int AddNode(int n);
   void Delete(int n);
-  int isaNode(int n) {return n>=0&&n<nodes_size&&nodes[n].indeg!=FREE_NODE;};
+  int isaNode(int n) const 
+        {return n>=0&&n<nodes_size&&nodes[n].indeg!=FREE_NODE;};
   
-  int InDeg(int n) {return nodes[n].indeg;};
-  int OutDeg(int n) {return nodes[n].outdeg;};
-  EdgePoint FirstIn(int n) {return nodes[n].firstin;};
-  EdgePoint FirstOut(int n) {return nodes[n].firstout;};
+  int InDeg(int n) const {return nodes[n].indeg;};
+  int OutDeg(int n) const {return nodes[n].outdeg;};
+  EdgePoint FirstIn(int n) const {return nodes[n].firstin;};
+  EdgePoint FirstOut(int n) const {return nodes[n].firstout;};
 
-  E& operator()(EdgePoint e) {return *(E*)(((edge_t*)e)->data);};
-  E& Data      (EdgePoint e) {return *(E*)(((edge_t*)e)->data);};
-  int From(EdgePoint e) {return e->from;};
-  int To(EdgePoint e) {return e->to;};
-  EdgePoint NextIn(EdgePoint e)
+  E& operator()(EdgePoint e) const {return *(E*)(((edge_t*)e)->data);};
+  E& Data      (EdgePoint e) const {return *(E*)(((edge_t*)e)->data);};
+  int From(EdgePoint e) const {return e->from;};
+  int To(EdgePoint e) const {return e->to;};
+  EdgePoint NextIn(EdgePoint e) const 
     {return e->nextin;};
-  EdgePoint NextOut(EdgePoint e)
+  EdgePoint NextOut(EdgePoint e)const 
     {return e->nextout;};
   EdgePoint AddEdge(int f, int t);
   void Delete(EdgePoint e);
   EdgePoint Edge(int f,int t);
   //  EdgePoint Edge(E &d)
   //    {return (EdgePoint)(((char*)&d)-(char*)&(((edge_t*)NULL)->data));};
-  E& operator()(int f, int t) {return *(E*)(((edge_t*)Edge(f,t))->data);};
-  E& Data(int f, int t) {return *(E*)(((edge_t*)Edge(f,t))->data);};
+  E& operator()(int f, int t) const {return *(E*)(((edge_t*)Edge(f,t))->data);};
+  E& Data(int f, int t) const {return *(E*)(((edge_t*)Edge(f,t))->data);};
   void Delete(int f, int t) {Delete(Edge(f,t));};
   void Reverse(EdgePoint e);
 
   // Functions for EdgeIndex
   
-  EdgePoint Edge(EdgeIndex i)
+  EdgePoint Edge(EdgeIndex i) const 
     { return (EdgePoint)(edges[i.block]->fields+i.index);};
-  EdgeIndex Index(EdgePoint e) { return e->index;};
-  EdgeIndex Index(int f, int t) { EdgePoint e; return Edge(f,t)->index; }
+  EdgeIndex Index(EdgePoint e) const { return e->index;};
+  EdgeIndex Index(int f, int t) const { EdgePoint e; return Edge(f,t)->index; }
   void Delete(EdgeIndex i) { Delete(Edge(i));};
-  E& operator()(EdgeIndex i)
+  E& operator()(EdgeIndex i) const 
      {return *(E*)(edges[i.block]->fields[i.index].data);};
-  E& Data(EdgeIndex i)
+  E& Data(EdgeIndex i) const 
      {return *(E*)(edges[i.block]->fields[i.index].data);};
   EdgePoint AddEdge(int f, int t,EdgeIndex in);
   
@@ -163,11 +164,11 @@
   
   // Operators for symmetric graphs:
 
-  EdgePoint FirstEdge(int n)
+  EdgePoint FirstEdge(int n) const 
     { return (EdgePoint)(FirstIn(n)?FirstIn(n):FirstOut(n));};
-  EdgePoint NextEdge(int n,EdgePoint e)
+  EdgePoint NextEdge(int n,EdgePoint e) const 
     { return From(e)==n?NextOut(e):(NextIn(e)?NextIn(e):FirstOut(n)); };
-  int Opposite(EdgePoint e,int n)
+  int Opposite(EdgePoint e,int n) const 
     { return From(e)+To(e)-n; };
   
   // Initializers, destructors
@@ -222,7 +223,6 @@
 
 template<class N, class E> void OldGraph<N,E>::destroy()
 {
-  edge_block *oe;
   int i;
   
   while(firstnode!=INVALID) Delete(firstnode);