#ifndef INCLUDED_STRING_2011_08_25_17_30_MM
#define INCLUDED_STRING_2011_08_25_17_30_MM


#include <stdlib.h>   // for size_t
#include <stdio.h>    // for FILE



/*** CONSTANTS ***/


#define  STRING_LOG2BLKSZ          8   /* see below */
/* maximal lenght of a String block */
#define  STRING_TOTALMAXBLOCKSIZE  (1<<STRING_LOG2BLKSZ)
/* maximal lenght of a String block, without the terminating '\0' */
#define  STRING_MAXBLOCKSIZE       (STRING_TOTALMAXBLOCKSIZE-1)



/*** TYPES ***/


/* the String object, to manage large and/or dynamic strings;
   it takes the form of a linked list of datas including an allocated block
   and informations concerning this block and the linked list */
typedef struct String {   /* single String object */
	unsigned int blkSize     :STRING_LOG2BLKSZ,   /* used lenght, without
	                                                 the terminating '\0' */
	             blkCapacity :STRING_LOG2BLKSZ;   /* allocated lenght - 1 */
	/* NOTE: Here, "capacity" will mean the allocated lenght minus 1, the
	   latter being reserved for the terminating '\0'. The "block capacity"
	   will mean the capacity of the current single String object, when the
	   "[total] capacity" will mean the sum of the capacities of all the
	   single Strings composing the linked String object.
	   Similarly, "size" will mean the used lenght without the '\0'; the
	   "block size" is the size of the current single String, and the
	   "[total] size" is the sum of the sizes of the single Strings. */
	char* blk;   /* the block of string itself (terminating with '\0');
	                /!\  must be NULL if no memory is allocated */
	size_t size;   /* total size, counting from this block */
	struct String* next;   /* next block of the String;
	                          /!\  must be NULL if this is the last one */
} String;



/*** FUNCTIONS ***/


/* Creates a new linked String object filled with the content of the string
   passed or, if the 1st argument is NULL, lets it empty but with a specified
   total capacity */
String* String_new(const char*, size_t);

/* Deletes completely the linked String object */
void String_del(String*);
/* Empties the linked String object, setting the total capacity to zero */
void String_clear(String*);

/* Write the content of the String object on the stream */
void String_write(const String*, FILE*);
/* idem, the stream is `stdout` ("displays" the String object) */
//#define  String_disp(this)  String_write(this, stdout)
static inline void String_disp(const String* this)
	{ String_write(this, stdout); }

/* Returns the total size of the linked String */
static inline size_t String_size(const String* this)
	{ return (this!=NULL)? this->size : 0; }
#define  String_lenght  String_size
/* Returns the total capacity of the linked String */
size_t String_capacity(const String*);

/* Creates a copy of the linked String without modifying it */
String* String_copy(const String*);

/* Concatenates the two linked Strings (the 2nd is directly put at the end
   of the 1st, without being copied before) */
void String_concat(String*, String*);
/* Concatenates the 1st linked String and a copy of the second, so the 2nd
   is not modified */
static inline void String_concatCopy(String* this, const String* src)
	{ String_concat(this, String_copy(src)); }

/* Returns the address of the character of index specified in the linked
   String; returns NULL if the index is out of range */
char* String_charP(const String*, size_t);
/* Returns the character of index specified in the linked String; returns
   '\0' if the index is out of range */
char String_char(const String*, size_t);
/* Sets the character of index specified in the linked String to the value
   specified; if it is '\0', then this index will become the end of the
   linked String; if the index is out of range, the linked String is not
   modified */
void String_setChar(String*, size_t, char);


#endif

#include "String.h"
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include "error.h"





/** AUXILIARY FUNCTIONS **/


/* returns the power of 2 greater than or equal to `n` */
static unsigned int pow2sup(unsigned int n) {
	
	if(!n)   return 0;
	unsigned int r= 1;
	while(n>r)   r<<=1;
	return r;
	
        /**
        if(!n || !(n&(n-1))   return n;   // solution found here < http://forum.hardware.fr/hfr/Programmation/C-2/quizz-calculer-superieure-sujet_52944_1.htm#t757526 >
        __asm__ (
            "bsr   eax,   n"
            "mov   n,   eax"
        );
        return 1<<n;
        **/
}





/** MAIN FUNCTIONS **/



/* Deletes only a single String object */
static void String_delSingle(String* this) {
	if(this==NULL)   return;
	if(this->blk!=NULL)
		free(this->blk);
	free(this);
}

void String_del(String* this) {
	if(this==NULL)   return;
	if(this->blk!=NULL)
		free(this->blk);
	if(this->next!=NULL)
		String_del(this->next);
	free(this);
}



