/*
* list.c
*
* version: 2012-12-19
*
* Copyright (c) Chris Putnam 2004-2013
*
* Source code released under the GPL version 2
*
* Implements a simple managed array of newstrs.
*
*/
#include "list.h"
void
list_init( list *a )
{
a->str = NULL;
a->max = 0;
a->n = 0;
a->sorted = 0;
}
void
list_empty( list *a )
{
int i;
for ( i=0; i<a->max; ++i )
newstr_empty( &(a->str[i]) );
a->n = 0;
a->sorted = 1;
}
void
list_free( list *a )
{
int i;
for ( i=0; i<a->max; ++i )
newstr_free( &(a->str[i]) );
free( a->str );
list_init( a );
}
list *
list_new( void )
{
list *a = ( list * ) malloc( sizeof ( list ) );
if ( a ) list_init( a );
return a;
}
void
list_delete( list *a )
{
list_free( a );
free( a );
}
/*
* returns 1 if n is valid string in list
*/
static inline int
list_valid_num( list *a, int n )
{
if ( n < 0 || n >= a->n ) return 0;
return 1;
}
/*
* return pointer to newstr 'n', list_getstr() is deprecated
*/
newstr *
list_get( list *a, int n )
{
if ( !list_valid_num( a, n ) ) return NULL;
else return &(a->str[n]);
}
newstr *
list_getstr( list *a, int n )
{
if ( !list_valid_num( a, n ) ) return NULL;
else return &(a->str[n]);
}
/*
* return pointer to C string 'n', list_getstr_char() is deprecated
*
* Ensure that a pointer is returned even if the newstr doesn't
* point to data. Thus we can convert loops like:
*
* for ( i=0; i<a->n; ++i ) {
* p = list_getc( a, i );
* if ( p==NULL ) continue; // empty string
* ...
* }
*
* to
*
* i = 0;
* while ( ( p = list_getc( a, i ) ) ) {
* ...
* i++;
* }
*
*/
char *
list_getc( list *a, int n )
{
static char empty[] = "";
char *p;
if ( !list_valid_num( a, n ) ) return NULL;
p = a->str[n].data;
if ( p ) return p;
else return empty;
}
char *
list_getstr_char( list *a, int n )
{
return list_getc( a, n );
}
static int
list_alloc( list *a )
{
int i, alloc = 20;
a->str = ( newstr* ) malloc( sizeof( newstr ) * alloc );
if ( !(a->str) ) return 0;
a->max = alloc;
a->n = 0;
for ( i=0; i<alloc; ++i )
newstr_init( &(a->str[i]) );
return 1;
}
static int
list_realloc( list *a )
{
newstr *more;
int i, alloc = a->max * 2;
more = ( newstr* ) realloc( a->str, sizeof( newstr ) * alloc );
if ( !more ) return 0;
a->str = more;
for ( i=a->max; i<alloc; ++i )
newstr_init( &(a->str[i]) );
a->max = alloc;
return 1;
}
static int
list_ensure_space( list *a )
{
int ok = 1;
if ( a->max==0 ) ok = list_alloc( a );
else if ( a->n >= a->max ) ok = list_realloc( a );
return ok;
}
int
list_add( list *a, char *s )
{
int ok = list_ensure_space( a );
if ( ok ) {
newstr_strcpy( &(a->str[a->n]), s );
a->sorted = 0;
a->n++;
}
return ok;
}
int
list_adds( list *a, ... )
{
int ok, ret = 1;
va_list ap;
char *v;
va_start( ap, a );
do {
v = va_arg( ap, char * );
if ( v ) {
ok = list_add( a, v );
if ( !ok ) { ret=0; goto out; }
}
} while( v );
out:
va_end( ap );
return ret;
}
int
list_add_unique( list *a, char *s )
{
if ( list_find( a, s )==-1 ) return list_add( a, s );
else return 1;
}
int
list_add_newstr( list *a, newstr *s )
{
int ok = list_ensure_space( a );
if ( ok ) {
newstr_newstrcpy( &(a->str[a->n]), s );
a->sorted = 0;
a->n++;
}
return ok;
}
int
list_add_newstr_unique( list *a, newstr *s )
{
if ( list_find( a, s->data )==-1 ) return list_add_newstr( a, s );
else return 1;
}
void
list_append( list *a, list *toadd )
{
int i;
for ( i=0; i<toadd->n; ++i ) {
list_add_newstr( a, &(toadd->str[i]) );
}
}
void
list_append_unique( list *a, list *toadd )
{
int i;
for ( i=0; i<toadd->n; ++i ) {
list_add_newstr_unique( a, &(toadd->str[i]) );
}
}
void
list_remove( list *a, int n )
{
int i;
if ( !list_valid_num( a, n ) ) return;
for ( i=n+1; i<a->n; ++i )
newstr_newstrcpy( &(a->str[i-1]), &(a->str[i]) );
a->n--;
}
static int
list_comp( const void *v1, const void *v2 )
{
newstr *s1 = ( newstr *) v1;
newstr *s2 = ( newstr *) v2;
if ( !s1->len && !s2->len ) return 0;
else if ( !s1->len ) return -1;
else if ( !s2->len ) return 1;
else return strcmp( s1->data, s2->data );
}
void
list_sort( list *a )
{
qsort( a->str, a->n, sizeof( newstr ), list_comp );
a->sorted = 1;
}
static int
list_find_sorted( list *a, char *searchstr )
{
int min, max, mid, comp;
newstr s, *cs;
if ( a->n==0 ) return -1;
newstr_init( &s );
newstr_strcpy( &s, searchstr );
min = 0;
max = a->n - 1;
while ( min <= max ) {
mid = ( min + max ) / 2;
cs = list_get( a, mid );
comp = list_comp( (void*)cs, (void*) (&s) );
if ( comp==0 ) return mid;
else if ( comp > 0 ) max = mid - 1;
else if ( comp < 0 ) min = mid + 1;
}
newstr_free( &s );
return -1;
}
static int
list_find_simple( list *a, char *searchstr, int nocase )
{
int i;
if ( nocase ) {
for ( i=0; i<a->n; ++i )
if ( !strcasecmp(a->str[i].data,searchstr) )
return i;
} else {
for ( i=0; i<a->n; ++i )
if ( !strcmp(a->str[i].data,searchstr) )
return i;
}
return -1;
}
int
list_find( list *a, char *searchstr )
{
if ( a->sorted )
return list_find_sorted( a, searchstr );
else
return list_find_simple( a, searchstr, 0 );
}
int
list_findnocase( list *a, char *searchstr )
{
return list_find_simple( a, searchstr, 1 );
}
/* Return the index of searched-for string.
* If cannot find string, add to list and then
* return the index
*/
int
list_find_or_add( list *a, char *searchstr )
{
int n = list_find( a, searchstr );
if ( n==-1 )
n = list_add( a, searchstr );
return n;
}
void
list_fillfp( list *a, FILE *fp )
{
newstr line;
char *p, buf[512]="";
int bufpos = 0;
list_init( a );
newstr_init( &line );
while ( newstr_fget( fp, buf, sizeof(buf), &bufpos, &line ) ) {
p = &(line.data[0]);
if ( *p=='\0' ) continue;
if ( !list_add( a, line.data ) ) return;
}
newstr_free( &line );
}
int
list_fill( list *a, char *filename )
{
FILE *fp = fopen( filename, "r" );
if ( !fp ) return 0;
list_fillfp( a, fp );
fclose( fp );
return 1;
}
void
list_copy( list *to, list *from )
{
int i;
list_free( to );
to->str = ( newstr * ) malloc( sizeof( newstr ) * from->n );
if ( !to->str ) return;
to->n = to->max = from->n;
for ( i=0; i<from->n; ++i ) {
newstr_init( &(to->str[i]) );
newstr_strcpy( &(to->str[i]), from->str[i].data );
}
}
list *
list_dup( list *aold )
{
list *anew;
int i;
anew = ( list* ) malloc( sizeof( list ) );
if ( !anew ) goto err0;
anew->str = ( newstr* ) malloc( sizeof( newstr ) * aold->n );
if ( !anew->str ) goto err1;
anew->n = anew->max = aold->n;
for ( i=0; i<aold->n; ++i ) {
newstr_init( &(anew->str[i]) );
newstr_strcpy( &(anew->str[i]), aold->str[i].data );
}
return anew;
err1:
free( anew );
err0:
return NULL;
}
int
list_match_entry( list *a, int n, char *s )
{
if ( n < 0 || n >= a->n ) return 0;
if ( strcmp( a->str[n].data, s ) ) return 0;
return 1;
}
void
list_trimend( list *a, int n )
{
int i;
if ( a->n - n < 1 ) {
list_empty( a );
} else {
for ( i=a->n -n; i<a->n; ++i ) {
newstr_empty( &(a->str[i]) );
}
a->n -= n;
}
}
void
list_tokenize( list *tokens, newstr *in, char delim, int merge_delim )
{
newstr s;
char *p;
list_empty( tokens );
p = in->data;
newstr_init( &s );
while ( p && *p ) {
while ( *p && *p!=delim ) newstr_addchar( &s, *p++ );
if ( s.len ) list_add( tokens, s.data );
else if ( !merge_delim ) list_add( tokens, "" );
newstr_empty( &s );
if ( *p==delim ) p++;
}
newstr_free( &s );
}
void
list_newstrtok( list *t, newstr *s, char *sep )
{
newstr tmp;
char *p;
list_empty( t );
if ( !s->len ) return;
newstr_init( &tmp );
p = s->data;
while ( *p ) {
if ( strchr( sep, *p ) ) {
if ( tmp.len ) {
list_add( t, tmp.data );
newstr_empty( &tmp );
}
} else newstr_addchar( &tmp, *p );
p++;
}
if ( tmp.len ) list_add( t, tmp.data );
newstr_free( &tmp );
}
void
lists_init( list *a, ... )
{
list *a2;
va_list ap;
list_init( a );
va_start( ap, a );
do {
a2 = va_arg( ap, list * );
if ( a2 ) list_init( a2 );
} while ( a2 );
va_end( ap );
}
void
lists_free( list *a, ... )
{
list *a2;
va_list ap;
list_free( a );
va_start( ap, a );
do {
a2 = va_arg( ap, list * );
if ( a2 ) list_free( a2 );
} while ( a2 );
va_end( ap );
}
void
lists_empty( list *a, ... )
{
list *a2;
va_list ap;
list_empty( a );
va_start( ap, a );
do {
a2 = va_arg( ap, list * );
if ( a2 ) list_empty( a2 );
} while ( a2 );
va_end( ap );
}