PureBasic

Coucou a toi aussi

Alors la au niveau du nbre de ligne dur dur pour faire + court...

Par contre il est vrai, que comme le code de brossden, pour les gros fichiers, ça va pas etre facile.

Si SPH daigne nous eclairer un jour, est-ce normal cette difference entre l'assembleur et le pure ????

bonne soiree

andrebernard a écrit :Coucou a toi aussi

Alors la au niveau du nbre de ligne dur dur pour faire + court...

Par contre il est vrai, que comme le code de brossden, pour les gros fichiers, ça va pas etre facile.

Si SPH daigne nous eclairer un jour, est-ce normal cette difference entre l'assembleur et le pure ????

bonne soiree

Simplement, mon code ne fais pas la meme chose que celui de brossden. Si je fais un code ASM qui fasse pareil, il sera rapide mais pondra un aussi gros fichier que celui de brossden.

Bonsoir

Je suis content de te lire SPH.
J'ai cru que tu etais véxé.

Merci de ta reponse, bon bah tant pis, pour l'hexa, je garderais le super code de brossden et de patrick88.

Quoi qu'il en soit il serait aussi gros, mais peut etre plus rapide non ???
Y a t'il une grosse difference entre l'assembleur et le pure ????

Parce que pour coder des centaines de gros fichiers, c'est important.

Par contre, si tu pouvais donner le complement de ton super, hypersonique code pour revenir en arriere, ça serait cool.

On aurait le pack complet de codage/decodage en ASM.

Et au passage, expliquer un petit peu le mecanisme du cryptage, etmettre quelques commentaires, parceque comme le dit brossden tu as affaire a des BB de la prog , mais qui vont essayer de grandir grace aux super biberons de vous tous.....
(section debutant, donc on comprend vite, mais il faut nous expliquer longtemps)

Enfin je ne veux pas trop abuser de ton temps qui doit etre precieux, ce sera a temps perdu evidement

Bonne soiree a toi

Mon code transforme en hexa n'importe quel fichier. Mais contrairement a celui de brossden, le mien rend EXACTEMENT l'hexa que tu aurais dans un editeur hexadecimal. Alors erreur de brossden ou ais-je encore du mal a comprendre de cahier des charges ??

Code : Tout sélectionner

#src=0 
#dst=1 
Lecture.l
Byte.b
Hexa.l
;;;;;;;;
source$=OpenFileRequester("Fichier à convertir","*.*","*.*",1)
destin$=SaveFileRequester("Sauver sous","SPH.doc","*.*",1) 

