FONCTIONS DE TRAITEMENT RAPIDE DE CHAINES ET FICHIER

#include <vcl.h>
#include <dir.h>
#include <stdio.h>
#include "text.h"
#pragma hdrstop
#pragma inline

//---------------------------------------------------------------------------
//---------------------------------------------------------------------------

void tomin(char *ZString);  // convertir une chaine en minuscules
void tomaj(char *ZString);  // convertir une chaine en majuscules
char Tolower(char ZString); //
char Toupper(char ZString); // convertit un caractere en
void Strcpy(char *ch1, char *ch2);
void Strcat(char *ch1, char *ch2);
int  Atoi(char *ZString);// convertit une chaine en integer
unsigned int Strlen(char *ZString);   // retourne la longueur d'une chaine

bool file_available(char *mossieu); // retourne vrai si fichier existeu
long filesize(FILE *safe); // retourne la taille d'un fichier ouvert
void copyfile(char *setFrench,char *getFrench);// copier un fichier
void ajouter_mot_au_fichier(FILE *fichier, char *chemin,char *mot);
int  trouvermot_dans_fichier(FILE *fichier, char *tst);


//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
// tomin: convertit une chaine en minuscules
void tomin(char *ZString)
{
asm{
   mov ecx,ZString
   debut2:
   mov al, BYTE PTR [ecx]
   cmp al,0
   je short fin2
   cmp al, 41h
   jb short inter2
   cmp al, 5Ah
   ja short inter2
   or al, 20h
   mov BYTE PTR [ecx], al
   inter2:
   inc ecx
   jmp short debut2
   fin2:
   mov ecx, [ZString]
   }
}

//---------------------------------------------------------------------------
// tomaj: convertit une chaine en majuscules
void tomaj(char *ZString)
{
asm{
   mov edx,ZString
   debut:
   mov al, BYTE PTR [ecx]
   cmp al,0
   je short fin
   cmp al, 61h
   jb short inter
   cmp al, 7Ah
   ja short inter
   and  al, 0DFh
   mov BYTE PTR [ecx], al
   inter:
   inc ecx
   jmp short debut
   fin:
   mov ecx, [ZString]
   }
}

//---------------------------------------------------------------------------
char Tolower(char ZString)
{
asm{
    mov al, ZString
    cmp al,0       // ==0
    je short fini
    cmp al, 41h    // <'A'
    jb short fini
    cmp al, 5Ah    // >'Z'
    ja short fini
    or al, 20h     // minusculiser
    fini:
  }
}

//---------------------------------------------------------------------------
char Toupper(char ZString)
{
asm
  {
  mov al, ZString
  cmp al,0       // ==0
  je short fini2
  cmp al, 61h    // <'a'
  jb short fini2
  cmp al, 7Ah    // >'z'
  ja short fini2
  and  al, 0DFh  // majusculiser
  fini2:
  }
}

//---------------------------------------------------------------------------
// la même  que dans string.h ou stdio, mais en assembleur
void Strcpy(char *ch1, char *ch2)
{
asm
   {
   mov edx,ch1
   mov ecx,ch2
   debutas:////////
   mov al, byte ptr [ecx]
   cmp al,0               // si code ascii= 0
   je short endas         // alors fin
   mov byte ptr [edx], al // sinon copier ds cible
   inc ecx                // incrementer source
   inc edx                // incrementer cible
   jmp short debutas      // retour boucle
   endas://///////        // fin boucle
   mov byte ptr [edx], 0  // 0 pour finir chaine
   mov ch1,edx
   }
}

//---------------------------------------------------------------------------
void Strcat(char *ch1, char *ch2)
{
asm
   {
   mov edx,ch1
   mov ecx,ch2
   debut03:
   mov al, byte ptr [edx]
   cmp al,0
   je short mid03
   inc edx
   jmp short debut03
   mid03:
   mov al, byte ptr [ecx]
   cmp al,0
   je short end04
   mov byte ptr [edx], al
   inc ecx
   inc edx
   jmp short mid03
   end04:
   mov byte ptr [edx],0
   }
}

//---------------------------------------------------------------------------
// Atoi: convertit une chaine en integer
int  Atoi(char *ZString)
{
int base=10;
int valeur=0;

asm{
   mov ecx,ZString
   xor bh, 0
   DEBU8:                 // debut boucle
   mov bl, BYTE PTR [ecx] // chercher l'ofset
   cmp bl, 030h           // si < '0'
   jb short Fin8          // fin
   cmp bl, 039h           // si > '9'
   ja short Fin8          // fin
   and  bl ,0CFh          // soustraire '0' soit 48
   mul  base              //  multiplier par 10
   add  ax, bx            // ajouter nouveau chiffre
   inc ecx                // caractere suivant
   jmp short DEBU8
   Fin8:
   mov word ptr [valeur], ax
   }
}

//---------------------------------------------------------------------------
// strlen: retourne la longueur d'une chaine
unsigned int Strlen(char *ZString)
{
int lon=0;
asm{
   xor eax,0
   mov ecx,ZString
   debut9:
   cmp BYTE PTR [ecx],0  // si fin de chaine
   je short fin9         // saut fin boucle
   inc eax               // sinon
   inc ecx               // incrementer
   jmp short debut9      // retour boucle
   fin9:                 // fin boucle
   mov dword ptr [lon], eax
   }
}

//---------------------------------------------------------------------------
// filesize: retourne la taille du fichier (qui doit etre ouvert)


long filesize(FILE *safe)
{
long curpos, length;

   curpos = ftell(safe);
   fseek(safe, 0L, SEEK_END);
   length = ftell(safe);
   fseek(safe, curpos, SEEK_SET);// remettre la position initiale

return length;
}

//---------------------------------------------------------------------------
// file_available : retourne vrai si le fichier existe

bool file_available(char *nomfichier)
{
FILE *safe;
if((safe=fopen(nomfichier,"rb"))!=NULL)
 {
 fclose(safe);
 return true;
 }
else
 return false;
}

//---------------------------------------------------------------------------

void copyfile(char *setFrench,char *getFrench)
{
FILE *source, *cible;
source =fopen(setFrench,"rb");
cible =fopen(getFrench,"wb");

while(true)
  {
  register c=fgetc(source);
  if(feof(source))break;
  fputc(c,cible);
  }

fclose(cible);
fclose(source);
}

//---------------------------------------------------------------------------

void ajouter_mot_au_fichier(FILE *fichier, char *chemin,char *mot)
{

   if ((fichier=fopen(chemin,"a"))!=NULL)
     {
     fprintf(fichier,"%s\n",mot);
     fclose(fichier);
     }
}

//---------------------------------------------------------------------------

int trouvermot_dans_fichier(FILE *fichier, char *tst)
{

    fpos_t filepos=0;
    fsetpos(fichier,&filepos);
    bool bFin=false,bFound=false;

     do
      { // boucle fichier cible
      char msg[256];
      fscanf(fichier,"%s",msg);
      //si mot trouvé alors sortie boucle fichier cible
       if(tst[0]==msg[0] /*&& strlen(tst)==strlen(msg)*/)
         {
         if( !strcmp(msg,tst) )
            {
            bFin=true;
            bFound=true;
            }
          }

          if(feof(fichier))
            {
            bFin=true;
            }
      }
      while(!bFin);

return (bFound);
}

//------------------------------------------------------------------------