/* strlib.c - string library in C */
/* June 1, 2003 */
/* PUBLIC DOMAIN - Jon Mayo */

/* TODO:
 * + rename all functions not to start with 'str' because that is reserved
 * + reference counting
 */
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <stdio.h>
#include "strlib.h"

struct string {
	/* TODO: reference count */
	unsigned		len;
	unsigned		max;
	/* unsigned		   utf8len;    *//* length if the string were utf8 */
#if __STDC_VERSION__ >= 199901L
	unsigned char	str[]; /* C99 technique */
#else
	unsigned char	str[0]; /* hack that works almost everywhere */
#endif
};

/* can only make it bigger then len */
int strlibResize(string_t *s, unsigned minsize)
{
	string_t new;
	if((*s)->len > minsize)
		minsize=(*s)->len;
	new=realloc(*s, sizeof **s + minsize + 1);
	if(!new) {
		return 0;
	}
	new->max=minsize; 
	*s=new;
	return 1;
}

/* append s2 onto the end of s1 */
int strlibCat(string_t *s1, string_t s2)
{
	if(!strlibResize(s1, (*s1)->len + s2->len)) {
		return 0;
	}
	memcpy((*s1)->str + (*s1)->len, s2->str, s2->len+1);
	(*s1)->len+=s2->len;
	/* (*s1)->str[(*s1)->len]=0; */ /* set the last character to null */
	return 1; 
}

/* free a string_t */
void strlibFree(string_t *s)
{
	free(*s);
	*s=NULL;
}

/* return the amount allocated for the string */
int strlibAlloc(string_t s)
{
	return (s->max);
}

/* return the basic length */
int strlibLength(string_t s)
{
	return (s->len);
}

/* converts to a char pointer */
const char *strlibCharp(string_t s)
{
	return (char*)(s->str);
}

/* create an empty string_t with the allocation preset to max or greater */
static string_t strlibCreateN(unsigned max)
{
	string_t ret;
	ret=malloc(sizeof *ret + max + 1);
	ret->len=0;
	ret->max=max;
	ret->str[0]=0;
	/* ret->utf8len=0; */
	return ret;
}

/* create an empty 0-length string_t */
string_t strlibCreate(void)
{
	return strlibCreateN(0);
}

/* set the contents of one to another. assume s1 is already allocated */
int strlibCopy(string_t *s1, string_t s2)
{
	if((*s1)->max < s2->len) {
		*s1=strlibCreateN(s2->len);
		if(!*s1)
			return 0;
	}
	memcpy((*s1)->str,s2->str,s2->len+1);
	(*s1)->len=s2->len;
	/* (*s1)->utf8len=s2->utf8len; */
	return 1;
}

/* create a string_t from a null terminated string */
string_t strlibInit(const char *str)
{
	string_t ret;
	unsigned len;
	if(str) {
		len=strlen(str);
	} else {
		len=0;
	}
	ret=strlibCreateN(len);
	ret->len=len;
	ret->max=len;
	if(str) {
		memcpy(ret->str, str,len+1);
	} else {
		ret->str[0]=0;
	}
	return ret;
}

/* create a string_t from a non-terminated string */
string_t strlibInitN(const char *str, int len)
{
	string_t ret;
	if(len<0) {
		len=strlen(str);
	}
	ret=strlibCreateN(len);
	ret->len=len;
	ret->max=len;
	memcpy(ret->str, str,len);
	ret->str[len]=0;
	return ret;
}

/* get a substring of another string. 
 * if offset is <0 then start at beginning.
 * if offset>s->len then do a zero length string
 * if len>s->len then truncate at length of string
 */
string_t strlibSub(string_t s, int offset, int len)
{
	if(offset<0) {
		offset=0;
	}
	if(offset>s->len) {
		offset=s->len;
	}
	if(len<0 || offset+len>s->len) {
		len=s->len - offset;
	}
	return strlibInitN((char*)s->str + offset, len);
}

/* allocate a duplicate of a string */
string_t strlibDup(string_t s)
{
	return strlibSub(s,0,strlibLength(s));
}

/* duplicates s as an uppercase string */
string_t strlibUpper(string_t s)
{
	int i;
	string_t ret;
	ret=strlibCreateN(s->len);
	if(!ret) {
		return NULL;
	}
	for(i=0;i<s->len;i++) {
	   ret->str[i]=toupper(s->str[i]); 
	}
	ret->len=s->len;
	ret->str[ret->len]=0;
	return ret;
}

/* duplicates s as a lowercase string */
string_t strlibLower(string_t s)
{
	int i;
	string_t ret;
	ret=strlibCreateN(s->len);
	if(!ret) {
		return NULL;
	}
	for(i=0;i<s->len;i++) {
	   ret->str[i]=tolower(s->str[i]); 
	}
	ret->len=s->len;
	ret->str[ret->len]=0;
	return ret;
}

/* returns the length of the string (in characters) using UTF-8 */
int strlibUtf8len(string_t s)
{
	return 0;
}

/* truncate the end of a string */
int strlibTrunc(string_t s, int offset)
{
}

/* cut out the middle of a string */
int strlibDelete(string_t s, int offset, int len)
{
}

/* insert spaces into the middle of a string */
int strlibInsertBlank(string_t *s, int offset, int len)
{
}

/* insert a sub string into a string */
int strlibInsertN(string_t *s1, string_t s2, int s1_offset, int s2_offset, int len)
{
}

/* insert a string into a string */
int strlibInsert(string_t *s1, string_t s2, int offset)
{
	return strlibInsertN(s1,s2,offset,0,s2->len); 
}

/* vim: ts=4 sts=0 noet sw=4
*/