Fonctions de traitement rapide de chaines et fichier

Télécharger le projet
Commenter

Description

C'est une librairie qui reprend une partie des fonctions de stdio.h et string.h
mais avec de l'assembleur dedans. Gain de vitesse important !
D'autres fonctions permettent de copier un fichier, savoir si il existe
ou quelle est sa taille.
attention : c++ builder professionel recommandé, parcce que sinon il faut retoucher le code.

Source / Exemple : 


#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);
}

//------------------------------------------------------------------------
Télécharger le projet

Codes Sources

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (uxtobirza)