1 files changed, 118 insertions, 10 deletions

diff --git a/src/slices.c b/src/slices.c
index edae571..8e9aee6 100755
--- a/src/slices.c
+++ b/src/slices.c
@@ -1,8 +1,12 @@
 #include <string.h>
 #include "slices.h"
 
+int min(int a, int b) { return (a<b)?a:b; }
+
 slice_t *sliceNew(address_t begin, address_t end, sliceStatus_t status, slice_t *next) {
-	slice_t *s = malloc(1*sizeof(slice_t));
+	slice_t *s;
+
+	s = malloc(1*sizeof(slice_t));
 	if (s!=NULL) {
 		s->begin=begin;
 		s->end=end;
@@ -13,8 +17,62 @@ slice_t *sliceNew(address_t begin, address_t end, sliceStatus_t status, slice_t
 	return s;
 }
 
-int sliceSplit(slice_t *slice, address_t splitAt, sliceStatus_t statusBefore, sliceStatus_t statusAt, sliceStatus_t statusAfter) {
-	return 1;
+// Return the numbers of slices after split (3 in the general case, 2 or 1 in particular cases. -1 is memory error)
+int sliceSplit(slices_t *slices, slice_t *initialSlice, address_t splitAt, sliceStatus_t statusBefore, sliceStatus_t statusAt, sliceStatus_t statusAfter) {
+	slice_t *secondSlice, *thirdSlice, *rightSlice;
+	int splitAfterSingularity, splitBeforeSingularity;
+
+	/* Basically, we want to split the slice in 3 :
+	[a;b] shoud be transformed in : [a;splitAt-1], [splitAt;splitAt], [splitAt+1;b]
+	There is exceptions and singularities :
+	* If splitAt is not within [a;b], bail out, no coherent solution
+	* If splitAt==a, the first slice should not exists
+	* If splitAt==b, the last slice shoud not exists
+	* If a==b (and so, ==splitAt), there is nothing to split, just change status
+	But, if statusBefore==statusAt, we don't want an interval [splitAt;splitAt], we want just split in 2.
+	This unwanted interval should be kept merged with the first interval.
+
+	For pratical reasons with pointer mess-up, the first action is to split between the second and the last slice
+	and then between he first and second if needed.
+	*/
+
+	if ( splitAt < initialSlice->begin || splitAt > initialSlice->end ) return 2;
+	
+	// Test before act because we'll change values of the initialSlice because
+	//  it would become the firstSlice or even the second one if the first is zero-lenght
+	splitAfterSingularity=(splitAt != initialSlice->end);
+	splitBeforeSingularity=(splitAt != initialSlice->begin) && (statusBefore != statusAt);
+
+	if ( splitAfterSingularity ) {
+		thirdSlice = sliceNew(splitAt+1, initialSlice->end, statusAfter, initialSlice->next);
+		if ( thirdSlice == NULL ) return -1;
+
+		initialSlice->end = splitAt;
+		// No status change because we'll split again in 2 parts or not
+		initialSlice->next = thirdSlice;
+		if ( initialSlice == slices->last ) slices->last = thirdSlice;
+		(slices->count)++;
+
+		rightSlice=thirdSlice;
+	} else {
+		rightSlice=initialSlice->next;
+	}
+
+	if ( splitBeforeSingularity ) {
+		secondSlice = sliceNew(splitAt, splitAt, statusAt, rightSlice);
+		if ( secondSlice == NULL ) return -1;
+		
+		initialSlice->end = splitAt-1;
+		initialSlice->status=statusBefore;
+		initialSlice->next = secondSlice;
+		if ( initialSlice == slices->last ) slices->last = secondSlice;
+		(slices->count)++;
+	} else {
+		initialSlice->status=statusAt; // Two cases : a==splitAt or statusAt==statusBefore
+	}
+
+	
+	return 1 + (splitBeforeSingularity?1:0) + (splitAfterSingularity?1:0);
 }
 
 slices_t *slicesNew() {
@@ -29,25 +87,75 @@ slices_t *slicesNew() {
 }
 
 void slicesAppend(slices_t *slices, slice_t *slice) {
-
+	slice->next=NULL; //XXX Could be generalized
+	if (slices->first==NULL || slices->last==NULL) {
+		slices->first = slice;
+	} else {
+		slices->last->next=slice;
+	}
+	slices->last=slice;
+	(slices->count)++;
 }
 
 slice_t *slicesFindLargest(slices_t *slices, sliceStatus_t status) {
-	return NULL;
+	slice_t *curr, *sMax = NULL;
+	address_t i, iMax = 0;
+	
+	curr = slices->first;
+	while (curr != NULL) {
+		i=curr->end - curr->begin + 1;
+		if ( curr->status == status && i > iMax ) {
+			iMax = i;
+			sMax = curr;
+		}
+		curr=curr->next;
+	}
+	return sMax;
 }
 
-char *slicesDump(slices_t *slices, int charCount, address_t begin, address_t end) {
+char *slicesDump(slices_t *slices, address_t *blockSize, unsigned int charCount, address_t begin, address_t end) {
 	slice_t *curr = slices->first;
-	address_t sb,se, blockSize=(end-begin)/(charCount+1);
-	char *dump=malloc(1*charCount+1);
+	unsigned int sb,se,i;
+	char *dump, ci;
+
+	// If blockSize is 0, try to autodetect to display entire slice chain
+	if (*blockSize == 0) {
+		*blockSize=(end-begin+1)/(charCount+1);
+		// If we have a too big zoom factor, draw it at 1:1 scale
+		if (*blockSize==0) *blockSize=1;
+	}
+
+	dump = malloc(charCount+1);
+	if (dump==NULL) { return NULL; }
 	memset(dump, ' ', charCount);
+	dump[charCount]=0;
 
 	while (curr != NULL) {
-		sb=curr->begin;
-		// TODO : boucle pour dessiner les caractères correspondant selon le type de zone. Attention aux cas ou 1 caractère contient la frontière de plusieurs zones (ne pas toujours écraser avec la dernière valeur)
+		sb=curr->begin / *blockSize; //FIXME : gérer le max également !
+		se=min(curr->end / *blockSize,charCount-1);
+
+		switch (curr->status) {
+			case S_UNKNOWN:		ci='_'; break;
+			case S_UNREADABLE:	ci='!'; break;
+			case S_RECOVERED:	ci='.'; break;
+			default:		ci='~'; break;
+		}
+
+		for (i=sb;i<=se;i++) {
+			if (dump[i] == ' ' ) {
+				// This is a new information
+				dump[i]=ci;
+			} else if ( dump[i] == ci || dump[i] == '!' ) {
+				// Already the right information or error, don't modify
+			} else {
+				// Multiple information on the same character
+				dump[i]='#';
+			}
+		}
 
 		curr=curr->next;
 	}
 
 	return dump;
 }
+