void String_clear(String* this) {
	if(this==NULL)   return;
	if(this->blk!=NULL) {
		free(this->blk);
		this->blk= NULL;
	}
	if(this->next!=NULL) {
		String_del(this->next);
		this->next= NULL;
	}
	this->blkCapacity= 0;
	this->blkSize= 0;
	this->size= 0;
}



/* Creates only an empty single String object, with the capacity specified;
   /!\  the specified capacity must not be greater than STRING_MAXBLOCKSIZE */
static String* String_newSingle(size_t blkCapac) {
	String* r= malloc(sizeof(String));
	if(r==NULL) {
		errorMessage("malloc", "when allocating"
		  " a single String object.");
		return NULL;
	}
	r->blkCapacity= pow2sup(blkCapac)-1;
	r->blkSize= 0;
	r->size= 0;
	r->next= NULL;
	r->blk= malloc((r->blkCapacity+1)*sizeof(char));
	if(r->blk==NULL) {
		errorMessage("malloc", "when allocating"
		  " the block of a single String object.");
		String_delSingle(r);
		return NULL;
	}
	*r->blk= '\0';
	return r;
}

/* for recursivity in function `String_new` */
static String* String_new_recur(size_t capacity, const char* s) {
	size_t blkCapac= (capacity>STRING_MAXBLOCKSIZE)?
	                 STRING_MAXBLOCKSIZE : capacity;
	String* r= String_newSingle(blkCapac);
	if(r==NULL) {
		errorMessage("String_newSingle", "when allocating"
		  " a single String of a linked String object.");
		return NULL;
	}
	if(s!=NULL) {
		r->size= capacity;
		for(/*r->blkSize=0*/; r->blkSize<blkCapac; ++r->blkSize)
			r->blk[r->blkSize]= s[r->blkSize];
		s+= blkCapac;
	}
	r->blk[r->blkSize]= '\0';
	if(capacity>blkCapac) {
		r->next= String_new_recur(capacity-blkCapac, s);
		if(r->next==NULL) {
			/*errorMessage("String_new_recur", "when allocating"
			  " the following single Strings of a linked String"
			  " object.");*/
			String_delSingle(r);
			return NULL;
		}
	}
	return r;
}

String* String_new(const char* s, size_t capacity) {
	return String_new_recur((s!=NULL)? strlen(s) : capacity, s);
}



void String_write(const String* this, FILE* stream) {
	while(this!=NULL) {
		if(this->blk!=NULL)
			fputs(this->blk, stream);
		this= this->next;
	}
}



size_t String_capacity(const String* this) {
	size_t r;
	for(r=0; this!=NULL; r+=this->blkCapacity, this=this->next);
	return r;
}



void String_concat(String* this, String* src) {
	if (this==NULL || src==NULL)   return;
	while(this->next!=NULL) {
		this->size+= src->size;
		this= this->next;
	}
	this->size+= src->size;
	this->next= src;
}



String* String_copy(const String* this) {
	if(this==NULL)   return NULL;
	String* r;
	r= String_newSingle(this->blkCapacity);
	if(r==NULL) {
		errorMessage("String_newSingle", "when allocating"
		  " a new single String for a copy of a linked String.");
		return NULL;
	}
	strcpy(r->blk, this->blk);
	r->blkSize= this->blkSize;
	r->size= this->size;
	if(this->next!=NULL) {
		r->next= String_copy(this->next);
		if(r->next==NULL) {
			String_delSingle(r);
			return NULL;
		}
	}
	return r;
}



char* String_charP(const String* this, size_t i) {
	if(this==NULL || this->size<=i)   return NULL;
	while(i>=this->blkSize) {
		i-= this->blkSize;
		//if(this->next==NULL)   return NULL;
		this= this->next;
	}
	return this->blk+i;
}



char String_char(const String* this, size_t i) {
	if(this==NULL || this->size<=i)   return '\0';
	while(i>=this->blkSize) {
		i-= this->blkSize;
		//if(this->next==NULL)   return '\0';
		this= this->next;
	}
	return this->blk[i];
}



void String_setChar(String* this, size_t i, char c) {
	if(this==NULL || this->size<=i)   return;
	while(i>=this->blkSize) {
		i-= this->blkSize;
		//if(this->next==NULL)   return '\0';
		this= this->next;
	}
	this->blk[i]= c;
}

#ifndef INCLUDED_ERROR_2011_08_25_17_50_MM
#define INCLUDED_ERROR_2011_08_25_17_50_MM


#include <stdlib.h>   // for size_t
#include <stdarg.h>   // for va_list


/*** FUNCTIONS ***/

/* Writes an error message on stderr, with the name of the file, the line, the
   name of the function in which the error occured, and optionally the name of
   the called function which signaled the error (NULL if not wanted), then an
   optional message in the format of `printf` (NULL if not wanted). */
void errorMessage(const char* file, size_t line, const char* function,
                  const char* calledFunction, const char* msgFmt, ...);
