This repository has been archived on 2023-08-20. You can view files and clone it, but cannot push or open issues or pull requests.
yap-6.3/packages/ProbLog/simplecudd_lfi/pqueue.c
2011-06-26 23:13:43 +01:00

716 lines
11 KiB
C

/******************************************************************
**
** QUEUE.C:
**
** ADT Queue Implementation
**
** This file is part of Apt Abstrct Data Types (ADT)
** Copyright (c) 1991 -- Apt Technologies
** All rights reserved
**
******************************************************************/
/* ---------- C Headers */
//#include "cheaders.h"
/* ---------- Headers */
#include "apt.h"
#include "allocate.h"
#include "pqueue.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/* ---------- Private Function Prototypes */
#ifdef __ANSI_C__
PRIVATE void QueueDisposeItem(QueueItem, DisposeFunction);
PRIVATE QueueItem QueueGetItem(Queue);
PRIVATE QueueItem QueueNewItem(void*, int);
PRIVATE void QueuePutItem(Queue, QueueItem);
PRIVATE QueueItem QueueRemoveItem(Queue, QueueItem);
PRIVATE int QueueCompareEqual(void *, void *);
#else
PRIVATE void QueueDisposeItem();
PRIVATE QueueItem QueueGetItem();
PRIVATE QueueItem QueueNewItem();
PRIVATE void QueuePutItem();
PRIVATE QueueItem QueueRemoveItem();
PRIVATE int QueueCompareEqual();
#endif
/* ---------- Functions */
/*
**
** QueueApply
**
*/
PUBLIC
#ifdef __ANSI_C__
void QueueApply(Queue q, ApplyFunction f)
#else
void QueueApply(q,f)
Queue q;
ApplyFunction f;
#endif
{
QueueItem item;
for (item = q->head; item != NULL; item = item->next) {
(*f)(item->element);
}
}
/*
**
** QueueApply1
**
*/
PUBLIC
#ifdef __ANSI_C__
void QueueApply1(Queue q, void *p1, ApplyFunction1 f)
#else
void QueueApply1(q,p1,f)
Queue q;
void *p1;
ApplyFunction1 f;
#endif
{
QueueItem item;
for (item = q->head; item != NULL; item = item->next) {
(*f)(item->element,p1);
}
}
/*
**
** QueueApply2
**
*/
PUBLIC
#ifdef __ANSI_C__
void QueueApply2(Queue q, void *p1, void *p2, ApplyFunction2 f)
#else
void QueueApply2(q,p1,p2,f)
Queue q;
void *p1;
void *p2;
ApplyFunction2 f;
#endif
{
QueueItem item;
for (item = q->head; item != NULL; item = item->next) {
(*f)(item->element,p1,p2);
}
}
/*
**
** QueueApply3
**
*/
PUBLIC
#ifdef __ANSI_C__
void QueueApply3(Queue q, void *p1, void* p2, void *p3, ApplyFunction3 f)
#else
void QueueApply3(q,p1,p2,p3,f)
Queue q;
void *p1;
void *p2;
void *p3;
ApplyFunction3 f;
#endif
{
QueueItem item;
for (item = q->head; item != NULL; item = item->next) {
(*f)(item->element,p1,p2,p3);
}
}
/*
**
** QueueCAR
**
*/
PUBLIC
#ifdef __ANSI_C__
void *QueueCAR(Queue q)
#else
void *QueueCAR(q)
Queue q;
#endif
{
if (q != NULL && q->head != NULL)
return QueueItemElement(q->head);
return NULL;
}
/*
**
** QueueCDR
**
*/
PUBLIC
#ifdef __ANSI_C__
Queue QueueCDR(Queue q)
#else
Queue QueueCDR(q)
Queue q;
#endif
{
if (q != NULL && q->head != NULL) {
Queue new = QueueNew();
new->head = q->head->next;
new->tail = new->head != NULL ? q->tail : NULL;
new->size = q->size-1;
return new;
} else
return NULL;
}
/*
**
** QueueDispose
**
*/
PUBLIC
#ifdef __ANSI_C__
void QueueDispose(Queue q, DisposeFunction f)
#else
void QueueDispose(q,f)
Queue q;
DisposeFunction f;
#endif
{
QueueItem item;
QueueItem next = NULL;
for (item = q->head; item != NULL; item = next) {
next = item->next;
QueueDisposeItem(item,f);
}
free(q);
}
/*
**
** QueueDisposeItem
**
*/
PRIVATE
#ifdef __ANSI_C__
void QueueDisposeItem(QueueItem item, DisposeFunction f)
#else
void QueueDisposeItem(item,f)
QueueItem item;
DisposeFunction f;
#endif
{
if (f) (*f)(item->element);
free(item);
}
/*
**
** QueueFind
**
*/
PUBLIC
#ifdef __ANSI_C__
void *QueueFind(Queue q, void *element, ComparisonFunction f)
#else
void *QueueFind(q,element,f)
Queue q;
void *element;
ComparisonFunction f;
#endif
{
QueueItem item;
for (item = q->head; item != NULL; item = item->next) {
if ((*f)(element,item->element) == 0) break;
}
return (item != NULL ? item->element : NULL);
}
/*
**
** QueueFindAndRemove
**
*/
PUBLIC
#ifdef __ANSI_C__
void *QueueFindAndRemove(Queue q, void *element,
ComparisonFunction f)
#else
void *QueueFindAndRemove(q, element, f)
Queue q;
void *element;
ComparisonFunction f;
#endif
{
QueueItem item;
for (item = q->head; item != NULL; item = item->next) {
if ((*f)(element,item->element) == 0) break;
}
item = QueueRemoveItem(q,item);
return (item != NULL ? item->element : NULL);
}
/*
**
** QueueFindAndRemoveType
**
*/
PUBLIC
#ifdef __ANSI_C__
void *QueueFindAndRemoveType(Queue q, void *element,
ComparisonFunction f, int type)
#else
void *QueueFindAndRemoveType(q, element, f, type)
Queue q;
void *element;
ComparisonFunction f;
int type;
#endif
{
QueueItem item;
for (item = q->head; item != NULL; item = item->next) {
if ((*f)(element,item->element) == 0 && item->type == type) break;
}
item = QueueRemoveItem(q,item);
return (item != NULL ? item->element : NULL);
}
/*
**
** QueueFindType
**
*/
PUBLIC
#ifdef __ANSI_C__
void *QueueFindType(Queue q, int type)
#else
void *QueueFindType(q,type)
Queue q;
int type;
#endif
{
QueueItem item;
for (item = q->head; item != NULL; item = item->next) {
if (item->type == type) break;
}
return (item != NULL ? item->element : NULL);
}
/*
**
** QueueFindTypeAndRemove
**
*/
PUBLIC
#ifdef __ANSI_C__
void *QueueFindTypeAndRemove(Queue q, int type)
#else
void *QueueFindTypeAndRemove(q,type)
Queue q;
int type;
#endif
{
QueueItem item;
for (item = q->head; item != NULL; item = item->next) {
if (item->type == type) break;
}
return (QueueRemoveItem(q,item));
}
/*
**
** QueueGet
**
*/
PUBLIC
#ifdef __ANSI_C__
void *QueueGet(Queue q)
#else
void *QueueGet(q)
Queue q;
#endif
{
void *element;
QueueItem item;
item = QueueGetItem(q);
if (item) {
element = item->element;
QueueDisposeItem(item,NULL);
}
else element = NULL;
return (element);
}
/*
**
** QueueGetItem
**
*/
PRIVATE
#ifdef __ANSI_C__
QueueItem QueueGetItem(Queue q)
#else
QueueItem QueueGetItem(q)
Queue q;
#endif
{
QueueItem item;
if (q->head) {
item = q->head;
q->head = q->head->next;
q->size--;
}
else item = NULL;
return (item);
}
/*
**
** QueueHead
**
*/
PUBLIC
#ifdef __ANSI_C__
QueueItem QueueHead(Queue q)
#else
QueueItem QueueHead(q)
Queue q;
#endif
{
return q != NULL ? q->head : NULL;
}
/*
**
** QueueItemElement
**
*/
PUBLIC
#ifdef __ANSI_C__
void *QueueItemElement(QueueItem item)
#else
void *QueueItemElement(item)
QueueItem item;
#endif
{
return (item->element);
}
/*
**
** QueueItemType
**
*/
PUBLIC
#ifdef __ANSI_C__
int QueueItemType(QueueItem item)
#else
int QueueItemType(item)
QueueItem item;
#endif
{
return (item->type);
}
/*
**
** QueueLook
**
*/
PUBLIC
#ifdef __ANSI_C__
void *QueueLook(Queue q)
#else
void *QueueLook(q)
Queue q;
#endif
{
QueueItem item;
item = q->head;
return (item != NULL ? item->element : NULL);
}
/*
**
** QueueNew
**
*/
PUBLIC
#ifdef __ANSI_C__
Queue QueueNew(void)
#else
Queue QueueNew()
#endif
{
Queue q;
q = ((Queue)Allocate(sizeof(_Queue)));
if (q) {
q->head = q->tail = NULL;
q->size = 0;
}
return (q);
}
/*
**
** QueueNewItem
**
*/
PRIVATE
#ifdef __ANSI_C__
QueueItem QueueNewItem(void *element, int type)
#else
QueueItem QueueNewItem(element,type)
void *element;
int type;
#endif
{
QueueItem item;
item = ((QueueItem)Allocate(sizeof(_QueueItem)));
if (item) {
item->element = element;
item->type = type;
item->next = NULL;
}
return (item);
}
/*
**
** QueueNext
**
*/
PUBLIC
#ifdef __ANSI_C__
QueueItem QueueNext(QueueItem item)
#else
QueueItem QueueNext(item)
QueueItem item;
#endif
{
return item != NULL ? item->next : NULL;
}
/*
**
** QueuePut
**
*/
PUBLIC
#ifdef __ANSI_C__
void QueuePut(Queue q, void *element, int type)
#else
void QueuePut(q,element,type)
Queue q;
void *element;
int type;
#endif
{
QueueItem item;
item = QueueNewItem(element,type);
QueuePutItem(q,item);
}
/*
**
** QueuePutItem
**
*/
PRIVATE
#ifdef __ANSI_C__
void QueuePutItem(Queue q, QueueItem item)
#else
void QueuePutItem(q,item)
Queue q;
QueueItem item;
#endif
{
if (q->head == NULL) {
q->head = q->tail = item;
} else {
q->tail->next = item;
q->tail = q->tail->next;
}
q->size++;
}
/*
**
** QueuePutOnPriority
**
*/
PUBLIC
#ifdef __ANSI_C__
void QueuePutOnPriority(Queue q, void *element, int type,
ComparisonFunction f)
#else
void QueuePutOnPriority(q,element,type,f)
Queue q;
void *element;
int type;
ComparisonFunction f;
#endif
{
QueueItem item;
item = QueueNewItem(element,type);
//fprintf(stderr,"searching for location using %p.\n",f);
if (f == NULL){
//fprintf(stderr,"comparing function is null %f \n",f);
exit(1);
QueuePutItem(q,item);
}else {
if (q->head == NULL) QueuePutItem(q,item);
else {
QueueItem p, lastp = NULL;
for (p = q->head; p != NULL; p = p->next) {
int cval =(*f)(element,p->element);
if (cval<0){
// fprintf(stderr,"%i <=> %i == %i\n",*((int *) element),*((int *)(p->element)),
// cval);
break;
}
lastp = p;
}
if (p == q->head) {
item->next = q->head;
q->head = item;
} else if (p == NULL) {
q->tail->next = item;
q->tail = q->tail->next;
} else {
item->next = p;
lastp->next = item;
}
q->size++;
}
}
}
/*
**
** QueueRemoveItem
**
*/
PRIVATE
#ifdef __ANSI_C__
QueueItem QueueRemoveItem(Queue q, QueueItem item)
#else
QueueItem QueueRemoveItem(q,item)
Queue q;
QueueItem item;
#endif
{
QueueItem this, prev = NULL;
if (q == NULL) return (NULL);
if (item == NULL) return (NULL);
this = q->head;
while (this && this != item) {
prev = this; this = this->next;
}
if (this == NULL) return (NULL);
if (this == q->head) q->head = item->next;
if (this == q->tail) q->tail = prev;
if (prev) prev->next = this->next;
q->size--;
return (item);
}
/*
**
** QueueSeek
**
*/
PUBLIC
#ifdef __ANSI_C__
QueueItem QueueSeek(Queue q, int position)
#else
QueueItem QueueSeek(q,position)
Queue q;
int position;
#endif
{
QueueItem item;
#if 0
/* Allow single-level negative addressing of queue items */
if (position <= 0)
position += QueueSize(q);
#endif
/* Seeks which fail will result in NULL, not error conditions */
if (position <= 0 || position > QueueSize(q))
return NULL;
item = QueueHead(q);
while (--position > 0)
item = QueueNext(item);
return item;
}
/*
**
** QueueSize
**
*/
PUBLIC
#ifdef __ANSI_C__
int QueueSize(Queue q)
#else
int QueueSize(q)
Queue q;
#endif
{
return q != NULL ? q->size : 0;
}
/*
**
** QueueTail
**
*/
PUBLIC
#ifdef __ANSI_C__
QueueItem QueueTail(Queue q)
#else
QueueItem QueueTail(q)
Queue q;
#endif
{
return q != NULL ? q->tail : NULL;
}
PRIVATE
#ifdef __ANSI_C__
int QueueCompareEqual(void *x, void *y)
#else
int QueueCompareEqual(x,y)
void *x, *y;
#endif
{
return 0;
}