;;;;;;;;
If ReadFile(#src, source$)
lg = Lof(#src) 
Else
MessageRequester("Erreur", "Fichier impossible à lire...")
End
EndIf
;;;;;;;;
If lg=0
MessageRequester("Inutilité", "Votre fichier est vide !")
End
EndIf
;;;;;;;;
If CreateFile(#dst, destin$)
Else
MessageRequester("Erreur", "Fichier impossible à créer...")
End
EndIf
;;;;;;;;

temps = GetTickCount_() 

;;;;;;;;
reste = lg%4
paquet = lg/4
;;;;;;;;
While paquet>0
Lecture.l = ReadLong(#src)
!MOV  eax,[v_Lecture]
!BSWAP  eax
!MOV [v_Hexa],eax
Hexa$ = RSet(Hex(Hexa.l), 8, "0") 
WriteString(#dst, Hexa$)
paquet-1
Wend
;;;;;;;;
While reste>0
Byte.b = ReadByte(#src)
Hexa$ = RSet(Hex(Byte.b), 2, "0") 
WriteString(#dst, Hexa$)
reste-1
Wend
;;;;;;;;
CloseFile(#src)
CloseFile(#dst)
;;;;;;;;


MessageRequester("Etat du programme", "Conversion finie " +Str( GetTickCount_()-temps )+" ms")

Alors la ........chapeau bas.
Rapide et en plus il marche

J'ai converti en binaire grace au code en purebasic.

Serait ce exagéré que

1/ Tu me donne le code inverse pour retourner en binaire

2/ ainsi que celui de ton cryptage que tu avais gentiment proposé meme si il n'a pas eu la gloire attendue.

Je sais, j'en demande beaucoup, c'est le probleme de tous les BB, il braillent tout le temps, car ils ont toujours faim.

Et pourrais tu me dire si il y a une grosse difference de rapidité d'execution entre l'assembleur comme tu le programme et le code purebasic traditionnel une fois compilé ????

Merci beaucoup

andrebernard a écrit :Serait ce exagéré que

1/ Tu me donne le code inverse pour retourner en binaire

2/ ainsi que celui de ton cryptage que tu avais gentiment proposé meme si il n'a pas eu la gloire attendue.

Et pourrais tu me dire si il y a une grosse difference de rapidité d'execution entre l'assembleur comme tu le programme et le code purebasic traditionnel une fois compilé ????

Merci beaucoup

1> je te le donnerais
2> je l'ai abandonné

La difference de rapidité entre l'ASM et PB une fois compilé peux aller du simple au double (triple meme). Ca depend comment est codé la partie PB.

Dans tout ca, tu oublies de preciser pourquoi un fichier "travaillé" est different sur le code de brossden par rapport au mien !!?

Bonjour SPH

Je te remercie beaucoup de bien vouloir me donner le code hexa/binaire en ASM, il me sera bien utile dans mon appli.(Grand besoin de rapidité)

Je ne savais pas qu'il pouvait y avoir autant de difference entre le Pb et l'ASM.

1 / Si j'ai bien compris l'ASM est le plus rapide des languages ????
Encore plus rapide que le C ????

2 / Pourquoi as-tu abandonné ton cryptage ??? il ne marchais pas ??? c'etait trop dur à realiser ???? ou bien etais-ce à cause de l'intervention de brossden ???

SPH a écrit : Dans tout ca, tu oublies de preciser pourquoi un fichier "travaillé" est different sur le code de brossden par rapport au mien !!?

3/ Excuse moi, mais je n'ai pas compris le sens de ta question, surtout "travaillé". Et comme on a deja eu du mal à une fois, je voudrais etre sur de bien comprendre avant de te repondre.

Encore sincerement merci SPH

Ouil l'ASM est le plus rapide des languages mais le C est si puissant qu'il le rattrape et surtout, le C est plus facile alors si tu as le choix, fait du C.

Bon, utilise ma routine et utilise la routine de brossden sur le meme fichier. Le resultat est different !!
POURQUOI ?

Bon, j'ai fait tout comme t'a dit ....

J'ai essayé ton code et celui de BrossDen suivant :

Code : Tout sélectionner

Global Matrice.s="0123456789ABCDEF" 
Procedure.s Hexa(dec) 
  x = dec % 16 
  y = dec / 16 
  ProcedureReturn Mid(Matrice,y+1,1)+Mid(Matrice,x+1,1) 
EndProcedure  
  

#src=0 
#dst=1 
Lg=0 
source$=OpenFileRequester("Fichier traité","*.*","*.*",1) 
destin$=SaveFileRequester("Fichier à traiter","dump.hex","*.*",1) 
If source$>"" 
  If destin$>"" 
    OpenFile(#src,source$) 
    CreateFile(#dst,destin$) 
    Lg = Lof(#src) 
    Lgd = Lg*3 
    If Lg>0 
      *Source=AllocateMemory(Lg) 
      *Destin=AllocateMemory(Lgd) 
      ReadData(#src,*Source,Lg) 
      For n=0 To Lg 
        PokeS(*Destin+(n*3),Hexa(PeekC(*Source+n))+",") 
      Next 
      WriteData(#dst,*Destin,Lgd)    
      Debug Destin 
    EndIf 
  EndIf 
EndIf 
CloseFile(#src) 
CloseFile(#dst) 
MessageRequester("Etat du programme", "Conversion finie")

Hors mis les fameuses et satanées virgules (responsable de tant d'enervement), apparement c'est le meme resultat.

Il y a tellement de code que l'on s'y perd. Celui la fonctionne mais moi je mattais le code de la page 2 qui fait un resultat different.
Bon, ok ok ca marche.

T'as raison
Y'en a tellement que j'etais en train de les classer ds le repertoire exemple avec bin/hexa de brossden, bin/hexa de sph en asm, etc .....
Une vrai encyclopedie.

En tous cas cela prouve une chose c'est que vous etes super sympa de prendre autant de temps pour m'aider.
J'aurais jamais cru ça possible.

Et je vous en suis tous reconnaissant, car qd tu est devant un mur tout seul avec ton ignorance, tu es super content qu'un rayon de soleil, que dis-je un mais des rayons de soleils viennent t'illuminer.

En plus transmition de pensée qd tu m'a demandé de comparer j'etais en train d'inserer ton code ASM dans mon appli.

1/ Tu m'a pas dit pourquoi t'avais abandonné ton super cryptage ?????

2/ J'ai essayé de l'inserer dans une procedure et ça me créé une erreur, je suppose qu'il manque une variable, car il marche à l'exterieur.

1> Mon "super cryptage" n'en est pas un. Les trois quart des programmeurs pourraient décoder les données...

Bon bah tant pis.

je partirais de l'hexa pour coder et repasser par l'hexa pour decoder comme je l'avais fait au debut.
Je vais tenter de trouver un codage de la mort.....

peut etre avec 2 mots de passe .......que j'inverserais pour brouiller le pourcentage dont m'a parlé DOBRO.
Je vais chercher car je ne veut pas que mes info perso soit sur E-mule

Je vais utiliser ton code bin/hexa apres essai, si il est plus rapide......

Il faut dire que celui de BrossDen meme optimisé n'avait aucune chance car si comme tu le dit l'ASM est 2 a 3 fois + rapide ....

Mais je le remercie qd meme et il a aussi son utilité, car cela permet d'apprendre et si l'on veut rester en pure seulement....

Le tiens va m'etre tres utile pour la convertion de centaines de gros fichiers pour le gain de temps.

Quoi qu'il en soit par respect pour votre travail, je vais les mettre tous les 2 dans mon appli, chacun ds une procedure , pour pas qu'il se dispute)

Code : Tout sélectionner

ConvertionBinaireHexaPb(FichierBinHexa$, FichierBinHexa$ + ".Hexa")
ConvertionBinaireHexaASM(FichierBinHexa$, FichierBinHexa$ + ".Hexa")

J'attend avec impatience le hexa/bin en ASM que tu m'a gentiment promis.

et je ferais de meme

Code : Tout sélectionner

ConvertionHexaBinairePb(FichierHexaBin$, Fichier$)
ConvertionHexaBinaireASM(FichierHexaBin$, Fichier$)

J'ai essayé de mettre ton code bin/hexa dans une procedure et il cree une erreur apparement de compilation ASM, alors qu'il marche en dehors ?????

T"as une idée???

Merci

PureBasic

Conversion hexa/texte en binaire