void errorMessage_v(const char* file, size_t line, const char* function,
                    const char* calledFunction, const char* msgFmt, va_list ap);

/* Calls the function aboce and then quits the program with `exit` and the value
   `EXIT_FAILURE` */
void errorQuit(const char* file, size_t line, const char* function,
               const char* calledFunction, const char* msgFmt, ...);

/* macros designed to simplify the use of the functions above */
#define  errorMessage(called, ...)  \
  errorMessage(__FILE__, __LINE__, __func__, called, __VA_ARGS__)
#define  errorMessage_v(called, fmt, ap)  \
  errorMessage_v(__FILE__, __LINE__, __func__, called, fmt, ap)
#define  errorQuit(called, ...)  \
  errorQuit(__FILE__, __LINE__, __func__, called, __VA_ARGS__)


#endif

/* useful macro which prints on stdin the name (or the expression) of the String
   passed, its size, its capacity and its content */
#define DISPSTR(str)   do{\
	const String* _= (str);   \
	if(_==NULL)   puts(#str" is NULL.");   \
	else          printf(#str" (%u/%u): \"", String_size(_), String_capacity(_)), String_disp(_), puts("\"");   \
	               }while(0)

#include <stdio.h>

int main(void)
{
    fputs("Hello World", stdout);
    fputs("Hello World\n", stdout);

    puts("Hello World");
    puts("Hello World\n");

    return 0;
}

Hello WorldHello World
Hello World
Hello World


Process returned 0 (0x0)   execution time : 0.141 s
Press any key to continue.

#ifndef INCLUDED_STRING_2011_08_25_17_30_MM
#define INCLUDED_STRING_2011_08_25_17_30_MM


#include <stdlib.h>   // for size_t
#include <stdio.h>    // for FILE





/*** CONSTANTS ***/



/* see below */
#define  STRING_LOG2BLKSZ          8

/* maximal lenght of a String block */
#define  STRING_TOTALMAXBLOCKSIZE  (1<<STRING_LOG2BLKSZ)

/* maximal lenght of a String block, without the terminating '\0' */
#define  STRING_MAXBLOCKSIZE       (STRING_TOTALMAXBLOCKSIZE-1)





/*** TYPES ***/



/* the String object, to manage large and/or dynamic strings;
   it takes the form of a linked list of datas including an allocated block
   and informations concerning this block and the linked list */
typedef struct String {
	/* used length, without the terminating '\0' */
	unsigned int  blkSize      :STRING_LOG2BLKSZ,
	/* allocated length - 1 */
	              blkCapacity  :STRING_LOG2BLKSZ;
	/* the block itself (terminating with '\0');
	   /!\  must be NULL if no memory is allocated */
	char*  blk;
	/* total size, counting from this block */
	size_t  size;
	/* next block of the String;
	   /!\  must be NULL if this is the last one */
	struct String*  next;
} String;

/* NOTE:
 * Here, "capacity" will mean the allocated length minus 1, the latter being
 * reserved for the terminating '\0'. The "block capacity"  will mean the
 * capacity of the current single String object, when the "[total] capacity"
 * will mean the sum of the capacities of all the single Strings composing the
 * linked String object.
 * Similarly, "size" will mean the used length without the '\0'; the "block
 * size" is the size of the current single String, and the "[total] size" is the
 * sum of the sizes of the single Strings.
 */





/*** FUNCTIONS ***/



/* Creates a new linked String object filled with the content of the string
   passed or, if the 1st argument is NULL, lets it empty but with a specified
   total capacity */
String* String_new(const char*, size_t);



/* Deletes completely the linked String object */
void String_del(String*);

/* Empties the linked String object, setting the total capacity to zero */
void String_clear(String*);



/* Write the content of the String object on the stream */
void String_write(const String*, FILE*);

/* idem, the stream is `stdout` ("displays" the String object) */
static inline void String_disp(const String* this)
	{ String_write(this, stdout); }



/* Returns the total size of the linked String */
static inline size_t String_size(const String* this)
	{ return (this!=NULL)? this->size : 0; }
/* idem */
#define  String_length  String_size

/* Returns the total capacity of the linked String */
size_t String_capacity(const String* this);



/* Creates a copy of the linked String without modifying it */
String* String_copy(const String*);



/* Concatenates the two linked Strings (the 2nd is directly put at the end
   of the 1st, without being copied before) */
void String_concat(String*, String*);

/* Concatenates the 1st linked String and a copy of the second, so the 2nd
   is not modified */
static inline void String_concatCopy(String* this, const String* src)
	{ String_concat(this, String_copy(src)); }



/* Returns the address of the character of index specified in the linked
   String; returns NULL if the index is out of range */
char* String_charP(const String*, size_t);

/* Returns the character of index specified in the linked String; returns
   '\0' if the index is out of range */
char String_char(const String*, size_t);

/* Sets the character of index specified in the linked String to the value
   specified; if it is '\0', then this index will become the end of the
   linked String; if the index is out of range, the linked String is not
   modified */
void String_setChar(String*, size_t, char);


#endif

/**
***  String.h
***
***    module:   String  −  header file
***    function: provides the `String` object type (abstract data type) and
***              functions for using it; the `String` object type is designed to
***              manage dynamic and/or large characters strings.
***              This header is the interface file of the module, it provides
***              the incomplete type declaration of `String` (because `String`
***              is an ADT) and the prototype of the usable functions.
***    author:   Maëlan (aka Maëlan44)
***              (see http://www.siteduzero.com/membres-294-232877.html )
***    website:  http://www.siteduzero.com/forum-83-683766-p1-une-implementation-de-string-en-c.html
***
***    last modified: 09/07/2011, 15:15
***
**/

#ifndef INCLUDED_STRING_2011_08_25_17_30_MM
#define INCLUDED_STRING_2011_08_25_17_30_MM


#include <stddef.h>   // for size_t
#include <stdio.h>    // for FILE





/*** TYPES ***/



/* the String object, to manage large and/or dynamic strings;
   it takes the form of a linked list of datas including an allocated block
   and informations concerning this block and the linked list */
typedef  struct String  String;





/*** FUNCTIONS ***/



/* Creates a String object filled with the content of the string passed; if NULL
   is passed,  lets it null (ie. empty and with no capacity) */
String* String_new(const char*);

/* Creates an empty String object with at least the capacity specified */
String* String_newEmpty(size_t);

/* Creates a new String object that is a copy of the passed one */
String* String_copy(const String*);

/* Deletes completely the String object */
void String_del(String*);



/* Returns the size of the String */
/*extern inline*/  size_t String_size(const String*);
/* idem */
#define  String_length  String_size

/* Returns the capacity of the String */
/*extern inline*/  size_t String_capacity(const String*);

/* boolean: Is the String empty (ie. the size is zero)? */
/*extern inline*/  int String_isEmpty(const String*);

/* boolean: Is the String null (ie. the size and capacity are zero)? */
/*extern inline*/  int String_isNull(const String*);

/* Empties the String, setting its size to zero without altering its capacity */
void String_empty(String*);

/* Empties the String, setting its size and capacity to zero */
void String_clear(String*);



/* Returns the character of index specified in the String; returns '\0' if the
   index is out of range */
char String_char(/*const*/ String*, size_t);

/* Sets the character of index specified in the String to the value specified;
   if it is '\0', then this index will become the end of the String; if the
   index is out of range, the linked String is not modified */
void String_setChar(String*, size_t, char);



/* compare the two Strings the same way as strcmp does */
int String_cmp(const String*, const String*);

/* compare the String object with the ”regular” characters string, the same way
   as strcmp does */
int String_cmpCStr(const String*, const char*);

/* returns the index of the 1st occurrence of the character in the String, or a
   negative number if the the character is no found */
ptrdiff_t String_searchChar(const String*, char c);

/* returns the index of the last occurrence of the character in the String, or a
   negative number if the the character is no found */
ptrdiff_t String_searchLastChar(const String*, char c);



/* Concatenates a copy of the 2nd String object to the first; returns the final
   String, or NULL if there was an error */
String* String_concat(String*, const String*);



/* Write the content of the String on the stream */
void String_fput(const String*, FILE*);

/* idem, the stream is `stdout` */
/*extern inline*/  void String_put(const String*);



/* Returns a buffer containing the content of the String in the form of a plain
   characters string; this buffer shall not be modified by the user, and it may
   be modified by the String functions to stay up-to-date or be freed if it is
   no longer the case */
const char* String_cStr(String*);

/* Returns the buffer containing the "cstr" of the String if it exists and is
   up-to-date, NULL otherwise */
/*extern inline*/  const char* String_getCStr(const String*);


#endif

/**
***  String.c
***
***    module:   String  −  source file
***    function: provides the `String` object type (abstract data type) and
***              functions for using it; the `String` object type is designed to
***              manage dynamic and/or large characters strings.
***              This file is the main source file of the module, it contains
***              the full declaration of the type `String`, as well as others
***              types and additionnal function declarations (static), both used
***              internally by the implementation. Of course it contains (in
***              fact, includes) also the definitions of all the functions.
***    author:   Maëlan (aka Maëlan44)
***              (see http://www.siteduzero.com/membres-294-232877.html )
***    website:  http://www.siteduzero.com/forum-83-683766-p1-une-implementation-de-string-en-c.html
***
***    last modified: 09/06/2011, 18:40
***
**/

#include "String.h"
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include "error.h"





/*** CONSTANTS ***/



/* see below */
#define  STRING_LOG2BLKSZ      8

/* maximal lenght of the buffer of a String block */
#define  STRING_TOTALMAXBLKSZ  (1<<STRING_LOG2BLKSZ)

/* maximal lenght of the buffer of a String block, without the terminating '\0' */
#define  STRING_MAXBLKSZ       (STRING_TOTALMAXBLKSZ-1)

/* lenght of the static buffer of a String block; it is designed for a struct of
   type `StringBlock` to fit in 32 bytes */
//#define  STRING_TOTALBUFSZ     ( (32-sizeof(*char)-2*STRING_LOG2BLKSZ/8)       \
                                 / sizeof(char) )
