bff836ae6a
git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/trunk/SWIG@9 626c5289-ae23-0410-ae9c-e8d60b6d4f22
374 lines
9 KiB
C
374 lines
9 KiB
C
/****************************************************************************
|
|
* Simplified Wrapper and Interface Generator (SWIG)
|
|
*
|
|
* Author : David Beazley
|
|
*
|
|
* Department of Computer Science
|
|
* University of Chicago
|
|
* 1100 E 58th Street
|
|
* Chicago, IL 60637
|
|
* beazley@cs.uchicago.edu
|
|
*
|
|
* Please read the file LICENSE for the copyright and terms by which SWIG
|
|
* can be used and distributed.
|
|
****************************************************************************/
|
|
|
|
/*******************************************************************************
|
|
* $Header$
|
|
*
|
|
* File : list.c
|
|
*
|
|
* General purpose structure for keeping a list of reference counted Swig objects.
|
|
*******************************************************************************/
|
|
|
|
#include "doh.h"
|
|
|
|
typedef struct List {
|
|
DOHCOMMON;
|
|
int maxitems; /* Max size */
|
|
int nitems; /* Num items */
|
|
int iter; /* Iterator */
|
|
DOH **items;
|
|
} List;
|
|
|
|
/* Forward references */
|
|
|
|
DOH *CopyList(DOH *);
|
|
void DelList(DOH *);
|
|
void List_clear(DOH *);
|
|
DOH *List_get(DOH *, int pos);
|
|
int List_set(DOH *, int pos, DOH *obj);
|
|
int List_insert(DOH *, int pos, DOH *item);
|
|
int List_remove(DOH *, int pos);
|
|
int List_len(DOH *);
|
|
DOH *List_first(DOH *);
|
|
DOH *List_next(DOH *);
|
|
DOH *List_str(DOH *);
|
|
int List_dump(DOH *, DOH *);
|
|
|
|
#define MAXLISTITEMS 8
|
|
|
|
static DohSequenceMethods ListSeqMethods = {
|
|
List_get,
|
|
List_set,
|
|
List_remove,
|
|
List_insert,
|
|
List_first,
|
|
List_next,
|
|
};
|
|
|
|
static DohObjInfo ListType = {
|
|
"List", /* objname */
|
|
sizeof(List), /* List size */
|
|
DelList, /* sm_del */
|
|
CopyList, /* sm_copy */
|
|
List_clear, /* sm_clear */
|
|
List_str, /* sm_str */
|
|
0, /* doh_data */
|
|
List_dump, /* doh_dump */
|
|
List_len, /* sm_len */
|
|
0, /* sm_hash */
|
|
0, /* doh_cmp */
|
|
0, /* doh_mapping */
|
|
&ListSeqMethods, /* doh_sequence */
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
};
|
|
|
|
DohObjInfo *List_type() {
|
|
return &ListType;
|
|
}
|
|
|
|
/* Internal function. Doubles amount of memory in a list */
|
|
static
|
|
void more(List *l) {
|
|
int i;
|
|
void **newitems;
|
|
|
|
newitems = (void **) malloc(l->maxitems*2*sizeof(void *));
|
|
for (i = 0; i < l->maxitems; i++) {
|
|
newitems[i] = l->items[i];
|
|
}
|
|
for (i = l->maxitems; i < 2*l->maxitems; i++) {
|
|
newitems[i] = (void *) 0;
|
|
}
|
|
l->maxitems *= 2;
|
|
free(l->items);
|
|
l->items = newitems;
|
|
}
|
|
|
|
/* -----------------------------------------------------------------------------
|
|
* List_check(DOH *lo) - Check to see if an object is a list
|
|
* ----------------------------------------------------------------------------- */
|
|
|
|
int
|
|
List_check(DOH *lo) {
|
|
List *l = (List *) lo;
|
|
if (!l) return 0;
|
|
if (!DohCheck(lo)) return 0;
|
|
if (l->objinfo != &ListType) return 0;
|
|
return 1;
|
|
}
|
|
|
|
/* -----------------------------------------------------------------------------
|
|
* NewList() - Create a new list
|
|
* ----------------------------------------------------------------------------- */
|
|
|
|
DOH *
|
|
NewList() {
|
|
List *l;
|
|
int i;
|
|
l = (List *) DohMalloc(sizeof(List));
|
|
DohInit(l);
|
|
l->objinfo = &ListType;
|
|
l->nitems = 0;
|
|
l->maxitems = MAXLISTITEMS;
|
|
l->items = (void **) malloc(l->maxitems*sizeof(void *));
|
|
for (i = 0; i < MAXLISTITEMS; i++) {
|
|
l->items[i] = 0;
|
|
}
|
|
l->iter = 0;
|
|
return (DOH *) l;
|
|
}
|
|
|
|
/* -----------------------------------------------------------------------------
|
|
* DOH *CopyList(DOH *l) - Copy a list
|
|
* ----------------------------------------------------------------------------- */
|
|
|
|
DOH *
|
|
CopyList(DOH *lo) {
|
|
List *l,*nl;
|
|
int i;
|
|
l = (List *) lo;
|
|
nl = (List *) DohMalloc(sizeof(List));
|
|
DohInit(nl);
|
|
nl->objinfo = l->objinfo;
|
|
nl->nitems = l->nitems;
|
|
nl->maxitems = l->maxitems;
|
|
nl->items = (void **) malloc(l->maxitems*sizeof(void *));
|
|
nl->iter = 0;
|
|
for (i = 0; i < l->maxitems; i++) {
|
|
nl->items[i] = l->items[i];
|
|
if (nl->items[i]) {
|
|
Incref(nl->items[i]);
|
|
}
|
|
}
|
|
return (DOH *) nl;
|
|
}
|
|
|
|
/* -----------------------------------------------------------------------------
|
|
* void DelList(DOH *l) - Delete a list
|
|
* ----------------------------------------------------------------------------- */
|
|
|
|
void
|
|
DelList(DOH *lo) {
|
|
List *l;
|
|
int i;
|
|
l = (List *) lo;
|
|
assert(l->refcount <= 0);
|
|
for (i = 0; i < l->nitems; i++) {
|
|
Delete(l->items[i]);
|
|
}
|
|
free(l->items);
|
|
DohFree(l);
|
|
}
|
|
|
|
/* -----------------------------------------------------------------------------
|
|
* void List_clear(DOH *l) - Clear all elements in the list
|
|
* ----------------------------------------------------------------------------- */
|
|
|
|
void
|
|
List_clear(DOH *lo) {
|
|
List *l;
|
|
int i;
|
|
l = (List *) lo;
|
|
for (i = 0; i < l->nitems; i++) {
|
|
Delete(l->items[i]);
|
|
l->items[i] = 0;
|
|
}
|
|
l->nitems = 0;
|
|
}
|
|
|
|
/* -----------------------------------------------------------------------------
|
|
* void List_insert(DOH *lo, int pos, DOH *item) - Insert an element
|
|
* ----------------------------------------------------------------------------- */
|
|
|
|
int
|
|
List_insert(DOH *lo, int pos, DOH *item)
|
|
{
|
|
List *l;
|
|
DohBase *b;
|
|
int i;
|
|
|
|
if (!item) return;
|
|
b = (DohBase *) item;
|
|
l = (List *) lo;
|
|
|
|
if (pos == DOH_END) pos = l->nitems;
|
|
if (pos < 0) pos = 0;
|
|
if (pos > l->nitems) pos = l->nitems;
|
|
if (l->nitems == l->maxitems) more(l);
|
|
for (i = l->nitems; i > pos; i--) {
|
|
l->items[i] = l->items[i-1];
|
|
}
|
|
l->items[pos] = item;
|
|
b->refcount++;
|
|
l->nitems++;
|
|
return 0;
|
|
}
|
|
|
|
/* -----------------------------------------------------------------------------
|
|
* void List_remove(DOH *lo, int pos) - Remove an element
|
|
* ----------------------------------------------------------------------------- */
|
|
|
|
int
|
|
List_remove(DOH *lo, int pos)
|
|
{
|
|
List *l;
|
|
DOH *item;
|
|
int i;
|
|
|
|
l = (List *) lo;
|
|
if (pos == DOH_END) pos = l->nitems-1;
|
|
if (pos == DOH_BEGIN) pos = 0;
|
|
if ((pos < 0) || (pos >= l->nitems)) return;
|
|
item = l->items[pos];
|
|
for (i = pos; i < l->nitems-1; i++) {
|
|
l->items[i] = l->items[i+1];
|
|
}
|
|
l->nitems--;
|
|
Delete(item);
|
|
return 0;
|
|
}
|
|
|
|
/* -----------------------------------------------------------------------------
|
|
* int List_len(DOH *l) - List length
|
|
* ----------------------------------------------------------------------------- */
|
|
|
|
int
|
|
List_len(DOH *lo)
|
|
{
|
|
return ((List *) lo)->nitems;
|
|
}
|
|
|
|
/* -----------------------------------------------------------------------------
|
|
* DOH *List_get(DOH *lo, int n) - Get an item
|
|
* ----------------------------------------------------------------------------- */
|
|
|
|
DOH *
|
|
List_get(DOH *lo, int n)
|
|
{
|
|
List *l;
|
|
l = (List *) lo;
|
|
if (n == DOH_END) n = l->nitems-1;
|
|
if (n == DOH_BEGIN) n = 0;
|
|
if ((n < 0) || (n >= l->nitems)) {
|
|
printf("List_get : Invalid list index %d\n", n);
|
|
}
|
|
return l->items[n];
|
|
}
|
|
|
|
/* -----------------------------------------------------------------------------
|
|
* int List_set(DOH *lo, int n, DOH *val) - Set an item
|
|
* ----------------------------------------------------------------------------- */
|
|
|
|
int
|
|
List_set(DOH *lo, int n, DOH *val)
|
|
{
|
|
List *l;
|
|
|
|
l = (List *) lo;
|
|
if ((n < 0) || (n >= l->nitems)) {
|
|
printf("List_set : Invalid list index %d\n", n);
|
|
}
|
|
Delete(l->items[n]);
|
|
l->items[n] = val;
|
|
Incref(val);
|
|
return 0;
|
|
}
|
|
|
|
/* -----------------------------------------------------------------------------
|
|
* Iterators
|
|
* ----------------------------------------------------------------------------- */
|
|
|
|
DOH *
|
|
List_first(DOH *lo)
|
|
{
|
|
List *l;
|
|
l = (List *) lo;
|
|
l->iter = 0;
|
|
if (l->iter >= l->nitems) return 0;
|
|
return l->items[l->iter];
|
|
}
|
|
|
|
DOH *
|
|
List_next(DOH *lo)
|
|
{
|
|
List *l;
|
|
l = (List *) lo;
|
|
l->iter++;
|
|
if (l->iter >= l->nitems) return 0;
|
|
return l->items[l->iter];
|
|
}
|
|
|
|
/* -----------------------------------------------------------------------------
|
|
* String *List_str() - Create a string representation
|
|
* ----------------------------------------------------------------------------- */
|
|
|
|
DOH *
|
|
List_str(DOH *lo)
|
|
{
|
|
DOH *s;
|
|
int i;
|
|
|
|
List *l = (List *) lo;
|
|
s = NewString("");
|
|
for (i = 0; i < l->nitems; i++) {
|
|
Printf(s, "%o", l->items[i]);
|
|
if ((i+1) < l->nitems)
|
|
Printf(s,", ");
|
|
}
|
|
return s;
|
|
}
|
|
|
|
int
|
|
List_dump(DOH *lo, DOH *out) {
|
|
int nsent = 0;
|
|
int i,ret;
|
|
List *l = (List *) lo;
|
|
for (i = 0; i < l->nitems; i++) {
|
|
ret = Dump(l->items[i],out);
|
|
if (ret < 0) return -1;
|
|
nsent += ret;
|
|
}
|
|
return nsent;
|
|
}
|
|
|
|
#ifdef SORT
|
|
/* -----------------------------------------------------------------------------
|
|
* void List_sort(DOH *DOH)
|
|
*
|
|
* Sorts a list
|
|
* ----------------------------------------------------------------------------- */
|
|
|
|
int objcmp(const void *s1, const void *s2) {
|
|
DOH **so1, **so2;
|
|
so1 = (DOH **) s1;
|
|
so2 = (DOH **) s2;
|
|
return Cmp(*so1,*so2);
|
|
}
|
|
|
|
void List_sort(DOH *so) {
|
|
List *l;
|
|
if (!List_check(so)) return;
|
|
l = (List *) so;
|
|
qsort(l->items,l->nitems,sizeof(DOH *), objcmp);
|
|
}
|
|
#endif
|
|
|
|
|
|
|
|
|