#include <stdio.h>
#include <string.h>
#define false 0
#define true  1

void GenereErreur (char * szErreur)
{
	printf (szErreur);
	printf ("\n");
}

/****************************************************************************/
// Mettre en majuscule tous les caractères d'une ligne
//
// En entrée, szLigne pointe sur la ligne a convertir
// En sortie, la ligne est en majuscule
// Test ok le 14/03/06
/****************************************************************************/
void Majuscule (char * szLigne)
{
 char * szLigneTrt;
 int iCpt;
 
 szLigneTrt = szLigne;
 
 if (strlen (szLigne) > 0)
 {
    iCpt = 0;
    do
    {
            if (*szLigneTrt >= 'a' && *szLigneTrt <= 'z')
            {
               *szLigneTrt = *szLigneTrt - 'a' + 'A';                            
            }
            szLigneTrt++;
            iCpt++;
    }while (iCpt < strlen(szLigne));           
 }     
}

int NumEntries (char * szLigne, char cSeparateur)
{
	int iTaille, iCpt, iNumEntries = 1;
	char * szLigneTrt;

    szLigneTrt = szLigne;
    
	iTaille = strlen(szLigne);
	if (iTaille > 0)
	{
		iCpt = 0;
		do
		{
			if (*szLigneTrt == cSeparateur)
				iNumEntries ++;
			szLigneTrt++;
		}while (++iCpt < iTaille);
	}

	return iNumEntries;
}

/***************************************************************************/
// Recherche et extrait du texte � partir d'un s�parateur et d'une position donn�e
// En entr�e, pointeur sur szLigne qui contient la ligne a traiter, 
//  Entier indiquant la position � atteindre par rapport au s�parateur
// 1 char pour indiquer le s�parateur
// 
// En sortie, Le ou les mots se trouvant apr�s le s�parateur
// Test ok le 14/03/06
/***************************************************************************/
int FnctEntry (char* szLigne, int iPosition, char cSeparateur, char* szResultat)
{
	char * szLigneTrt;
	char * szResultatTrt;
	int iPositionTrt;

	szResultatTrt = szResultat;
	iPositionTrt = 1;
	szLigneTrt = szLigne;

	if (iPosition > 1)
	{
		do
		{
			if (*szLigneTrt == cSeparateur)
				iPositionTrt++;

			szLigneTrt++;
		}while (iPositionTrt < iPosition && *szLigneTrt != 0 && *szLigneTrt != 13 && *szLigneTrt != 10);
	}

	if (iPositionTrt == iPosition)
	{
		if (*szLigneTrt != 0 && *szLigneTrt != 13 && *szLigneTrt != 10)
		{
			do
			{
				if (*szLigneTrt != cSeparateur && *szLigneTrt != 0 && *szLigneTrt != 13 && *szLigneTrt != 10)
				{
					*szResultatTrt = *szLigneTrt;
					szResultatTrt++;
					szLigneTrt++;
				}
			}while (*szLigneTrt != cSeparateur && *szLigneTrt != 0 && *szLigneTrt != 13 && *szLigneTrt != 10);		
		}
	}
	else
	{
		*szResultat = 0;
		return false;
	}

	*szResultatTrt = 0;
	return true;
}

/***************************************************************************/
// Supprime les espaces au d�but et en fin de ligne
// En entr�e, pointeur sur szLigne qui contient la ligne a traiter, 
//  Pointeur de type entier sur la taille de la ligne (Taille qui pourra �tre � 0 si la chaine se termine par 0)
// En sortie, ligne rectifi�, et iTaille contient la nouvelle taille de la ligne
// Test ok le 14/03/06
/***************************************************************************/
int SupprimeEspaceAvAp (char * szLigne, int *iTaille)
{
	char * szLigneTrtDeb;
	char * szLigneTrtFin;
	char szLigneConv[1000];

	int iCptTrtFin;


	if (*iTaille != 0)
		iCptTrtFin = *iTaille;
	else
		iCptTrtFin = strlen (szLigne);

	szLigneTrtDeb = szLigne;

	if (*szLigneTrtDeb == ' ')
	{
		szLigneTrtDeb = szLigne;

		do
		{
			szLigneTrtDeb+=1;
		}while (*szLigneTrtDeb == ' ');
	}

	if (*szLigneTrtDeb != 0)
	{
		szLigneTrtFin = szLigne + iCptTrtFin - 1;

		if (*szLigneTrtFin == ' ' && szLigneTrtFin > szLigneTrtDeb)
		{
			do
			{
				szLigneTrtFin-=1;
			}while (*szLigneTrtFin == ' ' && szLigneTrtFin > szLigneTrtDeb);
		}
		
		if (szLigneTrtFin > szLigneTrtDeb || (szLigneTrtFin == szLigneTrtDeb && *szLigneTrtDeb != 0 && *szLigneTrtDeb != ' '))
		{
			*iTaille = szLigneTrtFin - szLigneTrtDeb + 1;
			memcpy (szLigneConv, szLigneTrtDeb, *iTaille);
			szLigneConv[*iTaille] = 0;
			strcpy (szLigne, szLigneConv);
			return true;
		}
		else
			return false;

	}
	else
		return false;
}

