mirror of https://github.com/cc65/cc65.git
304 lines
10 KiB
C
304 lines
10 KiB
C
/*****************************************************************************/
|
|
/* */
|
|
/* coll.h */
|
|
/* */
|
|
/* Collection (dynamic array) */
|
|
/* */
|
|
/* */
|
|
/* */
|
|
/* (C) 2000-2011, Ullrich von Bassewitz */
|
|
/* Roemerstrasse 52 */
|
|
/* D-70794 Filderstadt */
|
|
/* EMail: uz@cc65.org */
|
|
/* */
|
|
/* */
|
|
/* This software is provided 'as-is', without any expressed or implied */
|
|
/* warranty. In no event will the authors be held liable for any damages */
|
|
/* arising from the use of this software. */
|
|
/* */
|
|
/* Permission is granted to anyone to use this software for any purpose, */
|
|
/* including commercial applications, and to alter it and redistribute it */
|
|
/* freely, subject to the following restrictions: */
|
|
/* */
|
|
/* 1. The origin of this software must not be misrepresented; you must not */
|
|
/* claim that you wrote the original software. If you use this software */
|
|
/* in a product, an acknowledgment in the product documentation would be */
|
|
/* appreciated but is not required. */
|
|
/* 2. Altered source versions must be plainly marked as such, and must not */
|
|
/* be misrepresented as being the original software. */
|
|
/* 3. This notice may not be removed or altered from any source */
|
|
/* distribution. */
|
|
/* */
|
|
/*****************************************************************************/
|
|
|
|
|
|
|
|
#ifndef COLL_H
|
|
#define COLL_H
|
|
|
|
|
|
|
|
/* common */
|
|
#include "attrib.h"
|
|
#include "check.h"
|
|
#include "inline.h"
|
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
/* Data */
|
|
/*****************************************************************************/
|
|
|
|
|
|
|
|
/* An array of pointers that grows if needed */
|
|
typedef struct Collection Collection;
|
|
struct Collection {
|
|
unsigned Count; /* Number of items in the list */
|
|
unsigned Size; /* Size of allocated array */
|
|
void** Items; /* Array with dynamic size */
|
|
};
|
|
|
|
/* An empty collection */
|
|
extern const Collection EmptyCollection;
|
|
|
|
/* Initializer for static collections */
|
|
#define STATIC_COLLECTION_INITIALIZER { 0, 0, 0 }
|
|
|
|
/* Initializer for auto collections */
|
|
#define AUTO_COLLECTION_INITIALIZER EmptyCollection
|
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
/* Code */
|
|
/*****************************************************************************/
|
|
|
|
|
|
|
|
Collection* InitCollection (Collection* C);
|
|
/* Initialize a collection and return it. */
|
|
|
|
void DoneCollection (Collection* C);
|
|
/* Free the data for a collection. This will not free the data contained in
|
|
** the collection.
|
|
*/
|
|
|
|
Collection* NewCollection (void);
|
|
/* Create and return a new collection */
|
|
|
|
void FreeCollection (Collection* C);
|
|
/* Free a collection */
|
|
|
|
void CollGrow (Collection* C, unsigned Size);
|
|
/* Grow the collection C so it is able to hold Size items without a resize
|
|
** being necessary. This can be called for performance reasons if the number
|
|
** of items to be placed in the collection is known in advance.
|
|
*/
|
|
|
|
#if defined(HAVE_INLINE)
|
|
INLINE unsigned CollCount (const Collection* C)
|
|
/* Return the number of items in the collection */
|
|
{
|
|
return C->Count;
|
|
}
|
|
#else
|
|
# define CollCount(C) (C)->Count
|
|
#endif
|
|
|
|
void CollInsert (Collection* C, void* Item, unsigned Index);
|
|
/* Insert the data at the given position in the collection */
|
|
|
|
#if defined(HAVE_INLINE)
|
|
INLINE void CollAppend (Collection* C, void* Item)
|
|
/* Append an item to the end of the collection */
|
|
{
|
|
/* Insert the item at the end of the current list */
|
|
CollInsert (C, Item, C->Count);
|
|
}
|
|
#else
|
|
void CollAppend (Collection* C, void* Item);
|
|
/* Append an item to the end of the collection */
|
|
#endif
|
|
|
|
#if defined(HAVE_INLINE)
|
|
INLINE void* CollAt (const Collection* C, unsigned Index)
|
|
/* Return the item at the given index */
|
|
{
|
|
/* Check the index */
|
|
PRECONDITION (Index < C->Count);
|
|
|
|
/* Return the element */
|
|
return C->Items[Index];
|
|
}
|
|
#else
|
|
void* CollAt (const Collection* C, unsigned Index);
|
|
/* Return the item at the given index */
|
|
#endif
|
|
|
|
#if defined(HAVE_INLINE)
|
|
INLINE void* CollAtUnchecked (const Collection* C, unsigned Index)
|
|
/* Return the item at the given index */
|
|
{
|
|
/* Return the element */
|
|
return C->Items[Index];
|
|
}
|
|
#else
|
|
# define CollAtUnchecked(C, Index) ((C)->Items[(Index)])
|
|
#endif
|
|
|
|
#if defined(HAVE_INLINE)
|
|
INLINE const void* CollConstAt (const Collection* C, unsigned Index)
|
|
/* Return the item at the given index */
|
|
{
|
|
/* Check the index */
|
|
PRECONDITION (Index < C->Count);
|
|
|
|
/* Return the element */
|
|
return C->Items[Index];
|
|
}
|
|
#else
|
|
const void* CollConstAt (const Collection* C, unsigned Index);
|
|
/* Return the item at the given index */
|
|
#endif
|
|
|
|
#if defined(HAVE_INLINE)
|
|
INLINE void* CollLast (Collection* C)
|
|
/* Return the last item in a collection */
|
|
{
|
|
/* We must have at least one entry */
|
|
PRECONDITION (C->Count > 0);
|
|
|
|
/* Return the element */
|
|
return C->Items[C->Count-1];
|
|
}
|
|
#else
|
|
void* CollLast (Collection* C);
|
|
/* Return the last item in a collection */
|
|
#endif
|
|
|
|
#if defined(HAVE_INLINE)
|
|
INLINE const void* CollConstLast (const Collection* C)
|
|
/* Return the last item in a collection */
|
|
{
|
|
/* We must have at least one entry */
|
|
PRECONDITION (C->Count > 0);
|
|
|
|
/* Return the element */
|
|
return C->Items[C->Count-1];
|
|
}
|
|
#else
|
|
const void* CollConstLast (const Collection* C);
|
|
/* Return the last item in a collection */
|
|
#endif
|
|
|
|
#if defined(HAVE_INLINE)
|
|
INLINE void* CollPop (Collection* C)
|
|
/* Remove the last segment from the stack and return it. Calls FAIL if the
|
|
** collection is empty.
|
|
*/
|
|
{
|
|
/* We must have at least one entry */
|
|
PRECONDITION (C->Count > 0);
|
|
|
|
/* Return the element */
|
|
return C->Items[--C->Count];
|
|
}
|
|
#else
|
|
void* CollPop (Collection* C);
|
|
/* Remove the last segment from the stack and return it. Calls FAIL if the
|
|
** collection is empty.
|
|
*/
|
|
#endif
|
|
|
|
int CollIndex (Collection* C, const void* Item);
|
|
/* Return the index of the given item in the collection. Return -1 if the
|
|
** item was not found in the collection.
|
|
*/
|
|
|
|
void CollDelete (Collection* C, unsigned Index);
|
|
/* Remove the item with the given index from the collection. This will not
|
|
** free the item itself, just the pointer. All items with higher indices
|
|
** will get moved to a lower position.
|
|
*/
|
|
|
|
void CollDeleteItem (Collection* C, const void* Item);
|
|
/* Delete the item pointer from the collection. The item must be in the
|
|
** collection, otherwise FAIL will be called.
|
|
*/
|
|
|
|
#if defined(HAVE_INLINE)
|
|
INLINE void CollDeleteAll (Collection* C)
|
|
/* Delete all items from the given collection. This will not free the items
|
|
** itself, it will only remove the pointers.
|
|
*/
|
|
{
|
|
/* This one is easy... */
|
|
C->Count = 0;
|
|
}
|
|
#else
|
|
# define CollDeleteAll(C) ((C)->Count = 0)
|
|
#endif
|
|
|
|
#if defined(HAVE_INLINE)
|
|
INLINE void CollReplace (Collection* C, void* Item, unsigned Index)
|
|
/* Replace the item at the given position. The old item will not be freed,
|
|
** just the pointer will get replaced.
|
|
*/
|
|
{
|
|
/* Check the index */
|
|
PRECONDITION (Index < C->Count);
|
|
|
|
/* Replace the item pointer */
|
|
C->Items[Index] = Item;
|
|
}
|
|
#else
|
|
void CollReplace (Collection* C, void* Item, unsigned Index);
|
|
/* Replace the item at the given position. The old item will not be freed,
|
|
** just the pointer will get replaced.
|
|
*/
|
|
#endif
|
|
|
|
void CollReplaceExpand (Collection* C, void* Item, unsigned Index);
|
|
/* If Index is a valid index for the collection, replace the item at this
|
|
** position by the one passed. If the collection is too small, expand it,
|
|
** filling unused pointers with NULL, then add the new item at the given
|
|
** position.
|
|
*/
|
|
|
|
void CollMove (Collection* C, unsigned OldIndex, unsigned NewIndex);
|
|
/* Move an item from one position in the collection to another. OldIndex
|
|
** is the current position of the item, NewIndex is the new index before
|
|
** the function has done it's work. Existing entries with indices NewIndex
|
|
** and up might be moved one position upwards.
|
|
*/
|
|
|
|
void CollMoveMultiple (Collection* C, unsigned Start, unsigned Count, unsigned Target);
|
|
/* Move a range of items from one position to another. Start is the index
|
|
** of the first item to move, Count is the number of items and Target is
|
|
** the index of the target item. The item with the index Start will later
|
|
** have the index Target. All items with indices Target and above are moved
|
|
** to higher indices.
|
|
*/
|
|
|
|
void CollTransfer (Collection* Dest, const Collection* Source);
|
|
/* Transfer all items from Source to Dest. Anything already in Dest is left
|
|
** untouched. The items in Source are not changed and are therefore in both
|
|
** Collections on return.
|
|
*/
|
|
|
|
void CollSort (Collection* C,
|
|
int (*Compare) (void*, const void*, const void*),
|
|
void* Data);
|
|
/* Sort the collection using the given compare function. The data pointer is
|
|
** passed as *first* element to the compare function, it's not used by the
|
|
** sort function itself. The other two pointer passed to the Compare function
|
|
** are pointers to objects.
|
|
*/
|
|
|
|
|
|
|
|
/* End of coll.h */
|
|
|
|
#endif
|