Erreur de découpage d'un fichier

[titeeee]

Bonsoir,
Je cherche à faire un découpeur de fichier. C'est à dire couper un fichier > à 1.44Mo en plusieurs fichiers < 1.4Mo.

Voici un bout de code expliquer

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 
program Decoupage;
 
uses Crt, Dos;
 
var
  Destination, Source:     String;
  FDestination, FSource:   File;
  Ko, Mo:                  Word;
  Buffer:                  Word;
 
begin
  {Assignation des fichiers}
  Destination := 'c:\Destination.zip.1';
  Source := 'c:\Source.zip';
  Assign(FSource,Source);
  Assign(FDestination,Destination);
 
  {Ouverture}
  Rewrite(FDestination);
  Reset(FSource,1); {Chaque block := 128 octet}
 
  {Définition des tailles}
  Ko := 8; {8 * 128 = 1024}
  Mo := Ko * 1024;
 
  {Lecture du fichier source}
  BlockRead(FSource,Buffer,Mo); {On fais des fichier de 1Mo}
  BlockWrite(FDestination,Buffer,Mo); {On écrit 1Mo}
 
  {Fermeture}
  Close(FDestination);
  Close(FSource);  
 
end.

Le problème c'est que le programme n'écrit pas plus de 2.5Ko.
J'ai fais des testes.
Quand je met 1 -> Le fichier destination = 128octets
Quand je met 2 -> Le fichier = 256Octets;
Quand je met Ko -> J'ai un Ko

Mais quand j'ai plus que 2,5 Ko, alors, mon éditeur se ferme sans sauvegarder.
J'ai parfois un message Illegal Opération.

Si vous aviez une solution !

Merci

[DOLPat®]

Tu veux effectuer une copie d'un méga octet alors que tu déclares un buffer d'une taille d'un mot, soit 2 octets...

Code :

Buffer:                  Word;

Inspire-toi du code de la FAQ qui montre comment utiliser BlockRead et BlockWrite.

[titeeee]

Merci, tu as résolus une partie de l'erreur.

Maintenant, mon programme devient fou Soit il se ferme ou soit il reste bloqué. J'ai beau eu changé le word par une variable plus grande, rien ni fais.
Si quelqu'un voit une autre erreur

[droggo]

Quo,

Qu'appelles-tu "une variable plus grande" ?

C'est un tableau qu'il te faut, en t'assurant qu'il soit de taille suffisante (voir l'aide pour les fonctions que tu utilises).

[titeeee]

J'avais mis un longint. Mais comment je peut faire avec un tableau ?

[wormful_sickfoot]

Tu lis 1 Mo de données d'un fichier, il faut donc que tu alloues en mémoire en espace de 1 Mo pour contenir ces données. Pour cela, il faudra que tu passes par une allocation dynamique.

Si tu ne veux pas d'allocation dynamique, tu peux te limiter à transférer 64k par 64k.

[Eric2a]

Salut,

Reset(FSource,1); {Chaque block := 128 octet}

Non, dans ce cas la taille des enregistrements n'est pas de 128 octets (valeur par défaut si paramètre omis) mais bel et bien d'un octet.

Par contre,

Rewrite(FDestination);

Ici, la taille des enregistrements est bien de 128 octets car le paramètre Taille_enr est omis.

Rappel :

procedure BlockWrite(var F:file; var Buf; Nombre:Word[;Resultat:Word]);

Le bloc transféré aura au plus une taille de Nombre*Taille_enr octets, où Taille_enr représente la taille d'enregistrements précisée à l'ouverture du fichier.

procedure Rewrite(var F[:file; TailleEnr:Word] );

ou 128 octets si aucune taille n'avait été précisée.

Une erreur est retournée si le produit Nombre*Taille_enr est supérieur à 65535 (64 Ko).

Source : Guide de référence Turbo Pascal

Ci-dessous un code TP7 permettant le découpage de fichier en plusieurs fichiers de OutFileSize octets.
La lecture et l'écriture se fait par paquet de 65520 octets.

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
Program FCut;
 
Const
 BufferSize:Word=$FFF0;
 OutFileSize:LongInt=1048576;
 FilesCount:Word=0;
 
Var
 InFile,OutFile:File;
 Buffer:Pointer;
 BytesCount:Word;
 InBytesLeft,OutBytesLeft,BytesToWrite:LongInt;
 
 
Function WordToStr(W:Word):String;
Var
 S:String[11];
 
Begin
 Str(W,S);
 WordToStr:=S;
End;
 
 
Begin
 GetMem(Buffer,BufferSize);
 
 Assign(InFile,'e:\src.zip');
 Reset(InFile,1);
 
 InBytesLeft:=FileSize(InFile);
 Repeat
  Inc(FilesCount);
  Assign(OutFile,'e:\dest.'+WordToStr(FilesCount));
  Rewrite(OutFile,1);
 
  If InBytesLeft>OutFileSize Then
     BytesToWrite:=OutFileSize
  Else
     BytesToWrite:=InBytesLeft;
 
  OutBytesLeft:=BytesToWrite;
  Repeat
   If OutBytesLeft>BufferSize Then
      BytesCount:=BufferSize
   Else
      BytesCount:=OutBytesLeft;
 
   BlockRead(InFile,Buffer^,BytesCount);
   BlockWrite(OutFile,Buffer^,BytesCount);
 
   Dec(OutBytesLeft,BytesCount);
  Until OutBytesLeft=0;
 
  Close(OutFile);
 
  Dec(InBytesLeft,BytesToWrite);
 Until InBytesLeft=0;
 
 Close(InFile);
 
 FreeMem(Buffer,BufferSize)
End.

[titeeee]

Merci beaucoup !