---

mlist_tmpl_c.inc

Go to the documentation of this file.

/***************************************************************************
                               mlist_tmpl_c.inc
                             --------------------
    begin                : Tue Nov 20 2001
    copyright            : (C) 2001-2002 by Christian Hoenig & Gunter Ohrner
    email                : pdepp@CustomCDROM.de
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   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 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#ifdef ML_LIST_NAME

#include "common.h"

#include <stdlib.h>

#include "xmalloc.h"
#include "assert.h"

#ifndef MLPFX
# define MLPFX ML_FUNC_PFX
#endif

#ifdef DOXYGEN_PREPROCESSING
# include "mlist_tmpl_h.inc"
#endif

#define mlist_assertions    assert(liste != NULL                  \
                            && liste->head->next != NULL          \
                            && liste->tail->prev != NULL          \
                            && liste->cur != NULL                 \
                            && liste->head->prev == liste->head   \
                            && liste->tail->next == liste->tail);

#define no_clone_assertion  assert(                               \
                              liste->is_clone == false ||         \
                              liste->num_of_clones != 0           \
                            )


// define element returned to indicate an "invalid" state / result
#ifndef ML_INVALID

# define ML_INVALID (MlCargo) 0L
#endif

// define a way to tell if a given MlCargo object is valid
#ifndef ML_IS_VALID_CARGO

# define ML_IS_VALID_CARGO(a) (a != ML_INVALID)
#endif

// define a facility to create an MlCargo object
#ifndef ML_CREATE_CARGO

# define ML_CREATE_CARGOI(new)
#else
# define ML_CREATE_CARGOI(new) ML_CREATE_CARGO(new)
#endif

// define a way to dublicate an MlCargo object
#ifndef ML_COPY_CARGO

# define ML_COPY_CARGO(dest, source) (dest = source)
#endif

// give a possibility to free a Cargo object
#ifndef ML_FREE_CARGO

# define ML_FREE_CARGOI(a)
#else
# define ML_FREE_CARGOI(a) ML_FREE_CARGO(a)
#endif


#define MlNode fn(ML_LIST_NAME, Node)

struct MlNode
{
  struct MlNode* next; 
  struct MlNode* prev; 
  MlCargo payload;     
};

struct ML_LIST_NAME
{
  struct MlNode* head; 
  struct MlNode* tail; 
  struct MlNode* cur;  
#ifndef NDEBUG
  int num_of_clones;   
  int is_clone;        
  ML_LIST_NAME parent;
#endif
};

typedef struct MlNode MlNode;

ML_LIST_NAME fn(MLPFX,Init)()
{
  ML_LIST_NAME new_list = (ML_LIST_NAME) pd_malloc(sizeof(struct ML_LIST_NAME));
  new_list->head = (MlNode*) pd_malloc(sizeof(MlNode));
  new_list->head->prev = new_list->head;

  new_list->tail = (MlNode*) pd_malloc(sizeof(MlNode));
  new_list->tail->next = new_list->tail;

  new_list->head->next = new_list->tail;
  new_list->tail->prev = new_list->head;

  new_list->cur  = new_list->head;

#ifndef NDEBUG
  new_list->num_of_clones = 0;
  new_list->is_clone = false;
  new_list->parent = new_list;
#endif

  return new_list;
}

ML_LIST_NAME fn(MLPFX,Dublicate)(ML_LIST_NAME liste)
{
  struct MlNode* tmp_cur_node = NULL;
  // Create a working copy of liste's control block so we do not
  // change the state of the original list.
  ML_LIST_NAME tmp_list = fn(MLPFX,Clone)(liste);
  ML_LIST_NAME new_list = fn(MLPFX,Init)();

  fn(MLPFX,First)(tmp_list);
  while(!fn(MLPFX,IsTail)(tmp_list))
  {
    fn(MLPFX,Append)(new_list, fn(MLPFX,GetPayload)(tmp_list));
    /* If we're just visiting the original list's "current" node,
       remeber the current position in the new list - it will become
       the current node in the new_list as well. */
    if (tmp_list->cur == liste->cur)
      tmp_cur_node = new_list->cur;
    fn(MLPFX,Next)(tmp_list);
    fn(MLPFX,Next)(new_list);
  }

#ifndef NDEBUG
  assert(tmp_cur_node != NULL);
#endif  
  new_list->cur = tmp_cur_node;

  return new_list;
}

ML_LIST_NAME fn(MLPFX,Clone)(ML_LIST_NAME liste)
{
  ML_LIST_NAME clone_list = (ML_LIST_NAME) pd_malloc(sizeof(struct ML_LIST_NAME));
  clone_list->head = liste->head;
  clone_list->tail = liste->tail;
  clone_list->cur  = liste->cur;

#ifndef NDEBUG
  clone_list->num_of_clones = 0;
  clone_list->is_clone = true;
  clone_list->parent = liste->parent;
  ++clone_list->parent->num_of_clones;
#endif

  return clone_list;
}

int fn(MLPFX,InsertAfter)(ML_LIST_NAME liste, MlCargo new_load)
{
  MlNode* new_node;

  mlist_assertions;

  // you cannot modify a clone or a list having living clones
  assert(liste->is_clone == false || liste->num_of_clones != 0);

  if (fn(MLPFX,IsTail(liste))) return -1;

  new_node = (MlNode*) pd_malloc(sizeof(MlNode));
  new_node->payload = ML_INVALID;

  new_node->next = liste->cur->next;
  new_node->prev = liste->cur;

  liste->cur->next = new_node;
  new_node->next->prev = new_node;

  liste->cur = new_node;

  fn(MLPFX,SetPayload)(liste, new_load);

  return 0;
}

