typedef struct ObjListNode {
                           OBJECT Object;
                           ObjListNode* next;
                           ObjListNode* prev;
                           } OBJECT_LISTNODE;

 /************************************************
 * FUNCTION:  ObjRemove                          *
 *                                               *
 * Removes an node from a linked list of         *
 * object structures, returns pointer to the     *
 * next node                                     *
 *                                               *
 ************************************************/
 OBJECT_LISTNODE *ObjRemove(OBJECT_LISTNODE *Node)
   {
   OBJECT_LISTNODE *NextNode = Node->next;
   if(Node->prev == NULL)          
      // node is at start of list      
      {
      Node->next->prev = NULL;
      }
   else
      // node is anywhere else in list                            
      {
      Node->prev->next = Node->next;
      Node->next->prev = Node->prev;
      }
   free(Node);
   return NextNode;
   }        

// CALLED FROM HERE
Node = /* the head of some linked list */
while(Node->next != NULL)
   {
   if( /* some condition is met */ )
      {
      Node = ObjRemove(Node);
      }
   else
      {
      Node = Node->next;
      }
   }

Any advice would be greatly appreciated

--
Don Halloran

What do you mean by "my program exits when the free() function is
called"?  If it crashes or never returns from free (e.g., it doesn't
execute a fprintf(stderr,"after free\n") immediately following the
free()), then you probably corrupted the dynamic allocation mechanism
by writing outside the object you allocated or by giving free a
pointer that wasn't returned by malloc (or related function).

Did you malloc the correct size of node?  Are you trying to free
a node that was not allocated by free?

Are you sure that the linked list is set up correctly before you
remove elements?  And that it's still OK afterward, with no free?
Write a test program that explicitly allocates and initializes
a short linked list, and write a debug routine that prints out
each allocated node (using %p for pointers); delete nodes (without
free) and call the debug routine after each node deletion.

--
MJSR

Sent via Deja.com http://www.deja.com/
Before you buy.

...
[rest of code snipped]

Except for the fact that you're not freeing the last node in the list, the
code looks okay to me.  I was about to write that the code fails when
Node->next == NULL, but then I saw that you don't remove that last node.
I suspect that whatever is causing the failure is somewhere else in the
program, in code you haven't shown us.  I suggest stepping through this part
of the code with a de{*filter*}, if you have one available.  Barring that, try
to post a minimal complete program that displays the problem.

--

Kenan Systems Corp., a wholly-owned subsidiary of Lucent Technologies

Stephen

Hmm.  Yes, I should have noticed that.  Probably didn't because
of my lamentable failure to use square roots in my programs.

--
MJSR

Sent via Deja.com http://www.deja.com/
Before you buy.

   if(Node->prev == NULL)          
      // node is at start of list      
      {
      Node->next->prev = NULL;
      }

The problem here is that when I free(Node), the pointer to the start of
the list is now pointing to memory that I have freed. I solved it by
changing the ObjRemove function to:

 OBJECT_LISTNODE *ObjRemove(OBJECT_LISTNODE *Node,
                            OBJECT_LISTNODE **ListHead)
   {
   OBJECT_LISTNODE *NextNode = Node->next;
   if(Node->prev == NULL)          
      // case where node is at start of list    
      {
      Node->next->prev = NULL;
      *ListHead = Node->next;
      }
   else
      // case where node is anywhere else in list                    
      {
      Node->prev->next = Node->next;
      Node->next->prev = Node->prev;
      }
   free(Node);
   return NextNode;
   }        

So now if I am removing the first entry in the list, I move the pointer
to the start of the list forward one.
It took me so long to figure out what was going wrong here, not helped
by the fact that this is actually part of a directX application and
therefore stupidly difficult to debug. I feel SOOOOOOO much better now!!
:))

--
Don Halloran

--
Don Halloran