#define STRING_TOTALBUFSZ 19

/* lenght of the static buffer of a String block, without the terminating '\0' */
#define  STRING_BUFSZ          (STRING_TOTALBUFSZ-1)





/*** TYPES ***/



/* NOTE:
 * Here, "block capacity" will mean the allocated length for the block minus 1,
 * the latter being reserved for the terminating '\0'. The "String capacity" or
 * "total capacity" will mean the sum of the capacities of all the blocks
 * composing the String.
 * Similarly, "block size" will mean the used length without the '\0'. The
 * "String size" of "total size" is the sum of the sizes of all the blocks.
 */



/* a String block, link of a linked list;
   contains a buffer and informations for using it */
typedef struct StringBlk {
	/* static buffer: optimisation for short strings or string blocks
	   [OPT:buf] */
	char buf[STRING_TOTALBUFSZ];
	/* buffer; shall point to the member `buf` if it is used, else to the
	   allocated memory
	   /!\  Shall never be NULL! */
	char* p;
	/* block size (shall be lesser than or equal to the member `capac`) */
	unsigned int size   :STRING_LOG2BLKSZ,
	/* block capacity (shall be at least STRING_BUFSZ, since it is the size
	   of the static buffer; can not be greater than STRING_MAXBLKSZ) */
	             capac  :STRING_LOG2BLKSZ;
	/* block following this one in the linked list */
	struct StringBlk* next;
} StringBlk;



