Fonctions de traitement rapide de chaines et fichier
5/5 (4 avis)
Vue 7 758 fois - Téléchargée 235 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.
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
- Fonctions de traitement rapide de chaines et fichier
- Traitement dédoublonnage fichier ✓ - Forum C++ & C++ .NET
- Chaines de caracteres en python ✓ - Forum Python
- Traitement d'image python ✓ - Forum C / C++ / C++.NET
- Traitement d'image python opencv - Forum Python
- Fichier javascript - Conseils pratiques -Javascript
10 avril 2004 à 16:43
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;
}
8 avril 2004 à 20:51
a+
1 avril 2004 à 14:53
"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
1 avril 2004 à 11:36
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.