Fonctions de traitement rapide de chaines et fichier

Soyez le premier à donner votre avis sur cette source.

Vue 7 434 fois - Téléchargée 216 fois

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

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

Codes Sources

A voir également

Ajouter un commentaire

Commentaires

BruNews
Messages postés
21042
Date d'inscription
jeudi 23 janvier 2003
Statut
Modérateur
Dernière intervention
21 août 2019
16 -
Retour de Seattle, j'ai un peu plus de temps.
Voila exemple complet dans un prog win32.
Par principe si tu ecris une func en asm, faut la 'depouiller' afin de la controler completement, donc pas de declaration de variable ni 'return' ni rien d'autre. Si on mixe code C et ASM on gene l'optimisation du compilo, alors full asm ou rien.
Regarde strBinToInt(), j'ai mis en fastcall pour eviter empilage de param, on passe dans registre (ECX), ne pas oublier le ret final, ici avec 0 cause que rien de mis sur la pile.


#include <windows.h>

char szbuff[60];
char szappname[] = "Sample ASM inline";

__declspec(naked) int __fastcall strBinToInt(char *psz)
{ // ECX = psz, EDX autre param mais niet ici
__asm {
xor eax, eax
next:
mov dl, byte ptr[ecx]
sub dl, 48
jc short tointExit
cmp dl, 1
ja short tointExit
shl eax, 1
inc ecx
or al, dl
jmp short next
tointExit:
ret 0
}
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE, PSTR szcmdline, int)
{
int r;
r = strBinToInt("001101101");
itoa(r, szbuff, 10);

MessageBox(0, szbuff, szappname, 0);
return 0;
}
uxtobirza
Messages postés
16
Date d'inscription
dimanche 2 février 2003
Statut
Membre
Dernière intervention
3 juin 2008
-
Merci pour votre aide à tous. Voilà une nouvelle version, même si y a encore du boulot. Y'a plus qu'à dégrossir ? j'y retourne.
a+
cs_GoldenEye
Messages postés
527
Date d'inscription
vendredi 14 septembre 2001
Statut
Membre
Dernière intervention
6 octobre 2008
2 -
Cette source est extrêmement intéréssante pour illustrer les propos de BruNews. Le paradigme de base est bien celui de ce dernier
"Mieux vaut un C optimisé qu'un médiocre ASM".
Les compilateurs modernes intègrent une série de règles d'optimisation de code performantes et à ce jour seul un bon programmeur ASM sera à même d'améliorer le code généré par le compilateur C.
De ce fait, n'ajouter que du (bon) code ASM que si la section est critique et requiert un contrôle total me semble fondamental.
Je serai bien curieux de voir le rapport de performances entre le code "classique" de string.h compilé en Release de VC++ et ton code ASM non retouché
L'effort est louable mais ne perds pas de vue le rapport efficacité réelle/travail founi
BruNews
Messages postés
21042
Date d'inscription
jeudi 23 janvier 2003
Statut
Modérateur
Dernière intervention
21 août 2019
16 -
Un fichier peut exister meme si on ne peut pas l'ouvrir, suffit qu'il ait ete ouvert en exclusif avant, donc file_exist a refaire.
copyfile() procede octet par octet si j'ai bien compris, auquel cas faudra pas etre presse.
ASM: le tout n'est pas d'empiler des instructions pour faire joli, faut viser la performance. C'est loin d'etre le cas ici:
- instructions longues: mov eax, 0 au lieu de xor eax, eax
- emploi de ebx a sauvegarder quand les generaux suffisent.
- Les boucles ne sont pas deroulees.

etc ....

Mieux vaut un C optimise que du mauvais asm, un compilo moderne aura vite fait mieux.
Le prends pas mal mais revois ta copie.

BruNews, Admin CS, MVP Visual C++

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.