/* the String object itself;
   it takes the form of a linked list of blocks, each including a buffer and
   informations concerning it */
struct String {
	/* total length */
	size_t  size,
	/* total capacity */
	        capac;
	/* first block of the string */
	StringBlk *first,
	/* last block: optimisation for operations on the end of the string,
	   such as concatenating or adding a character [OPT:last] */
	          *last;
	/* optimisation: a cursor pointing to the last character read [OPT:cur] */
	struct {   size_t pos;   /* index of the 1st char. of the block pointed */
	           StringBlk* blk;
	       } cur;
	/* buffer containing the full character string obtained via
	   `String_cStr` (and returned as constant); shall be NULL if this
	   function had not be called yet, or if the content is outdated (in
	   this case, it shall be freed if needed).
	   For reasons of optimisation, this buffer can be that of the first
	   block of the String, in which case it shall not be freed.
	   If the buffer exists, it can be used to perform optimisations on
	   operations involving reading content [OPT:cstr]. */
	char* cStr;
};





/*** AUXILIARY FUNCTIONS ***/



/* returns the power of 2 greater than or equal to `n` */
static  unsigned int pow2sup(unsigned int n) {
	
	if(!n)   return 0;
	unsigned int r= 1;
	while(n>r)   r<<=1;
	return r;
	
        /**   // solution found here < http://forum.hardware.fr/hfr/Programmation/C-2/quizz-calculer-superieure-sujet_52944_1.htm#t757526 >
        if(!n || !(n&(n-1))   return n;
        __asm__ (
            "bsr   eax,   n"
            "mov   n,   eax"
        );
        return 1<<n;
        **/
}





/*** MAIN FUNCTIONS ***/



/** functions for object `StringBlock` **/


/* Creates a new String block filled with the content of the string passed, or
   at most its STRING_MAXBLKSZ first characters; the second argument must be the
   size of the string passed */
static  StringBlk* StringBlk_new(const char*, size_t);

/* Creates a new empty String block with at least the specified capacity */
static  StringBlk* StringBlk_newEmpty(unsigned int);

/* Creates a copy of the String block (ie. a new String block filled with the
   content of the one passed) */
static inline  StringBlk* StringBlk_copy(const StringBlk*);

/* Deletes the String block and all the following String blocks of the linked
   list to which it belongs */
static  void StringBlk_del(StringBlk*);

/* boolean: Does the String block uses its static buffer? */
static inline  int StringBlk_useStaticBuf(const StringBlk* this);


#include "String.c.1"



/** functions for object `String` **/


/* boolean: Has the String an existing "cstr"? */
static inline  int String_hasCStr(const String*);

/* boolean: Has the String an existing "cstr", the buffer of which is also that
   of the 1st block? */
static inline  int String_hasSharedCStr(const String*);

/* boolean: Has the String an existing "cstr", the buffer of which is allocated
   separately? */