/*-------------------------------------------------------------------------*/
// Extraction de la ligne contenu dans un buffer.
// Cette extraction supprimant les retours chariot �ventuels.
// La fonction retourne aussi un nouveau pointeur sur la prochaine ligne � traiter
// lors du prochain appel � la fonction ainsi que la taille restante du buffer � traiter.
//
// En entr�e:
// cBufferParam Pointeur sur les datas de la section
// resultat pointeur sur une cha�ne vide qui recevra la ligne suivante en sortie
// iTailleBuffer: pointeur sur un entier contenant la taille en caract�re du buffer section
// iTailleResult: pointeur sur un entier contenant la taille maxi du champ resultat
// 
// En sortie 
// cBufferParam un pointeur sur le debut de la ligne suivante, 
// resultat: Contient la ligne extraite du buffer section (sans 13, 10 et 0)
// iTailleBuffer : Taille du buffer restant � lire pour le prochain appel
// iTailleResultat: Taille de la ligne extraite (� 0 si la ligne ne contient que du 13,10,0)
// 
// Si la fonction retourne vrai, il y a bien une ligne � traiter dans resultat
// Sinon, on a atteind la fin du buffer, plus rien � traiter !
//
// Code test� et ok le 03/03/06
//
/*-------------------------------------------------------------------------*/
/* exemple de code utilisant la fonction: avec szSection le buffer sur les datas de la section...
Ex. char szsection [] = "  Data section1 \n blabla\n\n\nABC\ncoucou";

	char resultat[300];
	char * BufSec;
	int TailleSection, iTailleResult;
	int iNumSect;
	bool bResult;

	cBufferParam = szsection;
	iTaille = strlen (szsection);
	
	
	BufSec = 0;
	iNumSect = 0;

	do
	{
		
		iTailleResult = 300;
		bResult = ExtraireLigne(&cBufferParam, resultat, &iTaille, &iTailleResult);
		
	} while (bResult);

	return 0;
*/

int ExtraireLigne(char **cBuffer, char *resultat, int *iTailleBuffer, int *iTailleResult)
{
	char *cBufferTrt;
	int iTailleTrtResult, iTailleBufferTrt;
	iTailleTrtResult = 0;
	iTailleBufferTrt = *iTailleBuffer;

	memset (resultat, 0, *iTailleResult);

	if (**cBuffer != 0 && *iTailleBuffer > 0)
	{
		cBufferTrt = *cBuffer;
		do
		{


			if (*cBufferTrt == 13 || *cBufferTrt == 10 || *cBufferTrt == 0)
			{
				if (*cBufferTrt == 13 && *(cBufferTrt+1) == 10 )
				{
					cBufferTrt+=1;
					iTailleBufferTrt-=1;
				}
				cBufferTrt+=1;
				iTailleBufferTrt-=1;

				*cBuffer = cBufferTrt;
				*iTailleResult = iTailleTrtResult;
				*iTailleBuffer = iTailleBufferTrt;
				return true;
			}
			else
			{
				if (cBufferTrt+1 <= *cBuffer + *iTailleBuffer)
				{
					if (iTailleTrtResult != -1 && iTailleTrtResult < *iTailleResult)
					{
						*resultat = *cBufferTrt;
						resultat++;
						iTailleTrtResult++;
						cBufferTrt+=1;
						iTailleBufferTrt-=1;
					}
					else
						iTailleTrtResult = -1;
				}
				else
				{
					*cBuffer = cBufferTrt;
					*iTailleResult = iTailleTrtResult;
					*iTailleBuffer = iTailleBufferTrt;
					return true;
				}
			}
		}while (cBufferTrt < *cBuffer + *iTailleBuffer);
		*cBuffer = cBufferTrt;
		*iTailleResult = iTailleTrtResult;
		*iTailleBuffer = iTailleBufferTrt;
		return true;
	}
	else
		return false;
}