int fn(MLPFX,InsertBefore)(ML_LIST_NAME liste, MlCargo new_load)
{
  MlNode* new_node;

  mlist_assertions;

  no_clone_assertion;

  if (fn(MLPFX,IsHead(liste))) return -1;

  new_node = (MlNode*) pd_malloc(sizeof(MlNode));
  new_node->payload = ML_INVALID;

  new_node->next = liste->cur;
  new_node->prev = liste->cur->prev;

  liste->cur->prev->next = new_node;
  liste->cur->prev = new_node;

  liste->cur = new_node;

  fn(MLPFX,SetPayload)(liste, new_load);

  return 0;
}

void fn(MLPFX,Append)(ML_LIST_NAME liste, MlCargo new_load)
{
  mlist_assertions;

  no_clone_assertion; 

  fn(MLPFX,Last)(liste);
  fn(MLPFX,InsertAfter)(liste, new_load);
}

void fn(MLPFX,Prepend)(ML_LIST_NAME liste, MlCargo new_load)
{
  mlist_assertions;

  no_clone_assertion;

  fn(MLPFX,First)(liste);
  fn(MLPFX,InsertBefore)(liste, new_load);
}

int fn(MLPFX,Delete)(ML_LIST_NAME liste)
{
  MlNode* to_delete;

  mlist_assertions;

  no_clone_assertion;

  if (!fn(MLPFX,IsValid(liste))) return -1;

  liste->cur->prev->next = liste->cur->next;
  liste->cur->next->prev = liste->cur->prev;

  to_delete = liste->cur;
  liste->cur = liste->cur->next;

  ML_FREE_CARGOI(to_delete->payload);
  pd_free(to_delete);

  return 0;
}

void fn(MLPFX,Next)(ML_LIST_NAME liste)
{
  mlist_assertions;

  liste->cur = liste->cur->next;
}

void fn(MLPFX,Prev)(ML_LIST_NAME liste)
{
  mlist_assertions;

  liste->cur = liste->cur->prev;
}

void fn(MLPFX,First)(ML_LIST_NAME liste)
{
  mlist_assertions;

  liste->cur = liste->head->next;
}

void fn(MLPFX,Last)(ML_LIST_NAME liste)
{
  mlist_assertions;

  liste->cur = liste->tail->prev;
}

int fn(MLPFX,SetPayload)(ML_LIST_NAME liste, MlCargo new_load)
{
  mlist_assertions;

  if (!fn(MLPFX,IsValid)(liste)) return -1;

  // If ML_FREE_CARGO is defined, ML_FREE_CARGOI must be used as well.
#ifdef ML_FREE_CARGO
  if (ML_IS_VALID_CARGO(liste->cur->payload))
    ML_FREE_CARGOI(liste->cur->payload);
#endif

  ML_CREATE_CARGOI(liste->cur->payload);
  ML_COPY_CARGO(liste->cur->payload, new_load);
  return 0;
}

MlCargo fn(MLPFX,GetPayload)(ML_LIST_NAME liste)
{
//  MlCargo cur_load;

  mlist_assertions;

  if (!fn(MLPFX,IsValid)(liste)) return ML_INVALID;

//  ML_CREATE_CARGOI(cur_load);
//  ML_COPY_CARGO(cur_load, liste->cur->payload);
  return liste->cur->payload; // cur_load;
}

int fn(MLPFX,IsEmpty)(ML_LIST_NAME liste)
{
  mlist_assertions;

  return (liste->head->next == liste->tail);
}

int fn(MLPFX,IsHead)(ML_LIST_NAME liste)
{
  mlist_assertions;

  return (liste->cur == liste->head);
}

int fn(MLPFX,IsTail)(ML_LIST_NAME liste)
{
  mlist_assertions;

  return (liste->cur == liste->tail);
}

int fn(MLPFX,IsValid)(ML_LIST_NAME liste)
{
  mlist_assertions;

  return !fn(MLPFX,IsHead)(liste) && !fn(MLPFX,IsTail)(liste);
}

int fn(MLPFX,IsValidValue)(MlCargo load)
{
  return ML_IS_VALID_CARGO(load);
}

int fn(MLPFX,Terminate)(ML_LIST_NAME liste)
{
  mlist_assertions;

#ifndef NDEBUG
  /* we can't die if our clones still live */
  assert(liste->num_of_clones == 0);

  /* inform the parent (if any) that a clone died */
  --liste->parent->num_of_clones;

  /* If we're clone, it's not our data in this list.
     We must not touch it.                          */
  if (liste->is_clone)
  {
#endif

// has ML_FREE_CARGO any meaningful content?
#ifdef ML_FREE_CARGO
    fn(MLPFX,First)(liste);
    while (!fn(MLPFX,IsTail)(liste))
      fn(MLPFX,Delete)(liste);
#else
    if (liste->head->next != liste->tail) return -1;
#endif

#ifndef NDEBUG
  } /* liste->is_clone */
#endif
  
  pd_free(liste->head);
  pd_free(liste->tail);
  pd_free(liste);

  return 0;
}

// clean up
#undef ML_INVALID
#undef ML_IS_VALID_CARGO
#undef ML_FUNC_PFX
#undef MLPFX
#undef MlNode
#undef ML_LIST_NAME
#undef MlCargo
#undef ML_CREATE_CARGO
#undef ML_CREATE_CARGOI
#undef ML_COPY_CARGO
#undef ML_FREE_CARGO
#undef ML_FREE_CARGOI
#undef ML_EMPTY_DEF

#endif

---