static inline  int String_hasSeparateCStr(const String*);

/* Delete the "cstr" of the String */
static inline  void String_delCStr(String*);


#include "String.c.2"

/**
***  String.c.1
***
***    module:   String  −  source file (part 1)
***    function: provides the `String` object type (abstract data type) and
***              functions for using it; the `String` object type is designed to
***              manage dynamic and/or large characters strings.
***              This file contains the definitions of functions working on the
***              `StringBlock` object type.
***    author:   Maëlan (aka Maëlan44)
***              (see http://www.siteduzero.com/membres-294-232877.html )
***    website:  http://www.siteduzero.com/forum-83-683766-p1-une-implementation-de-string-en-c.html
***
***    last modified: 09/07/2011, 20:45
***
**/





static  StringBlk* StringBlk_newEmpty(unsigned int capac) {
	StringBlk* r =  malloc(sizeof(StringBlk));
	if(r==NULL) {
		errorMessage("malloc", "when allocating a String block");
		return NULL;
	}
	
	if(capac<=STRING_BUFSZ) {
		r->p =      r->buf;
		r->capac =  STRING_BUFSZ;
	} else {
		r->capac =  (capac>STRING_MAXBLKSZ)? STRING_MAXBLKSZ : capac;
		//r->capac =  log2sup(r->blk.capac) - 1;
		r->p =  malloc((r->capac+1)*sizeof(char));
		if(r->p == NULL) {
			errorMessage("malloc", "when allocating a dynamic"
			 " buffer for a String block");
			free(r);
			return NULL;
		}
	}
	
	*r->p =    '\0';
	r->size =  0;
	//r->next =      NULL;
	
	return r;
}



static  StringBlk* StringBlk_new(const char* s, size_t size) {
	StringBlk* r;
	
	//if(s==NULL)    size =  0;
	r =  StringBlk_newEmpty(size);
	if(r==NULL)    return NULL;
	
	r->size =  (size > r->capac)? r->capac : size;
	/*if(s!=NULL)    */strncpy(r->p, s, r->size);
	r->p[r->size] =  '\0';
	
	return r;
}



static inline  StringBlk* StringBlk_copy(const StringBlk* this)
	{ //if(this==NULL)    return NULL;
	return StringBlk_new(this->p, this->size); }



static  void StringBlk_del(StringBlk* this) {
	StringBlk* blk;
	while(this!=NULL) {
		blk =   this;
		this =  this->next;
		if(!StringBlk_useStaticBuf(blk))
			free(blk->p);
		free(blk);
	}
}





static inline  int StringBlk_useStaticBuf(const StringBlk* this)
	{ return this->p == this->buf; }

/**
***  String.c.2
***
***    module:   String  −  source file (part 2)
***    function: provides the `String` object type (abstract data type) and
***              functions for using it; the `String` object type is designed to
***              manage dynamic and/or large characters strings.
***              This file contains the definitions of functions working on the
***              `String` object type.
***    author:   Maëlan (aka Maëlan44)
***              (see http://www.siteduzero.com/membres-294-232877.html )
***    website:  http://www.siteduzero.com/forum-83-683766-p1-une-implementation-de-string-en-c.html
***
***    last modified: 09/07/2011, 18:50
***
**/





/**  CREATION, DELETION
 **    newEmpty, new, copy, del
 **/



String* String_newEmpty(size_t capac) {
	String* r;
	StringBlk** p;

	r =  malloc(sizeof(String));
	if(r==NULL) {
		errorMessage("malloc", "when allocating a String");
		return NULL;
	}
	
	r->capac =  0;
	p =  &r->first;
	do {    /* at least one block (so STRING_BUFSZ) is created, even if the
	           capacity required is 0 */
		*p =  StringBlk_newEmpty(capac-r->capac);
		if(*p==NULL) {
			errorMessage("StringBlk_newEmpty", "when creating a"
			 " String block");
			String_del(r);
			return NULL;
		}
		r->capac +=  (*p)->capac;
		if(capac > r->capac)    p =  &(*p)->next;
	} while(capac > r->capac);
	
	r->last =     *p;
	(*p)->next =  NULL;
	
	r->size =     0;
	r->cur.pos =  0;
	r->cur.blk =  r->first;
	r->cStr =     r->first->p;
	
	return r;
}



String* String_new(const char* s) {
	String* r;
	
	r =  malloc(sizeof(String));
	if(r==NULL) {
		errorMessage("malloc", "when allocating a String");
		return NULL;
	}
	
	r->size =   0;
	r->capac =  0;
	if(s==NULL) {
		r->first =  NULL;
		r->last =   NULL;
	} else {
		size_t size =  strlen(s);
		StringBlk** p =  &r->first;
		do {
			*p =  StringBlk_new(s+r->size, size-r->size);
			if(*p==NULL) {
				errorMessage("StringBlk_new", "when creating a"
				 " String block");
				String_del(r);
				return NULL;
			}
			r->capac +=  (*p)->capac;
			r->size +=   (*p)->size;
			if(size != r->size)    p =  &(*p)->next;
		} while(size != r->size);
		r->last =     *p;
		(*p)->next =  NULL;
	}
	
	r->cur.pos =  0;
	r->cur.blk =  r->first;
	r->cStr =     NULL;
	
	return r;
}



