/[projet1]/public/pc/tools/osdk/main/tap2dsk/sources/tap2dsk.c
Defence Force logotype

Diff of /public/pc/tools/osdk/main/tap2dsk/sources/tap2dsk.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1319 by Jylam, Wed Sep 17 19:54:27 2014 UTC revision 1320 by dbug, Sat Oct 24 15:33:07 2015 UTC
# Line 2  Line 2 
2  /* (c) F.Frances 2004 */  /* (c) F.Frances 2004 */
3    
4  /* Limitations :  /* Limitations :
5   *   - only 1 bitmap sector, thus limits the capacity to ~2048 sectors  *   - only 1 bitmap sector, thus limits the capacity to ~2048 sectors
6   *   - only 1 side with 80 tracks max.  *   - only 1 side with 80 tracks max.
7   */  */
8    
9  #include <stdio.h>  #include <stdio.h>
10  #include <stdlib.h>  #include <stdlib.h>
# Line 16  typedef unsigned char byte; Line 16  typedef unsigned char byte;
16  typedef byte sector[256];  typedef byte sector[256];
17    
18  struct {  struct {
19          char signature[8];    char signature[8];
20          int sides;    int sides;
21          int tracks;    int tracks;
22          int sect;    int sect;
23          char pad[256-20];    char pad[256-20];
24  } imageheader = { "ORICDISK", 1, NBTRACKS, NBSECT };  } imageheader = { "ORICDISK", 1, NBTRACKS, NBSECT };
25    
26  sector disk[80][NBSECT];  sector disk[80][NBSECT];
27  sector directory,descriptor;  sector directory,descriptor;
28  sector system_sect={    // some system parameters  sector system_sect={    // some system parameters
29          0xD0,0xD0,0xD0,0xD0,    // drive table    0xD0,0xD0,0xD0,0xD0,  // drive table
30          0,                      // keyboard type    0,                    // keyboard type
31          100,0,10,0,     // RENUM parameters    100,0,10,0,   // RENUM parameters
32          'T','A','P','2','D','S','K',' ','S','A','M','P','L','E',' ','D','I','S','C',' ',' ',  // disk name    'T','A','P','2','D','S','K',' ','S','A','M','P','L','E',' ','D','I','S','C',' ',' ',  // disk name
33          ' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',    ' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',
34          ' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',    ' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',
35          ' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '                 // inist    ' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '                       // inist
36  };  };
37  sector bitmap={  sector bitmap={
38          0xFF,           // signature    0xFF,         // signature
39          0,    0,
40          0,0,            // number of free sectors    0,0,          // number of free sectors
41          0,0,            // number of files    0,0,          // number of files
42          NBTRACKS,       // number of tracks/side    NBTRACKS,     // number of tracks/side
43          NBSECT,         // number of sectors/track    NBSECT,               // number of sectors/track
44          1,                      // number of directory sectors    1,                    // number of directory sectors
45          NBTRACKS,       // number of tracks + 128 if double sided    NBTRACKS,     // number of tracks + 128 if double sided
46          0                       // master/slave/gameinit indicator    0                     // master/slave/gameinit indicator
47  };  };
48    
49  byte sedoric[]=  byte sedoric[]=
# Line 59  int used_sectors; Line 59  int used_sectors;
59    
60  void allocate_sector(int track, int sect, byte *contents)  void allocate_sector(int track, int sect, byte *contents)
61  {  {
62          int linear_sector=track*NBSECT+sect-1;    int linear_sector=track*NBSECT+sect-1;
63          bitmap[0x10+linear_sector/8] &= ~(1<<linear_sector%8);    bitmap[0x10+linear_sector/8] &= ~(1<<linear_sector%8);
64          memcpy(disk[track][sect-1],contents,sizeof(sector));    memcpy(disk[track][sect-1],contents,sizeof(sector));
65          used_sectors++;    used_sectors++;
66  }  }
67    
68  void find_free_sector(byte *contents)  void find_free_sector(byte *contents)
69  {  {
70          int linear_sector=0;    int linear_sector=0;
71          while ((bitmap[0x10+linear_sector/8] & (1<<linear_sector%8)) == 0)    while ((bitmap[0x10+linear_sector/8] & (1<<linear_sector%8)) == 0)
72                  linear_sector++;      linear_sector++;
73    
74          track=linear_sector/NBSECT;    track=linear_sector/NBSECT;
75          sect=linear_sector%NBSECT+1;    sect=linear_sector%NBSECT+1;
76          if (track==80) {    if (track==80) {
77                  fprintf(stderr,"Not enough space on sample disc");      fprintf(stderr,"Not enough space on sample disc");
78                  exit(1);      exit(1);
79          }    }
80          allocate_sector(track,sect,contents);    allocate_sector(track,sect,contents);
81  }  }
82    
83  void update_sector(int track, int sect, byte *contents)  void update_sector(int track, int sect, byte *contents)
84  {  {
85          memcpy(disk[track][sect-1],contents,sizeof(sector));    memcpy(disk[track][sect-1],contents,sizeof(sector));
86  }  }
87    
88  void convert_basename(char *dest, char *name)  void convert_basename(char *dest, char *name)
89  {  {
90          static int filenumber=0;    static int filenumber=0;
91          int dest_offset=0, src_offset=0;    int dest_offset=0, src_offset=0;
92          printf("Storing ");    printf("Storing ");
93          while (dest_offset<9 && src_offset<17 && name[src_offset]) {    while (dest_offset<9 && src_offset<17 && name[src_offset])
94                  if (name[src_offset]>='a' && name[src_offset]<='z')    {
95                          name[src_offset]-=0x20;      if (name[src_offset]>='a' && name[src_offset]<='z')
96                  if ((name[src_offset]>='0' && name[src_offset]<='9')        name[src_offset]-=0x20;
97                          || (name[src_offset]>='A' && name[src_offset]<='Z')) {  
98                                  putchar(name[src_offset]);      if ((name[src_offset]>='0' && name[src_offset]<='9')
99                                  dest[dest_offset++]=name[src_offset];        || (name[src_offset]>='A' && name[src_offset]<='Z'))
100                  }      {
101                  src_offset++;        putchar(name[src_offset]);
102          }        dest[dest_offset++]=name[src_offset];
103          if (dest_offset) {      }
104                  while (dest_offset<9)      src_offset++;
105                          dest[dest_offset++]=' ';    }
106          } else {    if (dest_offset)
107                  printf("NONAME%03d",filenumber);    {
108                  sprintf(dest,"NONAME%03d",filenumber++);      while (dest_offset<9)
109          }        dest[dest_offset++]=' ';
110      }
111      else
112      {
113        printf("NONAME%03d",filenumber);
114        sprintf(dest,"NONAME%03d",filenumber++);
115      }
116  }  }
117    
118  void store_file(byte *buf, char *name, byte *header)  void store_file(byte *buf, char *name, byte *header)
119  {  {
120          int start=(header[6]<<8)+header[7];    int start=(header[6]<<8)+header[7];
121          int end=(header[4]<<8)+header[5];    int end=(header[4]<<8)+header[5];
122          int exec=header[3];    int exec=header[3];
123          int block=header[2];    int block=header[2];
124          int sectors=(end-start)/sizeof(sector)+1;    int sectors=(end-start)/sizeof(sector)+1;
125          int desc_sect,desc_track;    int desc_sect,desc_track;
126          int desc_off=0x0C;    int desc_off=0x0C;
127    
128          memset(descriptor,0,sizeof(sector));    memset(descriptor,0,sizeof(sector));
129          find_free_sector(descriptor);    find_free_sector(descriptor);
130          desc_track=track; desc_sect=sect;    desc_track=track; desc_sect=sect;
131          descriptor[2]=0xFF;    descriptor[2]=0xFF;
132          descriptor[3]=(block?0x40:0x80)+(exec?1:0);    descriptor[3]=(block?0x40:0x80)+(exec?1:0);
133          descriptor[4]=header[7];    descriptor[4]=header[7];
134          descriptor[5]=header[6];    descriptor[5]=header[6];
135          descriptor[6]=header[5];    descriptor[6]=header[5];
136          descriptor[7]=header[4];    descriptor[7]=header[4];
137          if (exec) {    if (exec)
138                  descriptor[8]=descriptor[4];    {
139                  descriptor[9]=descriptor[5];      descriptor[8]=descriptor[4];
140          } else {      descriptor[9]=descriptor[5];
141                  descriptor[8]=descriptor[9]=0;    }
142          }    else
143          descriptor[10]=sectors&0xFF;    {
144          descriptor[11]=sectors>>8;      descriptor[8]=descriptor[9]=0;
145      }
146          convert_basename((char*)(directory+dir_offset),name);    descriptor[10]=sectors&0xFF;
147          if (exec) {    descriptor[11]=sectors>>8;
148                  sprintf((char*)(directory+dir_offset+9),"COM");  
149                  printf(".COM");    convert_basename((char*)(directory+dir_offset),name);
150          } else {    if (exec)
151                  sprintf((char*)(directory+dir_offset+9),"%s",block?"BIN":"BAS");    {
152                  printf(".%s",block?"BIN":"BAS");      sprintf((char*)(directory+dir_offset+9),"COM");
153          }      printf(".COM");
154          printf("\n");    }
155          directory[dir_offset+12]=desc_track;    else
156          directory[dir_offset+13]=desc_sect;    {
157          directory[dir_offset+14]=sectors+1+(sectors>=(256-12)/2?1:0); // Sedoric bug work-around : allocate a second descriptor when exactly 122 sectors of data      sprintf((char*)(directory+dir_offset+9),"%s",block?"BIN":"BAS");
158          directory[dir_offset+15]=0x40; // UNPROT      printf(".%s",block?"BIN":"BAS");
159      }
160          while (sectors--) {    printf("\n");
161                  find_free_sector(buf);    directory[dir_offset+12]=desc_track;
162                  buf+=sizeof(sector);    directory[dir_offset+13]=desc_sect;
163                  descriptor[desc_off++]=track;    directory[dir_offset+14]=sectors+1+(sectors>=(256-12)/2?1:0); // Sedoric bug work-around : allocate a second descriptor when exactly 122 sectors of data
164                  descriptor[desc_off++]=sect;    directory[dir_offset+15]=0x40; // UNPROT
165                  if (desc_off==0x100) {                  // Sedoric bug work-around : allocate a second descriptor when the first is full, even if not needed  
166                          find_free_sector(descriptor);    while (sectors--)
167                          descriptor[0]=track;    {
168                          descriptor[1]=sect;      find_free_sector(buf);
169                          update_sector(desc_track,desc_sect,descriptor);      buf+=sizeof(sector);
170                          memset(descriptor,0,sizeof(sector));      descriptor[desc_off++]=track;
171                          desc_track=track;      descriptor[desc_off++]=sect;
172                          desc_sect=sect;      if (desc_off==0x100)
173                          desc_off=2;      {                   // Sedoric bug work-around : allocate a second descriptor when the first is full, even if not needed
174                  }        find_free_sector(descriptor);
175          }        descriptor[0]=track;
176          update_sector(desc_track,desc_sect,descriptor);        descriptor[1]=sect;
177          update_sector(desc_track,desc_sect,descriptor);
178          memset(descriptor,0,sizeof(sector));
179          desc_track=track;
180          desc_sect=sect;
181          desc_off=2;
182        }
183      }
184      update_sector(desc_track,desc_sect,descriptor);
185  }  }
186    
187  char generateEscapeCode(int color) {  char generateEscapeCode(int color)
188          return (char) 64 + color;  {
189      return (char) 64 + color;
190  }  }
191    
192  int main(int argc, char *argv[])  int main(int argc, char *argv[])
193  {  {
194          byte header[9];    byte header[9];
195          char name[17];    char name[17];
196          byte file_buffer[48*1024];    byte file_buffer[48*1024];
197          FILE *tape, *dsk;    FILE *tape, *dsk;
198          int dir_track=20, dir_sect=4;    int dir_track=20, dir_sect=4;
199          int tracks=21; // minimum track number    int tracks=21; // minimum track number
200          int total_sectors,free_sectors;    int total_sectors,free_sectors;
201          int tape_num,i;    int tape_num,i;
202          int tape_name_index = -1;    int tape_name_index = -1;
203          int paper_color = -1;    int paper_color = -1;
204          int ink_color = -1;    int ink_color = -1;
205    
206          printf("Tap2dsk V2.1\n");    printf("Tap2dsk V2.1\n");
207    
208          if (argc<2) {    if (argc<2)
209                  fprintf(stderr,"Usage: tap2dsk [-c<paper_color>:<ink_color>] [-n<disk_label>] [-i<init_string>] <tape_image1> ...<tape_imageN> <old_disk_image>\n");    {
210                  exit(1);      fprintf(stderr,"Usage: tap2dsk [-c<paper_color>:<ink_color>] [-n<disk_label>] [-i<init_string>] <tape_image1> ...<tape_imageN> <old_disk_image>\n");
211          }      exit(1);
212      }
213          for (i=1; i<argc; i++) {  
214                  if (argv[i][0]=='-') {    for (i=1; i<argc; i++)
215                          switch (argv[i][1]) {    {
216                          case 'c': case 'C':      if (argv[i][0]=='-')
217                                  if (sscanf(argv[i], "-c%d:%d", &paper_color, &ink_color) != 2) {      {
218                                          fprintf(stderr, "Malformed color option. It should be -c<paper_color>:<ink_color>\n");        switch (argv[i][1])
219                                          exit(3);        {
220                                  }        case 'c':
221                                  if (paper_color <16 || paper_color >23 || ink_color < 0 || ink_color > 7) {        case 'C':
222                                          fprintf(stderr, "Wrong colors. Paper color should be between 16 and 23 and ink color between 0 and 7\n");          if (sscanf(argv[i], "-c%d:%d", &paper_color, &ink_color) != 2)
223                                          exit(3);          {
224                                  }            fprintf(stderr, "Malformed color option. It should be -c<paper_color>:<ink_color>\n");
225                                  // if the name was before            exit(3);
226                                  if (tape_name_index > 0) {          }
227                                          memset(system_sect + 9, ' ', 21);          if (paper_color <16 || paper_color >23 || ink_color < 0 || ink_color > 7)
228                                          *(system_sect + 9) = (char)27;          {
229                                          *(system_sect + 10) = generateEscapeCode(paper_color);            fprintf(stderr, "Wrong colors. Paper color should be between 16 and 23 and ink color between 0 and 7\n");
230                                          *(system_sect + 11) = (char)27;            exit(3);
231                                          *(system_sect + 12) = generateEscapeCode(ink_color);          }
232                                          if (strlen(argv[tape_name_index]) - 2 > 17) {          // if the name was before
233                                                  fprintf(stderr, "Disk label too long (if you use colors you loose four characters)\n");          if (tape_name_index > 0)
234                                                  exit(3);          {
235                                          }            memset(system_sect + 9, ' ', 21);
236                                          memcpy(system_sect + 13, argv[tape_name_index] + 2, strlen(argv[tape_name_index]) - 2);            *(system_sect + 9) = (char)27;
237                                  }            *(system_sect + 10) = generateEscapeCode(paper_color);
238                                  break;            *(system_sect + 11) = (char)27;
239                          case 'i': case 'I':            *(system_sect + 12) = generateEscapeCode(ink_color);
240                                  if (strlen(argv[i]) - 2 > 60) {            if (strlen(argv[tape_name_index]) - 2 > 17)
241                                          fprintf(stderr,"Init string too long\n");            {
242                                          exit(3);              fprintf(stderr, "Disk label too long (if you use colors you loose four characters)\n");
243                                  }              exit(3);
244                                  memcpy(system_sect+0x1E,argv[i]+2,strlen(argv[i])-2);            }
245                                  // remember where it was            memcpy(system_sect + 13, argv[tape_name_index] + 2, strlen(argv[tape_name_index]) - 2);
246                                  tape_name_index = i;          }
247                                  break;          break;
248                          case 'n': case 'N':        case 'i':
249                                  memset(system_sect+9,' ',21);        case 'I':
250                                  // if the colors were before          if (strlen(argv[i]) - 2 > 60)
251                                  if (paper_color > 0 && ink_color >= 0) {          {
252                                          *(system_sect + 9) = (char)27;            fprintf(stderr,"Init string too long\n");
253                                          *(system_sect + 10) = generateEscapeCode(paper_color);            exit(3);
254                                          *(system_sect + 11) = (char)27;          }
255                                          *(system_sect + 12) = generateEscapeCode(ink_color);          memcpy(system_sect+0x1E,argv[i]+2,strlen(argv[i])-2);
256                                          if (strlen(argv[i]) - 2 > 17) {          // remember where it was
257                                                          fprintf(stderr, "Disk label too long (if you use colors you loose four characters)\n");          tape_name_index = i;
258                                                          exit(3);          break;
259                                          }        case 'n':
260                                          memcpy(system_sect + 13, argv[i] + 2, strlen(argv[i]) - 2);        case 'N':
261                                  }          memset(system_sect+9,' ',21);
262                                  else {          // if the colors were before
263                                          // if there are no colors do like before          if (paper_color > 0 && ink_color >= 0)
264                                          // if the colors are after we will overwrite the label          {
265                                          if (strlen(argv[i]) - 2 > 21) {            *(system_sect + 9) = (char)27;
266                                                  fprintf(stderr, "Disk label too long\n");            *(system_sect + 10) = generateEscapeCode(paper_color);
267                                                  exit(3);            *(system_sect + 11) = (char)27;
268                                          }            *(system_sect + 12) = generateEscapeCode(ink_color);
269                                          memcpy(system_sect + 9, argv[i] + 2, strlen(argv[i]) - 2);            if (strlen(argv[i]) - 2 > 17)
270                                  }            {
271                                  tape_name_index = i;              fprintf(stderr, "Disk label too long (if you use colors you loose four characters)\n");
272                                  break;              exit(3);
273                          default: fprintf(stderr,"Bad option : %c\n",argv[i][1]);            }
274                                  exit(2);            memcpy(system_sect + 13, argv[i] + 2, strlen(argv[i]) - 2);
275                          }          }
276                  }          else
277          }          {
278              // if there are no colors do like before
279          dsk=fopen(argv[argc-1],"wb");            // if the colors are after we will overwrite the label
280          if (dsk==NULL) {            if (strlen(argv[i]) - 2 > 21)
281                  fprintf(stderr,"Cannot open %s for writing\n",argv[2]);            {
282                  exit(1);              fprintf(stderr, "Disk label too long\n");
283          }              exit(3);
284              }
285          memset(bitmap+0x10,0xFF,sizeof(sector)-0x10);            memcpy(system_sect + 9, argv[i] + 2, strlen(argv[i]) - 2);
286          for (i=0; i<99; i++) {  // 99 secteurs pour sedoric          }
287                  int track= i/NBSECT;          tape_name_index = i;
288                  int sector = i%NBSECT + 1;          break;
289                  allocate_sector(track,sector,sedoric+i*256);  
290          }        default:
291          allocate_sector(20,1,system_sect);          fprintf(stderr,"Bad option : %c\n",argv[i][1]);
292          allocate_sector(20,2,bitmap);          exit(2);
293          allocate_sector(20,4,directory);        }
294        }
295          for (tape_num=1; tape_num<argc-1; tape_num++) {    }
296                  if (argv[tape_num][0]=='-') continue;  
297                  tape=fopen(argv[tape_num],"rb");    dsk=fopen(argv[argc-1],"wb");
298                  if (tape==NULL) {    if (dsk==NULL)
299                          fprintf(stderr,"Cannot read tape image %s\n",argv[tape_num]);    {
300                          exit(1);      fprintf(stderr,"Cannot open %s for writing\n",argv[2]);
301                  }      exit(1);
302                  printf("Reading %s\n",argv[tape_num]);    }
303    
304      memset(bitmap+0x10,0xFF,sizeof(sector)-0x10);
305                  while (fgetc(tape)!=EOF) {    for (i=0; i<99; i++)
306                          int start,end,i;    {     // 99 secteurs pour sedoric
307                          while (fgetc(tape)!=0x24)      int track= i/NBSECT;
308                                  ;      int sector = i%NBSECT + 1;
309                          for (i=0;i<9;i++) header[i]=fgetc(tape);      allocate_sector(track,sector,sedoric+i*256);
310                          for (i=0;i<17;i++) {    }
311                                  name[i]=fgetc(tape);    allocate_sector(20,1,system_sect);
312                                  if (name[i]==0) break;    allocate_sector(20,2,bitmap);
313                          }    allocate_sector(20,4,directory);
314    
315                          // if the name is null then copy the file name instead    for (tape_num=1; tape_num<argc-1; tape_num++)
316                          if (name[0] == 0) {    {
317                                  // only take the file name from the path      if (argv[tape_num][0]=='-') continue;
318                                  char *lastdot;      tape=fopen(argv[tape_num],"rb");
319                                  char *fileName = argv[tape_num];      if (tape==NULL)
320                                  // try to find '\\'      {
321                                  char *lastsep = strrchr(fileName, '\\');        fprintf(stderr,"Cannot read tape image %s\n",argv[tape_num]);
322                                  if (lastsep != NULL) {        exit(1);
323                                          // if there is something after the separator      }
324                                          if (lastsep+1 != 0)      printf("Reading %s\n",argv[tape_num]);
325                                                  fileName = lastsep + 1;  
326                                  } else {  
327                                          // try to find /      while (fgetc(tape)!=EOF)
328                                          lastsep = strrchr(fileName, '/');      {
329                                          if (lastsep != NULL) {        int start,end,i;
330                                                  // if there is something after the separator        while (fgetc(tape)!=0x24)
331                                                  if (lastsep + 1 != 0)          ;
332                                                          fileName = lastsep + 1;        for (i=0;i<9;i++) header[i]=fgetc(tape);
333                                          }        for (i=0;i<17;i++) {
334                                  }          name[i]=fgetc(tape);
335            if (name[i]==0) break;
336                                  // remove the extension if there is one        }
337                                  lastdot = strrchr(fileName, '.');  
338                                  if (lastdot != NULL)        // if the name is null then copy the file name instead
339                                          *lastdot = 0;        if (name[0] == 0)
340                                  for (i = 0; i<17; i++) {        {
341                                          name[i] = fileName[i];          // only take the file name from the path
342                                          if (name[i] == 0) break;          char *lastdot;
343                                  }          char *fileName = argv[tape_num];
344                          }          // try to find '\\'
345            char *lastsep = strrchr(fileName, '\\');
346                          start=(header[6]<<8)+header[7];          if (lastsep != NULL)
347                          end=(header[4]<<8)+header[5];          {
348                          for (i=0; i<end+1-start; i++)            // if there is something after the separator
349                                  file_buffer[i]=fgetc(tape);            if (lastsep+1 != 0)
350                          printf("Found %s\n",name);              fileName = lastsep + 1;
351                          store_file(file_buffer,name,header);          }
352                          bitmap[4]++; // number of files          else
353                          dir_offset+=16;          {
354                          if (dir_offset==0x100) {            // try to find /
355                                  find_free_sector(directory);            lastsep = strrchr(fileName, '/');
356                                  directory[0]=track;            if (lastsep != NULL)
357                                  directory[1]=sect;            {
358                                  update_sector(dir_track,dir_sect,directory);              // if there is something after the separator
359                                  memset(directory,0,sizeof(sector));              if (lastsep + 1 != 0)
360                                  dir_track=track;                fileName = lastsep + 1;
361                                  dir_sect=sect;            }
362                                  dir_offset=0x10;          }
363                                  update_sector(dir_track,dir_sect,directory);  
364                          }          // remove the extension if there is one
365                  }          lastdot = strrchr(fileName, '.');
366                  fclose(tape);          if (lastdot != NULL)
367                  tape=NULL;            *lastdot = 0;
368          }          for (i = 0; i<17; i++)
369          directory[2]=dir_offset;          {
370          update_sector(dir_track,dir_sect,directory);            name[i] = fileName[i];
371              if (name[i] == 0) break;
372          if (track>=tracks) tracks=track+1;          }
373          total_sectors=tracks*NBSECT;        }
374          free_sectors=total_sectors-used_sectors;  
375          bitmap[2]=free_sectors & 0xFF;        start=(header[6]<<8)+header[7];
376          bitmap[3]=free_sectors >> 8;        end  =(header[4]<<8)+header[5];
377          bitmap[6]=tracks;        for (i=0; i<end+1-start; i++)
378          bitmap[9]=tracks;          file_buffer[i]=fgetc(tape);
379          update_sector(20,2,bitmap);        printf("Found %s\n",name);
380          store_file(file_buffer,name,header);
381          imageheader.tracks=tracks;        bitmap[4]++; // number of files
382          fwrite(&imageheader,sizeof(imageheader),1,dsk);        dir_offset+=16;
383          for (track=0;track<tracks;track++)        if (dir_offset==0x100)
384                  for (sect=1;sect<=NBSECT;sect++)        {
385                          fwrite(disk[track][sect-1],sizeof(sector),1,dsk);          find_free_sector(directory);
386            directory[0]=track;
387            directory[1]=sect;
388            update_sector(dir_track,dir_sect,directory);
389            memset(directory,0,sizeof(sector));
390            dir_track=track;
391            dir_sect=sect;
392            dir_offset=0x10;
393            update_sector(dir_track,dir_sect,directory);
394          }
395        }
396        fclose(tape);
397        tape=NULL;
398      }
399      directory[2]=dir_offset;
400      update_sector(dir_track,dir_sect,directory);
401    
402      if (track>=tracks) tracks=track+1;
403      total_sectors=tracks*NBSECT;
404      free_sectors=total_sectors-used_sectors;
405      bitmap[2]=free_sectors & 0xFF;
406      bitmap[3]=free_sectors >> 8;
407      bitmap[6]=tracks;
408      bitmap[9]=tracks;
409      update_sector(20,2,bitmap);
410    
411      imageheader.tracks=tracks;
412      fwrite(&imageheader,sizeof(imageheader),1,dsk);
413      for (track=0;track<tracks;track++)
414        for (sect=1;sect<=NBSECT;sect++)
415          fwrite(disk[track][sect-1],sizeof(sector),1,dsk);
416    
417      return 0;    return 0;
418  }  }
419    
420    

Legend:
Removed from v.1319  
changed lines
  Added in v.1320

  ViewVC Help
Powered by ViewVC 1.1.26