String* String_copy(const String* this) {
	if(this==NULL)    return NULL;
	
	if(String_hasCStr(this))
		return String_new(this->cStr);
	
	String* r;
	
	r =  malloc(sizeof(String));
	if(r==NULL) {
		errorMessage("malloc", "when allocating a String");
		return NULL;
	}
	
	StringBlk *blk =  this->first,
	          **p =   &r->first;
	r->size =   0;
	r->capac =  0;
	if(blk==NULL)    r->first =  NULL;
	else while(blk!=NULL) {
		*p =  StringBlk_copy(blk);
		if(*p==NULL) {
			errorMessage("StringBlk_copy", "when creating a copy of"
			 " a String block");
			 String_del(r);
			 return NULL;
		}
		r->capac +=  (*p)->capac;
		r->size +=   (*p)->size;
		blk =  blk->next;
		if(blk!=NULL)    p =  &(*p)->next;
	}
	r->last =     *p;
	(*p)->next =  NULL;
	r->cur.pos =  0;
	r->cur.blk =  r->first;
	r->cStr =     NULL;
	
	return r;
}



void String_del(String* this) {
	if(this==NULL)    return;
	if(String_hasSeparateCStr(this))
		free(this->cStr);
	if(!String_isNull(this))
		StringBlk_del(this->first);
	free(this);
}





/**  SIZE, CAPACITY
 **    size, capacity, isEmpty, isNull, empty, clear
 **/



inline  size_t String_size(const String* this)
	{ return (this!=NULL)? this->size : 0; }



inline  size_t String_capacity(const String* this)
	{ return (this!=NULL)? this->capac : 0; }



inline  int String_isEmpty(const String* this)
	{ return (this!=NULL)? !this->size : 1; }



inline  int String_isNull(const String* this)
	{ return (this!=NULL)? !this->capac : 1; }



void String_empty(String* this) {
	if(this==NULL)    return;
	StringBlk* p =  this->first;
	while(p!=NULL) {
		*p->p =    '\0';
		p->size =  0;
		p =        p->next;
	}
	this->size =  0;
}



void String_clear(String* this) {
	if(this==NULL)    return;
	if(String_hasCStr(this)) {
		if(String_hasSeparateCStr(this))
			free(this->cStr);
		this->cStr =  NULL;
	}
	if(!String_isNull(this)) {
		StringBlk_del(this->first);
		this->first =  NULL;
		this->last =   NULL;
	}
	this->capac =    0;
	this->size =     0;
	this->cur.pos =  0;
	this->cur.blk =  NULL;
}





/**  CSTR
 **    getCStr, delCStr, hasCStr, hasSharedCStr, hasSeparateCStr
 **/



inline  const char* String_getCStr(const String* this)
	{ return this->cStr; }



void String_delCStr(String* this) {
	free(this->cStr);
	this->cStr =  NULL;
}



static inline  int String_hasCStr(const String* this)
	{ return this->cStr != NULL; }



static inline  int String_hasSharedCStr(const String* this)
	{ return this->capac  &&  this->cStr == this->first->p; }



static inline  int String_hasSeparateCStr(const String* this)
	{ return this->cStr != NULL  &&  this->cStr != this->first->p; }





/**  BASIC READ / WRITE
 **    char, setChar
 **/



char String_char(/*const*/ String* this, size_t i) {
	if(this==NULL || i>=this->size)    return '\0';
	
	if(String_hasCStr(this))    return this->cStr[i];
	
	if(i < this->cur.pos) {
		this->cur.pos =  0;
		this->cur.blk =  this->first;
	}
	while(i >= this->cur.pos + this->cur.blk->size) {
		this->cur.pos +=  this->cur.blk->size;
		this->cur.blk =   this->cur.blk->next;
	}
	return this->cur.blk->p[i - this->cur.pos];
}





void String_setChar(String* this, size_t i, char c) {
	if(this==NULL || i>=this->size)    return;
	
	if(i < this->cur.pos) {
		this->cur.pos =  0;
		this->cur.blk =  this->first;
	}
	while(i >= this->cur.pos + this->cur.blk->size) {
		this->cur.pos +=  this->cur.blk->size;
		this->cur.blk =   this->cur.blk->next;
	}
	this->cur.blk->p[i-this->cur.pos] =  c;
	
	if(c=='\0') {
		this->size =  i;
		this->cur.blk->size =  i - this->cur.pos;
		this->last =  this->cur.blk;
		if(this->last->next!=NULL) {
			StringBlk_del(this->last->next);
			this->last->next =  NULL;
		}
	}
	
	if(String_hasSeparateCStr(this)) {
		this->cStr[i] =  c;
		if(c=='\0') {
			// cf here: < http://www.siteduzero.com/forum-83-704272-p1-causes-d-echec-de-realloc.html >
			char* tmp =  realloc(this->cStr, (i+1)*sizeof(char));
			if(tmp==NULL)
				String_delCStr(this);
			else
				this->cStr =  tmp;
		}
	}
}





/**  UTILITIES
 **    cmp, cmpCStr, searchChar, searchLastChar
 **/



int String_cmp(const String* s1, const String* s2) {
	if(String_isEmpty(s1))    return !String_isEmpty(s2);
	if(String_isEmpty(s2))    return -1;
	
	if(String_hasCStr(s1) && String_hasCStr(s2))
		return strcmp(s1->cStr, s2->cStr);
	
	StringBlk *b1 =  s1->first,
	          *b2 =  s2->first;
	size_t i1 =  0,
	       i2 =  0;
	
	while(b1->p[i1] == b2->p[i2]) {
		if(b1->p[i1]=='\0')    return 0;
		++i1;    ++i2;
		while(i1 >= b1->size) {    /* while and not if, since there can
		                             be empty blocks */
			i1 =  0;
			b1 =  b1->next;
			if(b1==NULL)    return s1->size < s2->size;
		}
		while(i2 >= b2->size) {
			i2 =  0;
			b2 =  b2->next;
			if(b2==NULL)    return -(s1->size > s2->size);
		}
	}
	return  (b1->p[i1] > b2->p[i2])?  -1 : 1;
}



int String_cmpCStr(const String* this, const char* s) {
	if(String_isEmpty(this))    return s!=NULL && *s!='\0';
	if(s==NULL || *s=='\0')     return -1;
	
	if(String_hasCStr(this))
		return strcmp(this->cStr, s);
	
	StringBlk *blk =  this->first;
	size_t i =  0,
	       j =  0;
	
	while(blk->p[i] == s[j]) {
		if(s[j]=='\0')    return 0;
		++i;    ++j;
		while(i >= blk->size) {    /* while and not if, since there can
		                             be empty blocks */
			i =    0;
			blk =  blk->next;
			if(blk==NULL)    return s[j]!='\0';
		}
	}
	return  (blk->p[i] > s[j])?  -1 : 1;
}



ptrdiff_t String_searchChar(const String* this, char c) {
	if(String_isEmpty(this))    return (c=='\0')? 0 : -1;
	if(c=='\0')                 return this->size;
	
	if(String_hasCStr(this))    return strchr(this->cStr, c) - this->cStr;
	
	StringBlk* blk =  this->first;
	size_t pos =      0;
	char* r;
	while(blk!=NULL) {
		r =  strchr(blk->p, c);
		if(r!=NULL)    return r - blk->p + pos;
		pos +=  blk->size;
		blk =   blk->next;
	}
	return -1;
}



ptrdiff_t String_searchLastChar(const String* this, char c) {
	if(String_isEmpty(this))    return (c=='\0')? 0 : -1;
	if(c=='\0')                 return this->size;
	
	if(String_hasCStr(this))    return strrchr(this->cStr, c) - this->cStr;
	
	StringBlk* blk =   this->first;
	size_t pos =       0;
	char* r;
	ptrdiff_t found =  -1;
	while(blk!=NULL) {
		r =  strrchr(blk->p, c);
		if(r!=NULL)    return found =  r - blk->p + pos;
		pos +=  blk->size;
		blk =   blk->next;
	}
	return found;
}





/**  INSERTION
 **    concat
 **/



String* String_concat(String* this, const String* s2) {
	if(this==NULL)    return NULL;
	if(s2==NULL)      return this;
	
	String* cpy =  String_copy(s2);
	if(cpy==NULL) {
		errorMessage("String_copy", "when copying a String to add it to"
		 " the end of another one");
		return NULL;
	}
	
	if(String_isNull(this))    this->first =       cpy->first;
	else                       this->last->next =  cpy->first;
	this->last =    cpy->last;
	this->capac +=  cpy->capac;
	this->size +=   cpy->size;
	/*  /!\  UPDATE CSTR DATAS */
	
	free(cpy);
	return this;
}





/**  IN / OUT
 **    fput, put
 **/



void String_fput(const String* this, FILE* stream) {
	if(this==NULL || stream==NULL)    return;
	StringBlk* p =  this->first;
	while(p!=NULL) {
		fputs(p->p, stream);
		p =  p->next;
	}
}



inline  void String_put(const String* this)
	{ String_fput(this, stdout); }