ViewVC Help
View File | Revision Log | Show Annotations | Revision Graph | Root Listing
root/cebix/Frodo4/Src/1541d64.cpp
(Generate patch)

Comparing Frodo4/Src/1541d64.cpp (file contents):
Revision 1.2 by cebix, 2003-07-01T17:51:17Z vs.
Revision 1.7 by cebix, 2004-01-12T14:58:26Z

# Line 1 | Line 1
1   /*
2 < *  1541d64.cpp - 1541 emulation in .d64 file
2 > *  1541d64.cpp - 1541 emulation in disk image files (.d64/.x64/zipcode)
3   *
4   *  Frodo (C) 1994-1997,2002-2003 Christian Bauer
5 + *  zipcode decoding routines (C) 1993-1997 Marko Mäkelä, Paul David Doherty
6   *
7   *  This program is free software; you can redistribute it and/or modify
8   *  it under the terms of the GNU General Public License as published by
# Line 19 | Line 20
20   */
21  
22   /*
23 < * Incompatibilities:
24 < * ------------------
25 < *
26 < *  - Only read accesses possible
26 < *  - Not all commands implemented
27 < *  - The .d64 error info is read, but unused
23 > *  Incompatibilities:
24 > *   - No support for relative files
25 > *   - Unimplemented commands: P
26 > *   - Impossible to implement: B-E, M-E
27   */
28  
29   #include "sysdeps.h"
# Line 32 | Line 31
31   #include "1541d64.h"
32   #include "IEC.h"
33   #include "Prefs.h"
34 + #include "C64.h"
35 + #include "main.h"
36 +
37 + #define DEBUG 0
38 + #include "debug.h"
39  
40  
41   // Channel modes (IRC users listen up :-)
42   enum {
43          CHMOD_FREE,                     // Channel free
44          CHMOD_COMMAND,          // Command/error channel
45 <        CHMOD_DIRECTORY,        // Reading directory
46 <        CHMOD_FILE,                     // Sequential file open
47 <        CHMOD_DIRECT            // Direct buffer access ('#')
45 >        CHMOD_DIRECTORY,        // Reading directory, using large allocated buffer
46 >        CHMOD_FILE,                     // Sequential file open, using buffer in 1541 RAM
47 >        CHMOD_REL,                      // Relative file open, using buffer in 1541 RAM
48 >        CHMOD_DIRECT            // Direct buffer access ('#'), using buffer in 1541 RAM
49   };
50  
51 < // Access modes
51 > // Directory track
52 > const int DIR_TRACK = 18;
53 >
54 > // BAM structure
55   enum {
56 <        FMODE_READ, FMODE_WRITE, FMODE_APPEND
56 >        BAM_DIR_TRACK = 0,              // Track...
57 >        BAM_DIR_SECTOR = 1,             // ...and sector of first directory block (unused)
58 >        BAM_FMT_TYPE = 2,               // Format type
59 >        BAM_BITMAP = 4,                 // Sector allocation map
60 >        BAM_DISK_NAME = 144,    // Disk name
61 >        BAM_DISK_ID = 162,              // Disk ID
62 >        BAM_FMT_CHAR = 165              // Format characters
63   };
64  
65 < // File types
65 > // Directory structure
66   enum {
67 <        FTYPE_PRG, FTYPE_SEQ, FTYPE_USR, FTYPE_REL
67 >        DIR_NEXT_TRACK = 0,             // Track...
68 >        DIR_NEXT_SECTOR = 1,    // ... and sector of next directory block
69 >        DIR_ENTRIES = 2,                // Start of directory entries (8)
70 >
71 >        DE_TYPE = 0,                    // File type/flags
72 >        DE_TRACK = 1,                   // Track...
73 >        DE_SECTOR = 2,                  // ...and sector of first data block
74 >        DE_NAME = 3,                    // File name
75 >        DE_SIDE_TRACK = 19,             // Track...
76 >        DE_SIDE_SECTOR = 20,    // ...and sector of first side sector
77 >        DE_REC_LEN = 21,                // Record length
78 >        DE_OVR_TRACK = 26,              // Track...
79 >        DE_OVR_SECTOR = 27,             // ...and sector on overwrite (@)
80 >        DE_NUM_BLOCKS_L = 28,   // Number of blocks, LSB
81 >        DE_NUM_BLOCKS_H = 29,   // Number of blocks, MSB
82 >
83 >        SIZEOF_DE = 32                  // Size of directory entry
84 > };
85 >
86 > // Interleave of directory and data blocks
87 > const int DIR_INTERLEAVE = 3;
88 > const int DATA_INTERLEAVE = 10;
89 >
90 > // Number of sectors per track, for all tracks
91 > const int num_sectors[41] = {
92 >        0,
93 >        21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,
94 >        19,19,19,19,19,19,19,
95 >        18,18,18,18,18,18,
96 >        17,17,17,17,17,
97 >        17,17,17,17,17          // Tracks 36..40
98   };
99  
100 < // Number of tracks/sectors
101 < const int NUM_TRACKS = 35;
102 < const int NUM_SECTORS = 683;
100 > // Accumulated number of sectors
101 > const int accum_num_sectors[41] = {
102 >        0,
103 >        0,21,42,63,84,105,126,147,168,189,210,231,252,273,294,315,336,
104 >        357,376,395,414,433,452,471,
105 >        490,508,526,544,562,580,
106 >        598,615,632,649,666,
107 >        683,700,717,734,751     // Tracks 36..40
108 > };
109  
110   // Prototypes
111 < static bool match(uint8 *p, uint8 *n);
111 > static bool match(const uint8 *p, int p_len, const uint8 *n);
112  
113  
114   /*
115 < *  Constructor: Prepare emulation, open .d64 file
115 > *  Constructor: Prepare emulation, open image file
116   */
117  
118 < D64Drive::D64Drive(IEC *iec, char *filepath) : Drive(iec)
118 > ImageDrive::ImageDrive(IEC *iec, const char *filepath) : Drive(iec), the_file(NULL), bam(ram + 0x700), bam_dirty(false)
119   {
120 <        the_file = NULL;
121 <        ram = NULL;
122 <
73 <        Ready = false;
74 <        strcpy(orig_d64_name, filepath);
75 <        for (int i=0; i<=14; i++) {
76 <                chan_mode[i] = CHMOD_FREE;
77 <                chan_buf[i] = NULL;
120 >        for (int i=0; i<18; i++) {
121 >                ch[i].mode = CHMOD_FREE;
122 >                ch[i].buf = NULL;
123          }
124 <        chan_mode[15] = CHMOD_COMMAND;
80 <
81 <        // Open .d64 file
82 <        open_close_d64_file(filepath);
83 <        if (the_file != NULL) {
124 >        ch[15].mode = CHMOD_COMMAND;
125  
126 <                // Allocate 1541 RAM
86 <                ram = new uint8[0x800];
87 <                bam = (BAM *)(ram + 0x700);
126 >        Reset();
127  
128 <                Reset();
128 >        // Open image file
129 >        if (change_image(filepath))
130                  Ready = true;
91        }
131   }
132  
133  
# Line 96 | Line 135 | D64Drive::D64Drive(IEC *iec, char *filep
135   *  Destructor
136   */
137  
138 < D64Drive::~D64Drive()
138 > ImageDrive::~ImageDrive()
139   {
140 <        // Close .d64 file
102 <        open_close_d64_file("");
103 <
104 <        delete[] ram;
105 <        Ready = false;
140 >        close_image();
141   }
142  
143  
144   /*
145 < *  Open/close the .d64 file
145 > *  Close the image file
146   */
147  
148 < void D64Drive::open_close_d64_file(char *d64name)
148 > void ImageDrive::close_image(void)
149   {
150 <        long size;
116 <        uint8 magic[4];
117 <
118 <        // Close old .d64, if open
119 <        if (the_file != NULL) {
150 >        if (the_file) {
151                  close_all_channels();
152 +                if (bam_dirty) {
153 +                        write_sector(DIR_TRACK, 0, bam);
154 +                        bam_dirty = false;
155 +                }
156                  fclose(the_file);
157                  the_file = NULL;
158          }
159 + }
160  
125        // Open new .d64 file
126        if (d64name[0]) {
127                if ((the_file = fopen(d64name, "rb")) != NULL) {
128
129                        // Check length
130                        fseek(the_file, 0, SEEK_END);
131                        if ((size = ftell(the_file)) < NUM_SECTORS * 256) {
132                                fclose(the_file);
133                                the_file = NULL;
134                                return;
135                        }
161  
162 <                        // x64 image?
163 <                        rewind(the_file);
164 <                        fread(&magic, 4, 1, the_file);
140 <                        if (magic[0] == 0x43 && magic[1] == 0x15 && magic[2] == 0x41 && magic[3] == 0x64)
141 <                                image_header = 64;
142 <                        else
143 <                                image_header = 0;
162 > /*
163 > *  Open the image file
164 > */
165  
166 <                        // Preset error info (all sectors no error)
167 <                        memset(error_info, 1, NUM_SECTORS);
166 > bool ImageDrive::change_image(const char *path)
167 > {
168 >        // Close old image file
169 >        close_image();
170  
171 <                        // Load sector error info from .d64 file, if present
172 <                        if (!image_header && size == NUM_SECTORS * 257) {
173 <                                fseek(the_file, NUM_SECTORS * 256, SEEK_SET);
174 <                                fread(&error_info, NUM_SECTORS, 1, the_file);
175 <                        }
176 <                }
171 >        // Open new image file (try write access first, then read-only)
172 >        write_protected = false;
173 >        the_file = open_image_file(path, true);
174 >        if (the_file == NULL) {
175 >                write_protected = true;
176 >                the_file = open_image_file(path, false);
177          }
178 +        if (the_file) {
179 +
180 +                // Determine file type and fill in image_file_desc structure
181 +                if (!parse_image_file(the_file, desc)) {
182 +                        fclose(the_file);
183 +                        the_file = false;
184 +                        return false;
185 +                }
186 +
187 +                // Read BAM
188 +                read_sector(DIR_TRACK, 0, bam);
189 +                bam_dirty = false;
190 +                return true;
191 +        } else
192 +                return false;
193   }
194  
195  
# Line 159 | Line 197 | void D64Drive::open_close_d64_file(char
197   *  Open channel
198   */
199  
200 < uint8 D64Drive::Open(int channel, char *filename)
200 > uint8 ImageDrive::Open(int channel, const uint8 *name, int name_len)
201   {
202 +        D(bug("ImageDrive::Open channel %d, file %s\n", channel, name));
203 +
204          set_error(ERR_OK);
205  
206          // Channel 15: execute file name as command
207          if (channel == 15) {
208 <                execute_command(filename);
208 >                execute_cmd(name, name_len);
209                  return ST_OK;
210          }
211  
212 <        if (chan_mode[channel] != CHMOD_FREE) {
212 >        if (ch[channel].mode != CHMOD_FREE) {
213                  set_error(ERR_NOCHANNEL);
214                  return ST_OK;
215          }
216  
217 <        if (filename[0] == '$')
217 >        if (name[0] == '$')
218                  if (channel)
219 <                        return open_file_ts(channel, 18, 0);
219 >                        return open_file_ts(channel, DIR_TRACK, 0);
220                  else
221 <                        return open_directory(filename+1);
221 >                        return open_directory(name + 1, name_len - 1);
222  
223 <        if (filename[0] == '#')
224 <                return open_direct(channel, filename);
223 >        if (name[0] == '#')
224 >                return open_direct(channel, name);
225  
226 <        return open_file(channel, filename);
226 >        return open_file(channel, name, name_len);
227   }
228  
229  
# Line 191 | Line 231 | uint8 D64Drive::Open(int channel, char *
231   *  Open file
232   */
233  
234 < uint8 D64Drive::open_file(int channel, char *filename)
234 > uint8 ImageDrive::open_file(int channel, const uint8 *name, int name_len)
235   {
236 <        char plainname[256];
237 <        int filemode = FMODE_READ;
238 <        int filetype = FTYPE_PRG;
239 <        int track, sector;
240 <
241 <        convert_filename(filename, plainname, &filemode, &filetype);
242 <
243 <        // Channel 0 is READ PRG, channel 1 is WRITE PRG
244 <        if (!channel) {
245 <                filemode = FMODE_READ;
246 <                filetype = FTYPE_PRG;
247 <        }
248 <        if (channel == 1) {
249 <                filemode = FMODE_WRITE;
250 <                filetype = FTYPE_PRG;
236 >        uint8 plain_name[NAMEBUF_LENGTH];
237 >        int plain_name_len;
238 >        int mode = FMODE_READ;
239 >        int type = FTYPE_DEL;
240 >        int rec_len = 0;
241 >        parse_file_name(name, name_len, plain_name, plain_name_len, mode, type, rec_len);
242 >        if (plain_name_len > 16)
243 >                plain_name_len = 16;
244 >
245 >        D(bug(" plain name %s, type %d, mode %d\n", plain_name, type, mode));
246 >
247 >        // Channel 0 is READ, channel 1 is WRITE
248 >        if (channel == 0 || channel == 1) {
249 >                mode = channel ? FMODE_WRITE : FMODE_READ;
250 >                if (type == FTYPE_DEL)
251 >                        type = FTYPE_PRG;
252 >        }
253 >
254 >        ch[channel].writing = (mode == FMODE_WRITE || mode == FMODE_APPEND);
255 >
256 >        // Wildcards are only allowed on reading
257 >        if (ch[channel].writing && (strchr((const char *)plain_name, '*') || strchr((const char *)plain_name, '?'))) {
258 >                set_error(ERR_SYNTAX33);
259 >                return ST_OK;
260          }
261  
262 <        // Allow only read accesses
263 <        if (filemode != FMODE_READ) {
262 >        // Check for write-protection if writing
263 >        if (ch[channel].writing && write_protected) {
264                  set_error(ERR_WRITEPROTECT);
265                  return ST_OK;
266          }
267  
268 <        // Find file in directory and open it
269 <        if (find_file(plainname, &track, &sector))
270 <                return open_file_ts(channel, track, sector);
271 <        else
272 <                set_error(ERR_FILENOTFOUND);
268 >        // Relative files are not supported
269 >        if (type == FTYPE_REL) {
270 >                set_error(ERR_UNIMPLEMENTED);
271 >                return ST_OK;
272 >        }
273  
274 <        return ST_OK;
275 < }
274 >        // Find file in directory
275 >        int dir_track, dir_sector, entry;
276 >        if (find_first_file(plain_name, plain_name_len, dir_track, dir_sector, entry)) {
277  
278 +                // File exists
279 +                D(bug(" file exists, dir track %d, sector %d, entry %d\n", dir_track, dir_sector, entry));
280 +                ch[channel].dir_track = dir_track;
281 +                ch[channel].dir_sector = dir_sector;
282 +                ch[channel].entry = entry;
283 +                uint8 *de = dir + DIR_ENTRIES + entry * SIZEOF_DE;
284  
285 < /*
286 < *  Analyze file name, get access mode and type
287 < */
285 >                // Get file type from existing file if not specified in file name
286 >                if (type == FTYPE_DEL)
287 >                        type = de[DE_TYPE] & 7;
288  
289 < void D64Drive::convert_filename(char *srcname, char *destname, int *filemode, int *filetype)
234 < {
235 <        char *p;
289 >                if ((de[DE_TYPE] & 7) != type) {
290  
291 <        // Search for ':', p points to first character after ':'
292 <        if ((p = strchr(srcname, ':')) != NULL)
239 <                p++;
240 <        else
241 <                p = srcname;
291 >                        // File type doesn't match
292 >                        set_error(ERR_FILETYPE);
293  
294 <        // Remaining string -> destname
244 <        strncpy(destname, p, NAMEBUF_LENGTH);
294 >                } else if (mode == FMODE_WRITE) {
295  
296 <        // Search for ','
247 <        p = destname;
248 <        while (*p && (*p != ',')) p++;
296 >                        if (name[0] == '@') {
297  
298 <        // Look for mode parameters seperated by ','
299 <        p = destname;
252 <        while ((p = strchr(p, ',')) != NULL) {
298 >                                // Open old file for overwriting (save-replace)
299 >                                return create_file(channel, plain_name, plain_name_len, type, true);
300  
301 <                // Cut string after the first ','
255 <                *p++ = 0;
301 >                        } else {
302  
303 <                switch (*p) {
304 <                        case 'P':
305 <                                *filetype = FTYPE_PRG;
260 <                                break;
261 <                        case 'S':
262 <                                *filetype = FTYPE_SEQ;
263 <                                break;
264 <                        case 'U':
265 <                                *filetype = FTYPE_USR;
266 <                                break;
267 <                        case 'L':
268 <                                *filetype = FTYPE_REL;
269 <                                break;
270 <                        case 'R':
271 <                                *filemode = FMODE_READ;
272 <                                break;
273 <                        case 'W':
274 <                                *filemode = FMODE_WRITE;
275 <                                break;
276 <                        case 'A':
277 <                                *filemode = FMODE_APPEND;
278 <                                break;
279 <                }
280 <        }
281 < }
303 >                                // File to be written already exists, error
304 >                                set_error(ERR_FILEEXISTS);
305 >                        }
306  
307 +                } else if (mode == FMODE_APPEND) {
308  
309 < /*
310 < *  Search file in directory, find first track and sector
286 < *  false: not found, true: found
287 < */
309 >                        // Open old file for appending
310 >                        open_file_ts(channel, de[DE_TRACK], de[DE_SECTOR]);
311  
312 < bool D64Drive::find_file(char *filename, int *track, int *sector)
313 < {
314 <        int i, j;
315 <        uint8 *p, *q;
316 <        DirEntry *de;
312 >                        // Seek to end of file
313 >                        int track = 0, sector = 0, num_blocks = 0;
314 >                        while (ch[channel].buf[0]) {
315 >                                if (!read_sector(track = ch[channel].buf[0], sector = ch[channel].buf[1], ch[channel].buf))
316 >                                        return ST_OK;
317 >                                num_blocks++;
318 >                        }
319  
320 <        // Scan all directory blocks
321 <        dir.next_track = bam->dir_track;
322 <        dir.next_sector = bam->dir_sector;
320 >                        // Change channel mode to writing, adjust buffer pointer
321 >                        ch[channel].writing = true;
322 >                        ch[channel].buf_len = ch[channel].buf[1] + 1;
323 >                        ch[channel].buf_ptr = ch[channel].buf + ch[channel].buf_len;
324 >                        ch[channel].track = track;
325 >                        ch[channel].sector = sector;
326 >                        ch[channel].num_blocks = num_blocks;
327 >
328 >                } else if (mode == FMODE_M) {
329 >
330 >                        // Open old file for reading, even if it is not closed
331 >                        return open_file_ts(channel, de[DE_TRACK], de[DE_SECTOR]);
332 >
333 >                } else {
334 >
335 >                        // Open old file for reading, error if file is open
336 >                        if (de[DE_TYPE] & 0x80)
337 >                                return open_file_ts(channel, de[DE_TRACK], de[DE_SECTOR]);
338 >                        else
339 >                                set_error(ERR_WRITEFILEOPEN);
340 >                }
341  
342 <        while (dir.next_track) {
300 <                if (!read_sector(dir.next_track, dir.next_sector, (uint8 *) &dir.next_track))
301 <                        return false;
342 >        } else {
343  
344 <                // Scan all 8 entries of a block
345 <                for (j=0; j<8; j++) {
305 <                        de = &dir.entry[j];
306 <                        *track = de->track;
307 <                        *sector = de->sector;
308 <
309 <                        if (de->type) {
310 <                                p = (uint8 *)filename;
311 <                                q = de->name;
312 <                                for (i=0; i<16 && *p; i++, p++, q++) {
313 <                                        if (*p == '*')  // Wildcard '*' matches all following characters
314 <                                                return true;
315 <                                        if (*p != *q) {
316 <                                                if (*p != '?') goto next_entry; // Wildcard '?' matches single character
317 <                                                if (*q == 0xa0) goto next_entry;
318 <                                        }
319 <                                }
344 >                // File doesn't exist
345 >                D(bug(" file not found\n"));
346  
347 <                                if (i == 16 || *q == 0xa0)
348 <                                        return true;
349 <                        }
324 < next_entry: ;
325 <                }
326 <        }
347 >                // Set file type to SEQ if not specified in file name
348 >                if (type == FTYPE_DEL)
349 >                        type = FTYPE_SEQ;
350  
351 <        return false;
351 >                if (mode == FMODE_WRITE) {
352 >
353 >                        // Create new file for writing
354 >                        return create_file(channel, plain_name, plain_name_len, type);
355 >
356 >                } else
357 >                        set_error(ERR_FILENOTFOUND);
358 >        }
359 >        return ST_OK;
360   }
361  
362  
363   /*
364 < *  Open file given track/sector of first block
364 > *  Open channel for reading from file given track/sector of first block
365   */
366  
367 < uint8 D64Drive::open_file_ts(int channel, int track, int sector)
367 > uint8 ImageDrive::open_file_ts(int channel, int track, int sector)
368   {
369 <        chan_buf[channel] = new uint8[256];
370 <        chan_mode[channel] = CHMOD_FILE;
369 >        D(bug("open_file_ts track %d, sector %d\n", track, sector));
370 >
371 >        // Allocate buffer and set channel mode
372 >        int buf = alloc_buffer(-1);
373 >        if (buf == -1) {
374 >                set_error(ERR_NOCHANNEL);
375 >                return ST_OK;
376 >        }
377 >        ch[channel].buf_num = buf;
378 >        ch[channel].buf = ram + 0x300 + buf * 0x100;
379 >        ch[channel].mode = CHMOD_FILE;
380  
381          // On the next call to Read, the first block will be read
382 <        chan_buf[channel][0] = track;
383 <        chan_buf[channel][1] = sector;
384 <        buf_len[channel] = 0;
382 >        ch[channel].buf[0] = track;
383 >        ch[channel].buf[1] = sector;
384 >        ch[channel].buf_len = 0;
385  
386          return ST_OK;
387   }
388  
389  
390   /*
391 < *  Prepare directory as BASIC program (channel 0)
391 > *  Create file and open channel for writing to file
392   */
393  
394 < const char type_char_1[] = "DSPUREERSELQGRL?";
355 < const char type_char_2[] = "EERSELQGRL??????";
356 < const char type_char_3[] = "LQGRL???????????";
357 <
358 < // Return true if name 'n' matches pattern 'p'
359 < static bool match(uint8 *p, uint8 *n)
394 > uint8 ImageDrive::create_file(int channel, const uint8 *name, int name_len, int type, bool overwrite)
395   {
396 <        if (!*p)                // Null pattern matches everything
362 <                return true;
396 >        D(bug("create_file %s, type %d\n", name, type));
397  
398 <        do {
399 <                if (*p == '*')  // Wildcard '*' matches all following characters
400 <                        return true;
401 <                if ((*p != *n) && (*p != '?'))  // Wildcard '?' matches single character
402 <                        return false;
403 <                p++; n++;
404 <        } while (*p);
398 >        // Allocate buffer
399 >        int buf = alloc_buffer(-1);
400 >        if (buf == -1) {
401 >                set_error(ERR_NOCHANNEL);
402 >                return ST_OK;
403 >        }
404 >        ch[channel].buf_num = buf;
405 >        ch[channel].buf = ram + 0x300 + buf * 0x100;
406 >
407 >        // Allocate new directory entry if not overwriting
408 >        if (!overwrite) {
409 >                if (!alloc_dir_entry(ch[channel].dir_track, ch[channel].dir_sector, ch[channel].entry)) {
410 >                        free_buffer(buf);
411 >                        return ST_OK;
412 >                }
413 >        }
414 >        uint8 *de = dir + DIR_ENTRIES + ch[channel].entry * SIZEOF_DE;
415 >
416 >        // Allocate first data block
417 >        ch[channel].track = DIR_TRACK - 1;
418 >        ch[channel].sector = -DATA_INTERLEAVE;
419 >        if (!alloc_next_block(ch[channel].track, ch[channel].sector, DATA_INTERLEAVE)) {
420 >                free_buffer(buf);
421 >                return ST_OK;
422 >        }
423 >        ch[channel].num_blocks = 1;
424 >        D(bug(" first data block on track %d, sector %d\n", ch[channel].track, ch[channel].sector));
425  
426 <        return *n == 0xa0;
426 >        // Write directory entry
427 >        memset(de, 0, SIZEOF_DE);
428 >        de[DE_TYPE] = type;             // bit 7 not set -> open file
429 >        if (overwrite) {
430 >                de[DE_OVR_TRACK] = ch[channel].track;
431 >                de[DE_OVR_SECTOR] = ch[channel].sector;
432 >        } else {
433 >                de[DE_TRACK] = ch[channel].track;
434 >                de[DE_SECTOR] = ch[channel].sector;
435 >        }
436 >        memset(de + DE_NAME, 0xa0, 16);
437 >        memcpy(de + DE_NAME, name, name_len);
438 >        write_sector(ch[channel].dir_track, ch[channel].dir_sector, dir);
439 >
440 >        // Set channel descriptor
441 >        ch[channel].mode = CHMOD_FILE;
442 >        ch[channel].writing = true;
443 >        ch[channel].buf_ptr = ch[channel].buf + 2;
444 >        ch[channel].buf_len = 2;
445 >        return ST_OK;
446   }
447  
375 uint8 D64Drive::open_directory(char *pattern)
376 {
377        int i, j, n, m;
378        uint8 *p, *q;
379        DirEntry *de;
380        uint8 c;
381        char *tmppat;
448  
449 + /*
450 + *  Prepare directory as BASIC program (channel 0)
451 + */
452 +
453 + const char type_char_1[] = "DSPUREER";
454 + const char type_char_2[] = "EERSELQG";
455 + const char type_char_3[] = "LQGRL???";
456 +
457 + uint8 ImageDrive::open_directory(const uint8 *pattern, int pattern_len)
458 + {
459          // Special treatment for "$0"
460 <        if (pattern[0] == '0' && pattern[1] == 0)
461 <                pattern += 1;
460 >        if (pattern[0] == '0' && pattern_len == 1) {
461 >                pattern++;
462 >                pattern_len--;
463 >        }
464  
465          // Skip everything before the ':' in the pattern
466 <        if ((tmppat = strchr(pattern, ':')) != NULL)
467 <                pattern = tmppat + 1;
466 >        uint8 *t = (uint8 *)memchr(pattern, ':', pattern_len);
467 >        if (t) {
468 >                t++;
469 >                pattern_len -= t - pattern;
470 >                pattern = t;
471 >        }
472  
473 <        p = buf_ptr[0] = chan_buf[0] = new uint8[8192];
474 <        chan_mode[0] = CHMOD_DIRECTORY;
473 >        ch[0].mode = CHMOD_DIRECTORY;
474 >        uint8 *p = ch[0].buf_ptr = ch[0].buf = new uint8[8192];
475  
476 <        // Create directory title
476 >        // Create directory title with disk name, ID and format type
477          *p++ = 0x01;    // Load address $0401 (from PET days :-)
478          *p++ = 0x04;
479          *p++ = 0x01;    // Dummy line link
# Line 401 | Line 483 | uint8 D64Drive::open_directory(char *pat
483          *p++ = 0x12;    // RVS ON
484          *p++ = '\"';
485  
486 <        q = bam->disk_name;
487 <        for (i=0; i<23; i++) {
486 >        uint8 *q = bam + BAM_DISK_NAME;
487 >        for (int i=0; i<23; i++) {
488 >                int c;
489                  if ((c = *q++) == 0xa0)
490                          *p++ = ' ';             // Replace 0xa0 by space
491                  else
# Line 412 | Line 495 | uint8 D64Drive::open_directory(char *pat
495          *p++ = 0;
496  
497          // Scan all directory blocks
498 <        dir.next_track = bam->dir_track;
499 <        dir.next_sector = bam->dir_sector;
498 >        dir[DIR_NEXT_TRACK] = DIR_TRACK;
499 >        dir[DIR_NEXT_SECTOR] = 1;
500  
501 <        while (dir.next_track) {
502 <                if (!read_sector(dir.next_track, dir.next_sector, (uint8 *) &dir.next_track))
501 >        int num_dir_blocks = 0;
502 >        while (dir[DIR_NEXT_TRACK] && num_dir_blocks < num_sectors[DIR_TRACK]) {
503 >                if (!read_sector(dir[DIR_NEXT_TRACK], dir[DIR_NEXT_SECTOR], dir))
504                          return ST_OK;
505 +                num_dir_blocks++;
506  
507                  // Scan all 8 entries of a block
508 <                for (j=0; j<8; j++) {
509 <                        de = &dir.entry[j];
508 >                uint8 *de = dir + DIR_ENTRIES;
509 >                for (int j=0; j<8; j++, de+=SIZEOF_DE) {
510 >                        if (de[DE_TYPE] && (pattern_len == 0 || match(pattern, pattern_len, de + DE_NAME))) {
511  
512 <                        if (de->type && match((uint8 *)pattern, de->name)) {
513 <                                *p++ = 0x01; // Dummy line link
512 >                                // Dummy line link
513 >                                *p++ = 0x01;
514                                  *p++ = 0x01;
515  
516 <                                *p++ = de->num_blocks_l; // Line number
517 <                                *p++ = de->num_blocks_h;
516 >                                // Line number = number of blocks
517 >                                *p++ = de[DE_NUM_BLOCKS_L];
518 >                                *p++ = de[DE_NUM_BLOCKS_H];
519  
520 +                                // Appropriate number of spaces to align file names
521                                  *p++ = ' ';
522 <                                n = (de->num_blocks_h << 8) + de->num_blocks_l;
522 >                                int n = (de[DE_NUM_BLOCKS_H] << 8) + de[DE_NUM_BLOCKS_L];
523                                  if (n<10) *p++ = ' ';
524                                  if (n<100) *p++ = ' ';
525  
526 +                                // File name enclosed in quotes
527                                  *p++ = '\"';
528 <                                q = de->name;
529 <                                m = 0;
530 <                                for (i=0; i<16; i++) {
528 >                                q = de + DE_NAME;
529 >                                uint8 c;
530 >                                bool m = false;
531 >                                for (int i=0; i<16; i++) {
532                                          if ((c = *q++) == 0xa0) {
533                                                  if (m)
534 <                                                        *p++ = ' ';             // Replace all 0xa0 by spaces
534 >                                                        *p++ = ' ';                     // Replace all 0xa0 by spaces
535                                                  else
536 <                                                        m = *p++ = '\"';        // But the first by a '"'
536 >                                                        m = (*p++ = '\"');      // But the first by a '"'
537                                          } else
538                                                  *p++ = c;
539                                  }
# Line 452 | Line 542 | uint8 D64Drive::open_directory(char *pat
542                                  else
543                                          *p++ = '\"';                    // No 0xa0, then append a space
544  
545 <                                if (de->type & 0x80)
545 >                                // Open files are marked by '*'
546 >                                if (de[DE_TYPE] & 0x80)
547                                          *p++ = ' ';
548                                  else
549                                          *p++ = '*';
550  
551 <                                *p++ = type_char_1[de->type & 0x0f];
552 <                                *p++ = type_char_2[de->type & 0x0f];
553 <                                *p++ = type_char_3[de->type & 0x0f];
551 >                                // File type
552 >                                *p++ = type_char_1[de[DE_TYPE] & 7];
553 >                                *p++ = type_char_2[de[DE_TYPE] & 7];
554 >                                *p++ = type_char_3[de[DE_TYPE] & 7];
555  
556 <                                if (de->type & 0x40)
556 >                                // Protected files are marked by '<'
557 >                                if (de[DE_TYPE] & 0x40)
558                                          *p++ = '<';
559                                  else
560                                          *p++ = ' ';
561  
562 +                                // Appropriate number of spaces at the end
563                                  *p++ = ' ';
564                                  if (n >= 10) *p++ = ' ';
565                                  if (n >= 100) *p++ = ' ';
# Line 474 | Line 568 | uint8 D64Drive::open_directory(char *pat
568                  }
569          }
570  
571 <        // Final line
572 <        q = p;
573 <        for (i=0; i<29; i++)
574 <                *q++ = ' ';
575 <
576 <        n = 0;
483 <        for (i=0; i<35; i++)
484 <                n += bam->bitmap[i*4];
571 >        // Final line, count number of free blocks
572 >        int n = 0;
573 >        for (int i=1; i<=35; i++) {
574 >                if (i != DIR_TRACK)     // exclude track 18
575 >                        n += num_free_blocks(i);
576 >        }
577  
578          *p++ = 0x01;            // Dummy line link
579          *p++ = 0x01;
# Line 501 | Line 593 | uint8 D64Drive::open_directory(char *pat
593          *p++ = 'E';
594          *p++ = '.';
595  
596 <        p = q;
596 >        memset(p, ' ', 13);
597 >        p += 13;
598 >
599          *p++ = 0;
600          *p++ = 0;
601          *p++ = 0;
602  
603 <        buf_len[0] = p - chan_buf[0];
510 <
603 >        ch[0].buf_len = p - ch[0].buf;
604          return ST_OK;
605   }
606  
# Line 516 | Line 609 | uint8 D64Drive::open_directory(char *pat
609   *  Open channel for direct buffer access
610   */
611  
612 < uint8 D64Drive::open_direct(int channel, char *filename)
612 > uint8 ImageDrive::open_direct(int channel, const uint8 *name)
613   {
614          int buf = -1;
615  
616 <        if (filename[1] == 0)
616 >        if (name[1] == 0)
617                  buf = alloc_buffer(-1);
618          else
619 <                if ((filename[1] >= '0') && (filename[1] <= '3') && (filename[2] == 0))
620 <                        buf = alloc_buffer(filename[1] - '0');
619 >                if ((name[1] >= '0') && (name[1] <= '3') && (name[2] == 0))
620 >                        buf = alloc_buffer(name[1] - '0');
621  
622          if (buf == -1) {
623                  set_error(ERR_NOCHANNEL);
# Line 532 | Line 625 | uint8 D64Drive::open_direct(int channel,
625          }
626  
627          // The buffers are in the 1541 RAM at $300 and are 256 bytes each
628 <        chan_buf[channel] = buf_ptr[channel] = ram + 0x300 + (buf << 8);
629 <        chan_mode[channel] = CHMOD_DIRECT;
630 <        chan_buf_num[channel] = buf;
628 >        ch[channel].mode = CHMOD_DIRECT;
629 >        ch[channel].buf = ram + 0x300 + buf * 0x100;
630 >        ch[channel].buf_num = buf;
631  
632          // Store actual buffer number in buffer
633 <        *chan_buf[channel] = buf + '0';
634 <        buf_len[channel] = 1;
633 >        ch[channel].buf[1] = buf + '0';
634 >        ch[channel].buf_len = 1;
635 >        ch[channel].buf_ptr = ch[channel].buf + 1;
636  
637          return ST_OK;
638   }
# Line 548 | Line 642 | uint8 D64Drive::open_direct(int channel,
642   *  Close channel
643   */
644  
645 < uint8 D64Drive::Close(int channel)
645 > uint8 ImageDrive::Close(int channel)
646   {
647 <        if (channel == 15) {
554 <                close_all_channels();
555 <                return ST_OK;
556 <        }
647 >        D(bug("ImageDrive::Close channel %d\n", channel));
648  
649 <        switch (chan_mode[channel]) {
649 >        switch (ch[channel].mode) {
650                  case CHMOD_FREE:
651                          break;
652  
653 +                case CHMOD_COMMAND:
654 +                        close_all_channels();
655 +                        break;
656 +
657                  case CHMOD_DIRECT:
658 <                        free_buffer(chan_buf_num[channel]);
659 <                        chan_buf[channel] = NULL;
660 <                        chan_mode[channel] = CHMOD_FREE;
658 >                        free_buffer(ch[channel].buf_num);
659 >                        ch[channel].buf = NULL;
660 >                        ch[channel].mode = CHMOD_FREE;
661                          break;
662  
663 <                default:
664 <                        delete[] chan_buf[channel];
665 <                        chan_buf[channel] = NULL;
666 <                        chan_mode[channel] = CHMOD_FREE;
663 >                case CHMOD_FILE:
664 >                        if (ch[channel].writing) {
665 >
666 >                                // Current block empty? Then write CR character
667 >                                if (ch[channel].buf_len == 2) {
668 >                                        ch[channel].buf[2] = 0x0d;
669 >                                        ch[channel].buf_len++;
670 >                                }
671 >
672 >                                // Write last data block
673 >                                ch[channel].buf[0] = 0;
674 >                                ch[channel].buf[1] = ch[channel].buf_len - 1;
675 >                                D(bug(" writing last data block\n"));
676 >                                if (!write_sector(ch[channel].track, ch[channel].sector, ch[channel].buf))
677 >                                        goto free;
678 >
679 >                                // Close write file in directory
680 >                                read_sector(ch[channel].dir_track, ch[channel].dir_sector, dir);
681 >                                uint8 *de = dir + DIR_ENTRIES + ch[channel].entry * SIZEOF_DE;
682 >                                de[DE_TYPE] |= 0x80;
683 >                                de[DE_NUM_BLOCKS_L] = ch[channel].num_blocks & 0xff;
684 >                                de[DE_NUM_BLOCKS_H] = ch[channel].num_blocks >> 8;
685 >                                if (de[DE_OVR_TRACK]) {
686 >                                        // Overwriting, free old data blocks and set pointer to new ones
687 >                                        free_block_chain(de[DE_TRACK], de[DE_SECTOR]);
688 >                                        de[DE_TRACK] = de[DE_OVR_TRACK];
689 >                                        de[DE_SECTOR] = de[DE_OVR_SECTOR];
690 >                                        de[DE_OVR_TRACK] = de[DE_OVR_SECTOR] = 0;
691 >                                }
692 >                                write_sector(ch[channel].dir_track, ch[channel].dir_sector, dir);
693 >                                D(bug(" directory entry updated\n"));
694 >                        }
695 > free:           free_buffer(ch[channel].buf_num);
696 >                        ch[channel].buf = NULL;
697 >                        ch[channel].mode = CHMOD_FREE;
698 >                        break;
699 >
700 >                case CHMOD_DIRECTORY:
701 >                        delete[] ch[channel].buf;
702 >                        ch[channel].buf = NULL;
703 >                        ch[channel].mode = CHMOD_FREE;
704                          break;
705          }
706  
# Line 580 | Line 712 | uint8 D64Drive::Close(int channel)
712   *  Close all channels
713   */
714  
715 < void D64Drive::close_all_channels()
715 > void ImageDrive::close_all_channels()
716   {
717          for (int i=0; i<15; i++)
718                  Close(i);
719 +        Close(16);
720 +        Close(17);
721  
722          cmd_len = 0;
723   }
# Line 593 | Line 727 | void D64Drive::close_all_channels()
727   *  Read from channel
728   */
729  
730 < uint8 D64Drive::Read(int channel, uint8 *byte)
730 > uint8 ImageDrive::Read(int channel, uint8 &byte)
731   {
732 <        switch (chan_mode[channel]) {
732 > //      D(bug("ImageDrive::Read channel %d\n", channel));
733 >
734 >        switch (ch[channel].mode) {
735 >                case CHMOD_FREE:
736 >                        if (current_error == ERR_OK)
737 >                                set_error(ERR_FILENOTOPEN);
738 >                        break;
739 >
740                  case CHMOD_COMMAND:
741 <                        *byte = *error_ptr++;
741 >                        // Read error channel
742 >                        byte = *error_ptr++;
743                          if (--error_len)
744                                  return ST_OK;
745                          else {
# Line 607 | Line 749 | uint8 D64Drive::Read(int channel, uint8
749                          break;
750  
751                  case CHMOD_FILE:
752 +                        if (ch[channel].writing)
753 +                                return ST_READ_TIMEOUT;
754 +                        if (current_error != ERR_OK)
755 +                                return ST_READ_TIMEOUT;
756 +
757                          // Read next block if necessary
758 <                        if (chan_buf[channel][0] && !buf_len[channel]) {
759 <                                if (!read_sector(chan_buf[channel][0], chan_buf[channel][1], chan_buf[channel]))
758 >                        if (ch[channel].buf_len == 0 && ch[channel].buf[0]) {
759 >                                D(bug(" reading next data block track %d, sector %d\n", ch[channel].buf[0], ch[channel].buf[1]));
760 >                                if (!read_sector(ch[channel].buf[0], ch[channel].buf[1], ch[channel].buf))
761                                          return ST_READ_TIMEOUT;
762 <                                buf_ptr[channel] = chan_buf[channel] + 2;
762 >                                ch[channel].buf_ptr = ch[channel].buf + 2;
763  
764                                  // Determine block length
765 <                                buf_len[channel] = chan_buf[channel][0] ? 254 : (uint8)chan_buf[channel][1]-1;
765 >                                ch[channel].buf_len = ch[channel].buf[0] ? 254 : ch[channel].buf[1] - 1;
766                          }
767  
768 <                        if (buf_len[channel] > 0) {
769 <                                *byte = *buf_ptr[channel]++;
770 <                                if (!--buf_len[channel] && !chan_buf[channel][0])
768 >                        if (ch[channel].buf_len > 0) {
769 >                                byte = *(ch[channel].buf_ptr)++;
770 >                                if (--(ch[channel].buf_len) == 0 && ch[channel].buf[0] == 0)
771                                          return ST_EOF;
772                                  else
773                                          return ST_OK;
# Line 629 | Line 777 | uint8 D64Drive::Read(int channel, uint8
777  
778                  case CHMOD_DIRECTORY:
779                  case CHMOD_DIRECT:
780 <                        if (buf_len[channel] > 0) {
781 <                                *byte = *buf_ptr[channel]++;
782 <                                if (--buf_len[channel])
780 >                        if (ch[channel].buf_len > 0) {
781 >                                byte = *(ch[channel].buf_ptr)++;
782 >                                if (--(ch[channel].buf_len))
783                                          return ST_OK;
784                                  else
785                                          return ST_EOF;
# Line 647 | Line 795 | uint8 D64Drive::Read(int channel, uint8
795   *  Write byte to channel
796   */
797  
798 < uint8 D64Drive::Write(int channel, uint8 byte, bool eoi)
798 > uint8 ImageDrive::Write(int channel, uint8 byte, bool eoi)
799   {
800 <        switch (chan_mode[channel]) {
800 > //      D(bug("ImageDrive::Write channel %d, byte %02x, eoi %d\n", channel, byte, eoi));
801 >
802 >        switch (ch[channel].mode) {
803                  case CHMOD_FREE:
804 <                        set_error(ERR_FILENOTOPEN);
804 >                        if (current_error == ERR_OK)
805 >                                set_error(ERR_FILENOTOPEN);
806                          break;
807  
808                  case CHMOD_COMMAND:
809                          // Collect characters and execute command on EOI
810 <                        if (cmd_len >= 40)
810 >                        if (cmd_len > 58) {
811 >                                set_error(ERR_SYNTAX32);
812                                  return ST_TIMEOUT;
813 +                        }
814  
815 <                        cmd_buffer[cmd_len++] = byte;
815 >                        cmd_buf[cmd_len++] = byte;
816  
817                          if (eoi) {
818 <                                cmd_buffer[cmd_len++] = 0;
818 >                                execute_cmd(cmd_buf, cmd_len);
819                                  cmd_len = 0;
667                                execute_command(cmd_buffer);
820                          }
821                          return ST_OK;
822  
823                  case CHMOD_DIRECTORY:
824                          set_error(ERR_WRITEFILEOPEN);
825                          break;
826 +
827 +                case CHMOD_FILE:
828 +                        if (!ch[channel].writing)
829 +                                return ST_TIMEOUT;
830 +                        if (current_error != ERR_OK)
831 +                                return ST_TIMEOUT;
832 +
833 +                        // Buffer full?
834 +                        if (ch[channel].buf_len >= 256) {
835 +
836 +                                // Yes, allocate new block
837 +                                int track = ch[channel].track, sector = ch[channel].sector;
838 +                                if (!alloc_next_block(track, sector, DATA_INTERLEAVE))
839 +                                        return ST_TIMEOUT;
840 +                                ch[channel].num_blocks++;
841 +                                D(bug("next data block on track %d, sector %d\n", track, sector));
842 +
843 +                                // Write buffer with link to new block
844 +                                ch[channel].buf[0] = track;
845 +                                ch[channel].buf[1] = sector;
846 +                                write_sector(ch[channel].track, ch[channel].sector, ch[channel].buf);
847 +
848 +                                // Reset buffer
849 +                                ch[channel].buf_ptr = ch[channel].buf + 2;
850 +                                ch[channel].buf_len = 2;
851 +                                ch[channel].track = track;
852 +                                ch[channel].sector = sector;
853 +                        }
854 +                        *(ch[channel].buf_ptr)++ = byte;
855 +                        ch[channel].buf_len++;
856 +                        return ST_OK;
857 +
858 +                case CHMOD_DIRECT:
859 +                        if (ch[channel].buf_len < 256) {
860 +                                *(ch[channel].buf_ptr)++ = byte;
861 +                                ch[channel].buf_len++;
862 +                                return ST_OK;
863 +                        } else
864 +                                return ST_TIMEOUT;
865 +                        break;
866          }
867          return ST_TIMEOUT;
868   }
869  
870  
871   /*
872 < *  Execute command string
872 > *  Reset drive
873   */
874  
875 < void D64Drive::execute_command(char *command)
875 > void ImageDrive::Reset(void)
876   {
877 <        uint16 adr;
686 <        int len;
877 >        close_all_channels();
878  
879 <        switch (command[0]) {
880 <                case 'B':
881 <                        if (command[1] != '-')
691 <                                set_error(ERR_SYNTAX30);
692 <                        else
693 <                                switch (command[2]) {
694 <                                        case 'R':
695 <                                                block_read_cmd(&command[3]);
696 <                                                break;
697 <
698 <                                        case 'P':
699 <                                                buffer_ptr_cmd(&command[3]);
700 <                                                break;
701 <
702 <                                        case 'A':
703 <                                        case 'F':
704 <                                        case 'W':
705 <                                                set_error(ERR_WRITEPROTECT);
706 <                                                break;
707 <
708 <                                        default:
709 <                                                set_error(ERR_SYNTAX30);
710 <                                                break;
711 <                                }
712 <                        break;
879 >        cmd_len = 0;
880 >        for (int i=0; i<4; i++)
881 >                buf_free[i] = true;
882  
883 <                case 'M':
884 <                        if (command[1] != '-')
885 <                                set_error(ERR_SYNTAX30);
886 <                        else
718 <                                switch (command[2]) {
719 <                                        case 'R':
720 <                                                adr = ((uint8)command[4] << 8) | ((uint8)command[3]);
721 <                                                error_ptr = (char *)(ram + (adr & 0x07ff));
722 <                                                if (!(error_len = (uint8)command[5]))
723 <                                                        error_len = 1;
724 <                                                break;
725 <
726 <                                        case 'W':
727 <                                                adr = ((uint8)command[4] << 8) | ((uint8)command[3]);
728 <                                                len = (uint8)command[5];
729 <                                                for (int i=0; i<len; i++)
730 <                                                        ram[adr+i] = (uint8)command[i+6];
731 <                                                break;
883 >        if (bam_dirty) {
884 >                write_sector(DIR_TRACK, 0, bam);
885 >                bam_dirty = false;
886 >        }
887  
888 <                                        default:
734 <                                                set_error(ERR_SYNTAX30);
735 <                                }
736 <                        break;
888 >        memset(ram, 0, sizeof(ram));
889  
890 <                case 'I':
891 <                        close_all_channels();
892 <                        read_sector(18, 0, (uint8 *)bam);
893 <                        set_error(ERR_OK);
742 <                        break;
890 >        read_sector(DIR_TRACK, 0, bam);
891 >
892 >        set_error(ERR_STARTUP);
893 > }
894  
895 <                case 'U':
896 <                        switch (command[1] & 0x0f) {
897 <                                case 1:         // U1/UA: Block-Read
898 <                                        block_read_cmd(&command[2]);
899 <                                        break;
900 <
901 <                                case 2:         // U2/UB: Block-Write
902 <                                        set_error(ERR_WRITEPROTECT);
903 <                                        break;
904 <
905 <                                case 10:        // U:/UJ: Reset
906 <                                        Reset();
907 <                                        break;
908 <
758 <                                default:
759 <                                        set_error(ERR_SYNTAX30);
760 <                                        break;
895 >
896 > /*
897 > *  Allocate floppy buffer
898 > *   -> Desired buffer number or -1
899 > *   <- Allocated buffer number or -1
900 > */
901 >
902 > int ImageDrive::alloc_buffer(int want)
903 > {
904 >        if (want == -1) {
905 >                for (want=3; want>=0; want--)
906 >                        if (buf_free[want]) {
907 >                                buf_free[want] = false;
908 >                                return want;
909                          }
910 <                        break;
910 >                return -1;
911 >        }
912  
913 <                case 'G':
914 <                        if (command[1] != ':')
915 <                                set_error(ERR_SYNTAX30);
916 <                        else
917 <                                chd64_cmd(&command[2]);
918 <                        break;
913 >        if (want < 4)
914 >                if (buf_free[want]) {
915 >                        buf_free[want] = false;
916 >                        return want;
917 >                } else
918 >                        return -1;
919 >        else
920 >                return -1;
921 > }
922  
771                case 'C':
772                case 'N':
773                case 'R':
774                case 'S':
775                case 'V':
776                        set_error(ERR_WRITEPROTECT);
777                        break;
923  
924 <                default:
925 <                        set_error(ERR_SYNTAX30);
926 <                        break;
924 > /*
925 > *  Free floppy buffer
926 > */
927 >
928 > void ImageDrive::free_buffer(int buf)
929 > {
930 >        buf_free[buf] = true;
931 > }
932 >
933 >
934 > /*
935 > *  Search file in directory, return directory track/sector and entry number
936 > *  false: not found, true: found
937 > */
938 >
939 > // Return true if name 'n' matches pattern 'p'
940 > static bool match(const uint8 *p, int p_len, const uint8 *n)
941 > {
942 >        if (p_len > 16)
943 >                p_len = 16;
944 >
945 >        int c = 0;
946 >        while (p_len-- > 0) {
947 >                if (*p == '*')  // Wildcard '*' matches all following characters
948 >                        return true;
949 >                if ((*p != *n) && (*p != '?'))  // Wildcard '?' matches single character
950 >                        return false;
951 >                p++; n++; c++;
952 >        }
953 >
954 >        return *n == 0xa0 || c == 16;
955 > }
956 >
957 > bool ImageDrive::find_file(const uint8 *pattern, int pattern_len, int &dir_track, int &dir_sector, int &entry, bool cont)
958 > {
959 >        // Counter to prevent cyclic directories from resulting in an infinite loop
960 >        int num_dir_blocks = 0;
961 >
962 >        // Pointer to current directory entry
963 >        uint8 *de = NULL;
964 >        if (cont)
965 >                de = dir + DIR_ENTRIES + entry * SIZEOF_DE;
966 >        else {
967 >                dir[DIR_NEXT_TRACK] = DIR_TRACK;
968 >                dir[DIR_NEXT_SECTOR] = 1;
969 >                entry = 8;
970 >        }
971 >
972 >        while (num_dir_blocks < num_sectors[DIR_TRACK]) {
973 >
974 >                // Goto next entry
975 >                entry++; de += SIZEOF_DE;
976 >                if (entry >= 8) {
977 >
978 >                        // Read next directory block
979 >                        if (dir[DIR_NEXT_TRACK] == 0)
980 >                                return false;
981 >                        if (!read_sector(dir_track = dir[DIR_NEXT_TRACK], dir_sector = dir[DIR_NEXT_SECTOR], dir))
982 >                                return false;
983 >                        num_dir_blocks++;
984 >                        entry = 0;
985 >                        de = dir + DIR_ENTRIES;
986 >                }
987 >
988 >                // Does entry match pattern?
989 >                if (de[DE_TYPE] && match(pattern, pattern_len, de + DE_NAME))
990 >                        return true;
991          }
992 +        return false;
993 + }
994 +
995 + bool ImageDrive::find_first_file(const uint8 *pattern, int pattern_len, int &dir_track, int &dir_sector, int &entry)
996 + {
997 +        return find_file(pattern, pattern_len, dir_track, dir_sector, entry, false);
998 + }
999 +
1000 + bool ImageDrive::find_next_file(const uint8 *pattern, int pattern_len, int &dir_track, int &dir_sector, int &entry)
1001 + {
1002 +        return find_file(pattern, pattern_len, dir_track, dir_sector, entry, true);
1003   }
1004  
1005  
1006   /*
1007 < *  Execute B-R command
1007 > *  Allocate new entry in directory, returns false on error (usually when
1008 > *  all sectors of track 18 are allocated)
1009 > *  The track/sector and entry numbers are returned
1010   */
1011  
1012 < void D64Drive::block_read_cmd(char *command)
1012 > bool ImageDrive::alloc_dir_entry(int &track, int &sector, int &entry)
1013   {
1014 <        int channel, drvnum, track, sector;
1014 >        // First look for free entry in existing directory blocks
1015 >        dir[DIR_NEXT_TRACK] = DIR_TRACK;
1016 >        dir[DIR_NEXT_SECTOR] = 1;
1017 >        while (dir[DIR_NEXT_TRACK]) {
1018 >                if (!read_sector(track = dir[DIR_NEXT_TRACK], sector = dir[DIR_NEXT_SECTOR], dir))
1019 >                        return false;
1020  
1021 <        if (parse_bcmd(command, &channel, &drvnum, &track, &sector)) {
1022 <                if (chan_mode[channel] == CHMOD_DIRECT) {
1023 <                        read_sector(track, sector, buf_ptr[channel] = chan_buf[channel]);
1024 <                        buf_len[channel] = 256;
1025 <                        set_error(ERR_OK);
1026 <                } else
1027 <                        set_error(ERR_NOCHANNEL);
1028 <        } else
1029 <                set_error(ERR_SYNTAX30);
1021 >                uint8 *de = dir + DIR_ENTRIES;
1022 >                for (entry=0; entry<8; entry++, de+=SIZEOF_DE) {
1023 >                        if (de[DE_TYPE] == 0) {
1024 >                                D(bug(" allocated entry %d in dir track %d, sector %d\n", entry, track, sector));
1025 >                                return true;
1026 >                        }
1027 >                }
1028 >        }
1029 >
1030 >        // No free entry found, allocate new directory block
1031 >        int last_track = track, last_sector = sector;
1032 >        if (!alloc_next_block(track, sector, DIR_INTERLEAVE))
1033 >                return false;
1034 >        D(bug(" new directory block track %d, sector %d\n", track, sector));
1035 >
1036 >        // Write link to new block to last block
1037 >        dir[DIR_NEXT_TRACK] = track;
1038 >        dir[DIR_NEXT_SECTOR] = sector;
1039 >        write_sector(last_track, last_sector, dir);
1040 >
1041 >        // Write new empty directory block and return first entry
1042 >        memset(dir, 0, 256);
1043 >        dir[DIR_NEXT_SECTOR] = 0xff;
1044 >        write_sector(track, sector, dir);
1045 >        entry = 0;
1046 >        return true;
1047 > }
1048 >
1049 > /*
1050 > *  Test if block is free in BAM (track/sector are not checked for validity)
1051 > */
1052 >
1053 > bool ImageDrive::is_block_free(int track, int sector)
1054 > {
1055 >        uint8 *p = bam + BAM_BITMAP + (track - 1) * 4;
1056 >        int byte = sector / 8 + 1;
1057 >        int bit = sector & 7;
1058 >        return p[byte] & (1 << bit);
1059   }
1060  
1061  
1062   /*
1063 < *  Execute B-P command
1063 > *  Get number of free blocks on a track
1064   */
1065  
1066 < void D64Drive::buffer_ptr_cmd(char *command)
1066 > int ImageDrive::num_free_blocks(int track)
1067   {
1068 <        int channel, pointer, i;
1068 >        return bam[BAM_BITMAP + (track - 1) * 4];
1069 > }
1070 >
1071 >
1072 > /*
1073 > *  Clear BAM, mark all blocks as free
1074 > */
1075 >
1076 > static void clear_bam(uint8 *bam)
1077 > {
1078 >        for (int track=1; track<=35; track++) {
1079 >                static const uint8 num2bits[8] = {0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff};
1080 >                (bam + BAM_BITMAP)[(track-1) * 4 + 0] = num_sectors[track];
1081 >                (bam + BAM_BITMAP)[(track-1) * 4 + 1] = 0xff;
1082 >                (bam + BAM_BITMAP)[(track-1) * 4 + 2] = 0xff;
1083 >                (bam + BAM_BITMAP)[(track-1) * 4 + 3] = num2bits[num_sectors[track] - 16];
1084 >        }
1085 > }
1086 >
1087 >
1088 > /*
1089 > *  Allocate block in BAM, returns error code
1090 > */
1091 >
1092 > int ImageDrive::alloc_block(int track, int sector)
1093 > {
1094 >        if (track < 1 || track > 35 || sector < 0 || sector >= num_sectors[track])
1095 >                return ERR_ILLEGALTS;
1096 >
1097 >        uint8 *p = bam + BAM_BITMAP + (track - 1) * 4;
1098 >        int byte = sector / 8 + 1;
1099 >        int bit = sector & 7;
1100 >
1101 >        // Block free?
1102 >        if (p[byte] & (1 << bit)) {
1103 >
1104 >                // Yes, allocate and decrement free block count
1105 >                D(bug("allocating block at track %d, sector %d\n", track, sector));
1106 >                p[byte] &= ~(1 << bit);
1107 >                p[0]--;
1108 >                bam_dirty = true;
1109 >                return ERR_OK;
1110  
814        if (parse_bcmd(command, &channel, &pointer, &i, &i)) {
815                if (chan_mode[channel] == CHMOD_DIRECT) {
816                        buf_ptr[channel] = chan_buf[channel] + pointer;
817                        buf_len[channel] = 256 - pointer;
818                        set_error(ERR_OK);
819                } else
820                        set_error(ERR_NOCHANNEL);
1111          } else
1112 <                set_error(ERR_SYNTAX30);
1112 >                return ERR_NOBLOCK;
1113   }
1114  
1115  
1116   /*
1117 < *  Parse block command parameters
828 < *  true: OK, false: error
1117 > *  Free block in BAM, returns error code
1118   */
1119  
1120 < bool D64Drive::parse_bcmd(char *cmd, int *arg1, int *arg2, int *arg3, int *arg4)
1120 > int ImageDrive::free_block(int track, int sector)
1121   {
1122 <        int i;
1122 >        if (track < 1 || track > 35 || sector < 0 || sector >= num_sectors[track])
1123 >                return ERR_ILLEGALTS;
1124  
1125 <        if (*cmd == ':') cmd++;
1125 >        uint8 *p = bam + BAM_BITMAP + (track - 1) * 4;
1126 >        int byte = sector / 8 + 1;
1127 >        int bit = sector & 7;
1128  
1129 <        // Read four parameters separated by space, cursor right or comma
1130 <        while (*cmd == ' ' || *cmd == 0x1d || *cmd == 0x2c) cmd++;
839 <        if (!*cmd) return false;
1129 >        // Block allocated?
1130 >        if (!(p[byte] & (1 << bit))) {
1131  
1132 <        i = 0;
1133 <        while (*cmd >= 0x30 && *cmd < 0x40) {
1134 <                i *= 10;
1135 <                i += *cmd++ & 0x0f;
1132 >                // Yes, free and increment free block count
1133 >                D(bug("freeing block at track %d, sector %d\n", track, sector));
1134 >                p[byte] |= (1 << bit);
1135 >                p[0]++;
1136 >                bam_dirty = true;
1137          }
1138 <        *arg1 = i & 0xff;
1138 >        return ERR_OK;
1139 > }
1140  
848        while (*cmd == ' ' || *cmd == 0x1d || *cmd == 0x2c) cmd++;
849        if (!*cmd) return false;
1141  
1142 <        i = 0;
1143 <        while (*cmd >= 0x30 && *cmd < 0x40) {
1144 <                i *= 10;
1145 <                i += *cmd++ & 0x0f;
1142 > /*
1143 > *  Allocate chain of data blocks in BAM
1144 > */
1145 >
1146 > bool ImageDrive::alloc_block_chain(int track, int sector)
1147 > {
1148 >        uint8 buf[256];
1149 >        while (alloc_block(track, sector) == ERR_OK) {
1150 >                if (!read_sector(track, sector, buf))
1151 >                        return false;
1152 >                track = buf[0];
1153 >                sector = buf[1];
1154          }
1155 <        *arg2 = i & 0xff;
1155 >        return true;
1156 > }
1157  
858        while (*cmd == ' ' || *cmd == 0x1d || *cmd == 0x2c) cmd++;
859        if (!*cmd) return false;
1158  
1159 <        i = 0;
1160 <        while (*cmd >= 0x30 && *cmd < 0x40) {
1161 <                i *= 10;
1162 <                i += *cmd++ & 0x0f;
1159 > /*
1160 > *  Free chain of data blocks in BAM
1161 > */
1162 >
1163 > bool ImageDrive::free_block_chain(int track, int sector)
1164 > {
1165 >        uint8 buf[256];
1166 >        while (free_block(track, sector) == ERR_OK) {
1167 >                if (!read_sector(track, sector, buf))
1168 >                        return false;
1169 >                track = buf[0];
1170 >                sector = buf[1];
1171          }
1172 <        *arg3 = i & 0xff;
1172 >        return true;
1173 > }
1174  
868        while (*cmd == ' ' || *cmd == 0x1d || *cmd == 0x2c) cmd++;
869        if (!*cmd) return false;
1175  
1176 <        i = 0;
1177 <        while (*cmd >= 0x30 && *cmd < 0x40) {
1178 <                i *= 10;
1179 <                i += *cmd++ & 0x0f;
1176 > /*
1177 > *  Search and allocate next free block, returns false if no more blocks
1178 > *  are free (ERR_DISKFULL is also set in this case)
1179 > *  "track" and "sector" must be set to the block where the search should
1180 > *  begin
1181 > */
1182 >
1183 > bool ImageDrive::alloc_next_block(int &track, int &sector, int interleave)
1184 > {
1185 >        // Find track with free blocks
1186 >        bool side_changed = false;
1187 >        while (num_free_blocks(track) == 0) {
1188 >                if (track == DIR_TRACK) {       // Directory doesn't grow to other tracks
1189 > full:           track = sector = 0;
1190 >                        set_error(ERR_DISKFULL);
1191 >                        return false;
1192 >                } else if (track > DIR_TRACK) {
1193 >                        track++;
1194 >                        if (track > 35) {
1195 >                                if (!side_changed)
1196 >                                        side_changed = true;
1197 >                                else
1198 >                                        goto full;
1199 >                                track = DIR_TRACK - 1;
1200 >                                sector = 0;
1201 >                        }
1202 >                } else {
1203 >                        track--;
1204 >                        if (track < 1) {
1205 >                                if (!side_changed)
1206 >                                        side_changed = true;
1207 >                                else
1208 >                                        goto full;
1209 >                                track = DIR_TRACK + 1;
1210 >                                sector = 0;
1211 >                        }
1212 >                }
1213          }
876        *arg4 = i & 0xff;
1214  
1215 +        // Find next free block on track
1216 +        int num = num_sectors[track];
1217 +        sector = sector + interleave;
1218 +        if (sector >= num) {
1219 +                sector -= num;
1220 +                if (sector)
1221 +                        sector--;
1222 +        }
1223 +        while (!is_block_free(track, sector)) {
1224 +                sector++;
1225 +                if (sector >= num_sectors[track]) {
1226 +                        sector = 0;
1227 +                        while (!is_block_free(track, sector)) {
1228 +                                sector++;
1229 +                                if (sector >= num_sectors[track]) {
1230 +                                        // Something is wrong: the BAM free block count for this
1231 +                                        // track was >0, but we found no free blocks
1232 +                                        track = sector = 0;
1233 +                                        set_error(ERR_DIRERROR);
1234 +                                        return false;
1235 +                                }
1236 +                        }
1237 +                }
1238 +        }
1239 +
1240 +        alloc_block(track, sector);
1241          return true;
1242   }
1243  
1244  
1245   /*
1246 < *  Execute 'G' command
1246 > *  Sector reading/writing routines
1247   */
1248  
1249 < void D64Drive::chd64_cmd(char *d64name)
1249 > static long offset_from_ts(const image_file_desc &desc, int track, int sector)
1250   {
1251 <        char str[NAMEBUF_LENGTH];
1252 <        char *p = str;
1251 >        if ((track < 1) || (track > desc.num_tracks)
1252 >         || (sector < 0) || (sector >= num_sectors[track]))
1253 >                return -1;
1254  
1255 <        // Convert .d64 file name
1256 <        for (int i=0; i<NAMEBUF_LENGTH && (*p++ = conv_from_64(*d64name++, false)); i++) ;
1255 >        return ((accum_num_sectors[track] + sector) << 8) + desc.header_size;
1256 > }
1257  
1258 <        close_all_channels();
1258 > // Get number of sectors per given track
1259 > int sectors_per_track(const image_file_desc &desc, int track)
1260 > {
1261 >        return num_sectors[track];
1262 > }
1263 >
1264 > // Get reference to error info byte of given track/sector
1265 > uint8 &error_info_for_sector(image_file_desc &desc, int track, int sector)
1266 > {
1267 >        return desc.error_info[accum_num_sectors[track] + sector];
1268 > }
1269 >
1270 > static inline const uint8 &error_info_for_sector(const image_file_desc &desc, int track, int sector)
1271 > {
1272 >        return desc.error_info[accum_num_sectors[track] + sector];
1273 > }
1274 >
1275 > const int conv_job_error[16] = {
1276 >        ERR_OK,                         // 0 -> 00 OK
1277 >        ERR_OK,                         // 1 -> 00 OK
1278 >        ERR_READ20,                     // 2 -> 20 READ ERROR
1279 >        ERR_READ21,                     // 3 -> 21 READ ERROR
1280 >        ERR_READ22,                     // 4 -> 22 READ ERROR
1281 >        ERR_READ23,                     // 5 -> 23 READ ERROR
1282 >        ERR_READ24,                     // 6 -> 24 READ ERROR (undetected by 1541)
1283 >        ERR_WRITE25,            // 7 -> 25 WRITE ERROR
1284 >        ERR_WRITEPROTECT,       // 8 -> 26 WRITE PROTECT ON
1285 >        ERR_READ27,                     // 9 -> 27 READ ERROR
1286 >        ERR_WRITE28,            // 10 -> 28 WRITE ERROR
1287 >        ERR_DISKID,                     // 11 -> 29 DISK ID MISMATCH
1288 >        ERR_OK,                         // 12 -> 00 OK
1289 >        ERR_OK,                         // 13 -> 00 OK
1290 >        ERR_OK,                         // 14 -> 00 OK
1291 >        ERR_NOTREADY            // 15 -> 74 DRIVE NOT READY
1292 > };
1293 >
1294 > // Read sector, return error code
1295 > int read_sector(FILE *f, const image_file_desc &desc, int track, int sector, uint8 *buffer)
1296 > {
1297 >        // Convert track/sector to byte offset in file
1298 >        long offset = offset_from_ts(desc, track, sector);
1299 >        if (offset < 0)
1300 >                return ERR_ILLEGALTS;
1301 >
1302 >        if (f == NULL)
1303 >                return ERR_NOTREADY;
1304  
1305 <        // G:. resets the .d64 file name to its original setting
1306 <        if (str[0] == '.' && str[1] == 0)
1307 <                open_close_d64_file(orig_d64_name);
1305 >        fseek(f, offset, SEEK_SET);
1306 >        if (fread(buffer, 1, 256, f) != 256)
1307 >                return ERR_READ22;
1308 >        else {
1309 >                unsigned int error = error_info_for_sector(desc, track, sector);
1310 >                return conv_job_error[error & 0x0f];
1311 >        }
1312 > }
1313 >
1314 > // Write sector, return error code
1315 > int write_sector(FILE *f, const image_file_desc &desc, int track, int sector, uint8 *buffer)
1316 > {
1317 >        // Convert track/sector to byte offset in file
1318 >        long offset = offset_from_ts(desc, track, sector);
1319 >        if (offset < 0)
1320 >                return ERR_ILLEGALTS;
1321 >
1322 >        if (f == NULL)
1323 >                return ERR_NOTREADY;
1324 >
1325 >        fseek(f, offset, SEEK_SET);
1326 >        if (fwrite(buffer, 1, 256, f) != 256)
1327 >                return ERR_WRITE25;
1328          else
1329 <                open_close_d64_file(str);
1329 >                return ERR_OK;
1330 > }
1331  
1332 <        // Read BAM
1333 <        read_sector(18, 0, (uint8 *)bam);
1332 > // Read sector and set error message, returns false on error
1333 > bool ImageDrive::read_sector(int track, int sector, uint8 *buffer)
1334 > {
1335 >        int error = ::read_sector(the_file, desc, track, sector, buffer);
1336 >        if (error)
1337 >                set_error(error, track, sector);
1338 >        return error == ERR_OK;
1339   }
1340  
1341 + // Write sector and set error message, returns false on error
1342 + bool ImageDrive::write_sector(int track, int sector, uint8 *buffer)
1343 + {
1344 +        int error = ::write_sector(the_file, desc, track, sector, buffer);
1345 +        if (error)
1346 +                set_error(error, track, sector);
1347 +        return error == ERR_OK;
1348 + }
1349  
1350 < /*
1351 < *  Reset drive
1352 < */
1350 > // Write error info back to image file
1351 > void write_back_error_info(FILE *f, const image_file_desc &desc)
1352 > {
1353 >        if (desc.type == TYPE_D64 && desc.has_error_info) {
1354 >                int num_sectors = desc.num_tracks == 40 ? NUM_SECTORS_40 : NUM_SECTORS_35;
1355 >                fseek(f, num_sectors * 256, SEEK_SET);
1356 >                fwrite(desc.error_info, num_sectors, 1, f);
1357 >        }
1358 > }
1359  
1360 < void D64Drive::Reset(void)
1360 > // Format disk image
1361 > bool format_image(FILE *f, image_file_desc &desc, bool lowlevel, uint8 id1, uint8 id2, const uint8 *disk_name, int disk_name_len)
1362   {
1363 <        close_all_channels();
1363 >        uint8 p[256];
1364  
1365 <        read_sector(18, 0, (uint8 *)bam);
1365 >        if (lowlevel) {
1366  
1367 <        cmd_len = 0;
1368 <        for (int i=0; i<4; i++)
1369 <                buf_free[i] = true;
1367 >                // Fill buffer with 1541 empty sector pattern (4b 01 01 ...,
1368 >                // except on track 1 where it's 01 01 01 ...)
1369 >                memset(p, 1, 256);
1370  
1371 <        set_error(ERR_STARTUP);
1371 >                // Overwrite all blocks
1372 >                for (int track=1; track<=35; track++) {
1373 >                        if (track == 2)
1374 >                                p[0] = 0x4b;
1375 >                        for (int sector=0; sector<num_sectors[track]; sector++) {
1376 >                                if (write_sector(f, desc, track, sector, p) != ERR_OK)
1377 >                                        return false;
1378 >                        }
1379 >                }
1380 >
1381 >                // Clear and write error info
1382 >                memset(desc.error_info, 1, sizeof(desc.error_info));
1383 >                write_back_error_info(f, desc);
1384 >
1385 >                // Clear BAM
1386 >                memset(p, 0, 256);
1387 >
1388 >        } else {
1389 >
1390 >                // Read BAM
1391 >                if (read_sector(f, desc, DIR_TRACK, 0, p) != ERR_OK)
1392 >                        return false;
1393 >        }
1394 >
1395 >        // Create and write empty BAM
1396 >        p[BAM_DIR_TRACK] = DIR_TRACK;
1397 >        p[BAM_DIR_SECTOR] = 1;
1398 >        p[BAM_FMT_TYPE] = 'A';
1399 >        clear_bam(p);
1400 >        p[BAM_BITMAP + (DIR_TRACK - 1) * 4 + 0] -= 2;   // Allocate BAM and first directory block
1401 >        p[BAM_BITMAP + (DIR_TRACK - 1) * 4 + 1] &= 0xfc;
1402 >        memset(p + BAM_DISK_NAME, 0xa0, 27);
1403 >        if (disk_name_len > 16)
1404 >                disk_name_len = 16;
1405 >        memcpy(p + BAM_DISK_NAME, disk_name, disk_name_len);
1406 >        p[BAM_DISK_ID] = id1;
1407 >        p[BAM_DISK_ID + 1] = id2;
1408 >        p[BAM_FMT_CHAR] = '2';
1409 >        p[BAM_FMT_CHAR + 1] = 'A';
1410 >        if (write_sector(f, desc, DIR_TRACK, 0, p) != ERR_OK)
1411 >                return false;
1412 >
1413 >        // Create and write empty directory
1414 >        memset(p, 0, 256);
1415 >        p[1] = 255;
1416 >        return write_sector(f, desc, DIR_TRACK, 1, p) == ERR_OK;
1417   }
1418  
1419  
1420   /*
1421 < *  Allocate floppy buffer
927 < *   -> Desired buffer number or -1
928 < *   <- Allocated buffer number or -1
1421 > *  Execute drive commands
1422   */
1423  
1424 < int D64Drive::alloc_buffer(int want)
1424 > // BLOCK-READ:channel,0,track,sector
1425 > void ImageDrive::block_read_cmd(int channel, int track, int sector, bool user_cmd)
1426   {
1427 <        if (want == -1) {
1428 <                for (want=3; want>=0; want--)
1429 <                        if (buf_free[want]) {
1430 <                                buf_free[want] = false;
1431 <                                return want;
1427 >        if (channel >= 16 || ch[channel].mode != CHMOD_DIRECT) {
1428 >                set_error(ERR_NOCHANNEL);
1429 >                return;
1430 >        }
1431 >        if (!read_sector(track, sector, ch[channel].buf))
1432 >                return;
1433 >        if (user_cmd) {
1434 >                ch[channel].buf_len = 256;
1435 >                ch[channel].buf_ptr = ch[channel].buf;
1436 >        } else {
1437 >                ch[channel].buf_len = ch[channel].buf[0];
1438 >                ch[channel].buf_ptr = ch[channel].buf + 1;
1439 >        }
1440 > }
1441 >
1442 > // BLOCK-WRITE:channel,0,track,sector
1443 > void ImageDrive::block_write_cmd(int channel, int track, int sector, bool user_cmd)
1444 > {
1445 >        if (write_protected) {
1446 >                set_error(ERR_WRITEPROTECT);
1447 >                return;
1448 >        }
1449 >        if (channel >= 16 || ch[channel].mode != CHMOD_DIRECT) {
1450 >                set_error(ERR_NOCHANNEL);
1451 >                return;
1452 >        }
1453 >        if (!user_cmd)
1454 >                ch[channel].buf[0] = ch[channel].buf_len ? ch[channel].buf_len - 1 : 1;
1455 >        if (!write_sector(track, sector, ch[channel].buf))
1456 >                return;
1457 >        if (!user_cmd) {
1458 >                ch[channel].buf_len = 1;
1459 >                ch[channel].buf_ptr = ch[channel].buf + 1;
1460 >        }
1461 > }
1462 >
1463 > // BLOCK-ALLOCATE:0,track,sector
1464 > void ImageDrive::block_allocate_cmd(int track, int sector)
1465 > {
1466 >        int err = alloc_block(track, sector);
1467 >        if (err) {
1468 >                if (err == ERR_NOBLOCK) {
1469 >                        // Find next free block and return its track/sector address in the
1470 >                        // error message (only look on higher tracks)
1471 >                        for (;;) {
1472 >                                sector++;
1473 >                                if (sector >= num_sectors[track]) {
1474 >                                        track++;
1475 >                                        sector = 0;
1476 >                                        if (track > 35) {
1477 >                                                set_error(ERR_NOBLOCK, 0, 0);
1478 >                                                return;
1479 >                                        }
1480 >                                }
1481 >                                if (is_block_free(track, sector)) {
1482 >                                        set_error(ERR_NOBLOCK, track, sector);
1483 >                                        return;
1484 >                                }
1485                          }
1486 <                return -1;
1486 >                } else
1487 >                        set_error(err, track, sector);
1488          }
1489 + }
1490  
1491 <        if (want < 4)
1492 <                if (buf_free[want]) {
1493 <                        buf_free[want] = false;
1494 <                        return want;
1491 > // BLOCK-FREE:0,track,sector
1492 > void ImageDrive::block_free_cmd(int track, int sector)
1493 > {
1494 >        int err = free_block(track, sector);
1495 >        if (err)
1496 >                set_error(err, track, sector);
1497 > }
1498 >
1499 > // BUFFER-POINTER:channel,pos
1500 > void ImageDrive::buffer_pointer_cmd(int channel, int pos)
1501 > {
1502 >        if (channel >= 16 || ch[channel].mode != CHMOD_DIRECT) {
1503 >                set_error(ERR_NOCHANNEL);
1504 >                return;
1505 >        }
1506 >        ch[channel].buf_ptr = ch[channel].buf + pos;
1507 >        ch[channel].buf_len = 256 - pos;
1508 > }
1509 >
1510 > // M-R<adr low><adr high>[<number>]
1511 > void ImageDrive::mem_read_cmd(uint16 adr, uint8 len)
1512 > {
1513 >        error_len = len;
1514 >        if (adr >= 0x300 && adr < 0x1000) {
1515 >                // Read from RAM
1516 >                error_ptr = (char *)ram + (adr & 0x7ff);
1517 >        } else if (adr >= 0xc000) {
1518 >                // Read from ROM
1519 >                error_ptr = (char *)(TheC64->ROM1541) + (adr - 0xc000);
1520 >        } else {
1521 >                unsupp_cmd();
1522 >                memset(error_buf, 0, len);
1523 >                error_ptr = error_buf;
1524 >        }
1525 > }
1526 >
1527 > // M-W<adr low><adr high><number><data...>
1528 > void ImageDrive::mem_write_cmd(uint16 adr, uint8 len, uint8 *p)
1529 > {
1530 >        while (len) {
1531 >                if (adr >= 0x300 && adr < 0x1000) {
1532 >                        // Write to RAM
1533 >                        ram[adr & 0x7ff] = *p;
1534 >                } else if (adr < 0xc000) {
1535 >                        unsupp_cmd();
1536 >                        return;
1537 >                }
1538 >                len--; adr++; p++;
1539 >        }
1540 > }
1541 >
1542 > //   COPY:new=file1,file2,...
1543 > //        ^   ^
1544 > // new_file   old_files
1545 > void ImageDrive::copy_cmd(const uint8 *new_file, int new_file_len, const uint8 *old_files, int old_files_len)
1546 > {
1547 >        // Check if destination file is already present
1548 >        int dir_track, dir_sector, entry;
1549 >        if (find_first_file(new_file, new_file_len, dir_track, dir_sector, entry)) {
1550 >                set_error(ERR_FILEEXISTS);
1551 >                return;
1552 >        }
1553 >
1554 >        // Loop for all source files
1555 >        bool first = true;
1556 >        while (old_files_len > 0) {
1557 >                uint8 *comma = (uint8 *)memchr(old_files, ',', old_files_len);
1558 >                int name_len = comma ? comma - old_files : old_files_len;
1559 >
1560 >                // Check if source file is present
1561 >                if (!find_first_file(old_files, name_len, dir_track, dir_sector, entry)) {
1562 >                        set_error(ERR_FILENOTFOUND);
1563 >                        Close(17);
1564 >                        return;
1565 >                }
1566 >                uint8 *de = dir + DIR_ENTRIES + entry * SIZEOF_DE;
1567 >                uint8 type = de[DE_TYPE] & 7, track = de[DE_TRACK], sector = de[DE_SECTOR];
1568 >
1569 >                // If this is the first source file, open internal write channel for destination file
1570 >                if (first) {
1571 >                        create_file(17, new_file, new_file_len, type, false);
1572 >                        if (ch[17].mode == CHMOD_FREE)
1573 >                                return;
1574 >                        first = false;
1575 >                }
1576 >
1577 >                // Open internal read channel for source file
1578 >                open_file_ts(16, track, sector);
1579 >                if (ch[16].mode == CHMOD_FREE) {
1580 >                        Close(17);
1581 >                        return;
1582 >                }
1583 >
1584 >                // Copy file
1585 >                uint8 byte, st;
1586 >                do {
1587 >                        st = Read(16, byte);
1588 >                        Write(17, byte, false);
1589 >                } while (st == ST_OK);
1590 >                Close(16);
1591 >                if (st != ST_EOF) {
1592 >                        Close(17);
1593 >                        return;
1594 >                }
1595 >
1596 >                if (comma) {
1597 >                        old_files_len -= name_len + 1;
1598 >                        old_files = comma + 1;
1599                  } else
1600 <                        return -1;
1601 <        else
1602 <                return -1;
1600 >                        old_files_len = 0;
1601 >        }
1602 >        Close(17);
1603 > }
1604 >
1605 > // RENAME:new=old
1606 > //        ^   ^
1607 > // new_file   old_file
1608 > void ImageDrive::rename_cmd(const uint8 *new_file, int new_file_len, const uint8 *old_file, int old_file_len)
1609 > {
1610 >        // Check if destination file is already present
1611 >        int dir_track, dir_sector, entry;
1612 >        if (find_first_file(new_file, new_file_len, dir_track, dir_sector, entry)) {
1613 >                set_error(ERR_FILEEXISTS);
1614 >                return;
1615 >        }
1616 >
1617 >        // Check if source file is present
1618 >        if (!find_first_file(old_file, old_file_len, dir_track, dir_sector, entry)) {
1619 >                set_error(ERR_FILENOTFOUND);
1620 >                return;
1621 >        }
1622 >
1623 >        // Check for write-protection
1624 >        if (write_protected) {
1625 >                set_error(ERR_WRITEPROTECT);
1626 >                return;
1627 >        }
1628 >
1629 >        // Rename file in directory entry
1630 >        uint8 *p = dir + DIR_ENTRIES + entry * SIZEOF_DE;
1631 >        memset(p + DE_NAME, 0xa0, 16);
1632 >        memcpy(p + DE_NAME, new_file, new_file_len);
1633 >        write_sector(dir_track, dir_sector, dir);
1634 > }
1635 >
1636 > // SCRATCH:file1,file2,...
1637 > //         ^
1638 > //         files
1639 > void ImageDrive::scratch_cmd(const uint8 *files, int files_len)
1640 > {
1641 >        // Check for write-protection
1642 >        if (write_protected) {
1643 >                set_error(ERR_WRITEPROTECT);
1644 >                return;
1645 >        }
1646 >
1647 >        // Loop for all files
1648 >        int num_files = 0;
1649 >        while (files_len > 0) {
1650 >                uint8 *comma = (uint8 *)memchr(files, ',', files_len);
1651 >                int name_len = comma ? comma - files : files_len;
1652 >
1653 >                int dir_track, dir_sector, entry;
1654 >                if (find_first_file(files, name_len, dir_track, dir_sector, entry)) {
1655 >                        do {
1656 >                                uint8 *de = dir + DIR_ENTRIES + entry * SIZEOF_DE;
1657 >
1658 >                                // File protected? Then skip
1659 >                                if (de[DE_TYPE] & 0x40)
1660 >                                        continue;
1661 >
1662 >                                // Free allocated data blocks and side sectors
1663 >                                free_block_chain(de[DE_TRACK], de[DE_SECTOR]);
1664 >                                free_block_chain(de[DE_SIDE_TRACK], de[DE_SIDE_SECTOR]);
1665 >
1666 >                                // Clear file type
1667 >                                de[DE_TYPE] = 0;
1668 >
1669 >                                // Write directory block back
1670 >                                write_sector(dir_track, dir_sector, dir);
1671 >                                num_files++;
1672 >                        } while (find_next_file(files, name_len, dir_track, dir_sector, entry));
1673 >                }
1674 >
1675 >                if (comma) {
1676 >                        files_len -= name_len + 1;
1677 >                        files = comma + 1;
1678 >                } else
1679 >                        files_len = 0;
1680 >        }
1681 >
1682 >        // Report number of files scratched
1683 >        set_error(ERR_SCRATCHED, num_files);
1684 > }
1685 >
1686 > // INITIALIZE
1687 > void ImageDrive::initialize_cmd(void)
1688 > {
1689 >        // Close all channels and re-read BAM
1690 >        close_all_channels();
1691 >        if (bam_dirty) {
1692 >                write_sector(DIR_TRACK, 0, bam);
1693 >                bam_dirty = false;
1694 >        }
1695 >        read_sector(DIR_TRACK, 0, bam);
1696 > }
1697 >
1698 > // NEW:name,id
1699 > //     ^   ^
1700 > //  name   comma (or NULL)
1701 > void ImageDrive::new_cmd(const uint8 *name, int name_len, const uint8 *comma)
1702 > {
1703 >        // Check for write-protection
1704 >        if (write_protected) {
1705 >                set_error(ERR_WRITEPROTECT);
1706 >                return;
1707 >        }
1708 >
1709 >        // Remember current ID
1710 >        uint8 id1 = bam[BAM_DISK_ID], id2 = bam[BAM_DISK_ID + 1];
1711 >
1712 >        // Formatting with ID?
1713 >        if (comma) {
1714 >
1715 >                close_all_channels();
1716 >
1717 >                // Clear BAM buffer
1718 >                memset(bam, 0, 256);
1719 >
1720 >                // Get ID from command
1721 >                if (comma[1]) {
1722 >                        id1 = comma[1];
1723 >                        id2 = comma[2] ? comma[2] : ' ';
1724 >                } else {
1725 >                        id1 = id2 = ' ';
1726 >                }
1727 >        }
1728 >
1729 >        // Format disk image
1730 >        format_image(the_file, desc, comma, id1, id2, name, name_len);
1731 >
1732 >        // Re-read BAM
1733 >        read_sector(DIR_TRACK, 0, bam);
1734 >        bam_dirty = false;
1735 > }
1736 >
1737 > // VALIDATE
1738 > void ImageDrive::validate_cmd(void)
1739 > {
1740 >        // Backup of old BAM in case something goes amiss
1741 >        uint8 old_bam[256];
1742 >        memcpy(old_bam, bam, 256);
1743 >
1744 >        // Clear BAM
1745 >        clear_bam(bam);
1746 >        bam_dirty = true;
1747 >
1748 >        // Allocate BAM and directory
1749 >        if (!alloc_block_chain(DIR_TRACK, 0)) {
1750 >                memcpy(bam, old_bam, 256);
1751 >                return;
1752 >        }
1753 >
1754 >        // Allocate all file data and side sector blocks
1755 >        int dir_track, dir_sector, entry;
1756 >        if (find_first_file((uint8 *)"*", 1, dir_track, dir_sector, entry)) {
1757 >                do {
1758 >                        uint8 *de = dir + DIR_ENTRIES + entry * SIZEOF_DE;
1759 >
1760 >                        if (de[DE_TYPE] & 0x80) {
1761 >                                // Closed file, allocate all file data and side sector blocks
1762 >                                if (!alloc_block_chain(de[DE_TRACK], de[DE_SECTOR]) || !alloc_block_chain(de[DE_SIDE_TRACK], de[DE_SIDE_SECTOR])) {
1763 >                                        memcpy(bam, old_bam, 256);
1764 >                                        return;
1765 >                                }
1766 >                        } else {
1767 >                                // Open file, delete it
1768 >                                de[DE_TYPE] = 0;
1769 >                                write_sector(dir_track, dir_sector, dir);
1770 >                        }
1771 >                } while (find_next_file((uint8 *)"*", 1, dir_track, dir_sector, entry));
1772 >        }
1773   }
1774  
1775  
1776   /*
1777 < *  Free floppy buffer
1777 > *  Check whether file with given header (64 bytes) and size looks like one
1778 > *  of the file types supported by this module
1779   */
1780  
1781 < void D64Drive::free_buffer(int buf)
1781 > static bool is_d64_file(const uint8 *header, long size)
1782   {
1783 <        buf_free[buf] = true;
1783 >        return size == NUM_SECTORS_35 * 256 || size == NUM_SECTORS_35 * 257
1784 >            || size == NUM_SECTORS_40 * 256 || size == NUM_SECTORS_40 * 257;
1785   }
1786  
1787 + static bool is_ed64_file(const uint8 *header, long size)
1788 + {
1789 +        // 35-track d64 file with header ID at the end (only used internally for
1790 +        // converted zipcode files)
1791 +        return size == NUM_SECTORS_35 * 256 + 2;
1792 + }
1793 +
1794 + static bool is_x64_file(const uint8 *header, long size)
1795 + {
1796 +        return memcmp(header, "C\x15\x41\x64\x01\x02", 6) == 0;
1797 + }
1798  
1799 + static bool is_zipcode_file(const char *path)
1800 + {
1801 + #if 0
1802 +        string base, part;
1803 +        SplitPath(path, base, part);
1804 +        return part.length() > 2 && part[0] >= '1' && part[0] <= '4' && part[1] == '!';
1805 + #else
1806 +        return false;
1807 + #endif
1808 + }
1809 +
1810 + bool IsImageFile(const char *path, const uint8 *header, long size)
1811 + {
1812 +        return is_d64_file(header, size) || is_x64_file(header, size) || is_zipcode_file(path);
1813 + }
1814 +
1815 +
1816 + #if 0
1817   /*
1818 < *  Read sector (256 bytes)
965 < *  true: success, false: error
1818 > *  Convert zipcode file to extended d64 file (d64 file with header ID)
1819   */
1820  
1821 < bool D64Drive::read_sector(int track, int sector, uint8 *buffer)
1821 > static FILE *open_zipcode_file(FILE *old, int num, const string &base, string &part, uint8 &id1, uint8 &id2)
1822   {
1823 <        int offset;
1824 <
1825 <        // Convert track/sector to byte offset in file
1826 <        if ((offset = offset_from_ts(track, sector)) < 0) {
1827 <                set_error(ERR_ILLEGALTS);
1828 <                return false;
1823 >        if (old)
1824 >                fclose(old);
1825 >        part[0] = num + '1';
1826 >        FILE *f = fopen(AddToPath(base, part).c_str(), "rb");
1827 >        if (f == NULL)
1828 >                return NULL;
1829 >        if (fseek(f, 2, SEEK_SET) < 0) {
1830 >                fclose(f);
1831 >                return NULL;
1832          }
1833 <
1834 <        if (the_file == NULL) {
1835 <                set_error(ERR_NOTREADY);
980 <                return false;
1833 >        if (num == 0) {
1834 >                id1 = getc(f);
1835 >                id2 = getc(f);
1836          }
1837 +        return f;
1838 + }
1839  
1840 < #ifdef AMIGA
1841 <        if (offset != ftell(the_file))
1842 <                fseek(the_file, offset + image_header, SEEK_SET);
1843 < #else
1844 <        fseek(the_file, offset + image_header, SEEK_SET);
1840 > static FILE *convert_zipcode_to_ed64(const string &path)
1841 > {
1842 >        FILE *in = NULL, *out = NULL;
1843 >        uint8 id1, id2;
1844 >
1845 >        // Split input file name
1846 >        string base, part;
1847 >        SplitPath(path, base, part);
1848 >
1849 >        // Open output file
1850 >        out = tmpfile();
1851 >        if (out == NULL)
1852 >                goto error;
1853 >
1854 >        // Decode all tracks
1855 >        for (int track=1; track<=35; track++) {
1856 >                int max_sect = 17 + ((track < 31) ? 1 : 0) + ((track < 25) ? 1 : 0) + ((track < 18) ? 2 : 0);
1857 >
1858 >                // Select appropriate input file
1859 >                switch (track) {
1860 >                        case 1:
1861 >                                if ((in = open_zipcode_file(NULL, 0, base, part, id1, id2)) == NULL)
1862 >                                        goto error;
1863 >                                break;
1864 >                        case 9:
1865 >                                if ((in = open_zipcode_file(in, 1, base, part, id1, id2)) == NULL)
1866 >                                        goto error;
1867 >                                break;
1868 >                        case 17:
1869 >                                if ((in = open_zipcode_file(in, 2, base, part, id1, id2)) == NULL)
1870 >                                        goto error;
1871 >                                break;
1872 >                        case 26:
1873 >                                if ((in = open_zipcode_file(in, 3, base, part, id1, id2)) == NULL)
1874 >                                        goto error;
1875 >                                break;
1876 >                }
1877 >
1878 >                // Clear "sector read" flags
1879 >                bool sect_flag[21];
1880 >                for (int i=0; i<max_sect; i++)
1881 >                        sect_flag[i] = false;
1882 >
1883 >                // Read track
1884 >                uint8 act_track[21 * 256];
1885 >                for (int i=0; i<max_sect; i++) {
1886 >
1887 >                        // Read and verify track/sector number
1888 >                        uint8 t = getc(in);
1889 >                        uint8 s = getc(in);
1890 >                        if ((t & 0x3f) != track || s >= max_sect || sect_flag[s] || feof(in))
1891 >                                goto error;
1892 >                        sect_flag[s] = true;
1893 >                        uint8 *p = act_track + s * 256;
1894 >
1895 >                        // Uncompress sector
1896 >                        if (t & 0x80) {
1897 >                                // Run-length encoded sector
1898 >                                uint8 len = getc(in);
1899 >                                uint8 rep = getc(in);
1900 >                                int count = 0;
1901 >                                for (int j=0; j<len; j++) {
1902 >                                        if (feof(in))
1903 >                                                goto error;
1904 >                                        uint8 c = getc(in);
1905 >                                        if (c != rep)
1906 >                                                p[count++] = c;
1907 >                                        else {
1908 >                                                uint8 repnum = getc(in);
1909 >                                                if (feof(in))
1910 >                                                        goto error;
1911 >                                                c = getc(in);
1912 >                                                j += 2;
1913 >                                                for (int k=0; k<repnum; k++)
1914 >                                                        p[count++] = c;
1915 >                                        }
1916 >                                }
1917 >                        } else if (t & 0x40) {
1918 >                                // Sector filled with constant byte
1919 >                                if (feof(in))
1920 >                                        goto error;
1921 >                                uint8 c = getc(in);
1922 >                                memset(p, c, 256);
1923 >                        } else {
1924 >                                // Plain sector
1925 >                                if (fread(p, 1, 256, in) != 256)
1926 >                                        goto error;
1927 >                        }
1928 >                }
1929 >
1930 >                // Write track
1931 >                if (fwrite(act_track, 256, max_sect, out) != (size_t)max_sect)
1932 >                        goto error;
1933 >        }
1934 >
1935 >        // Write header ID
1936 >        putc(id1, out);
1937 >        putc(id2, out);
1938 >
1939 >        // Done
1940 >        fclose(in);
1941 >        fseek(out, 0, SEEK_SET);
1942 >        return out;
1943 >
1944 > error:
1945 >        if (in)
1946 >                fclose(in);
1947 >        if (out)
1948 >                fclose(out);
1949 >        return NULL;
1950 > }
1951   #endif
1952 <        fread(buffer, 256, 1, the_file);
1953 <        return true;
1952 >
1953 >
1954 > /*
1955 > *  Open disk image file, return file handle
1956 > */
1957 >
1958 > FILE *open_image_file(const char *path, bool write_mode)
1959 > {
1960 > #if 0
1961 >        if (is_zipcode_file(path)) {
1962 >                if (write_mode)
1963 >                        return NULL;
1964 >                else
1965 >                        return convert_zipcode_to_ed64(path);
1966 >        } else
1967 > #endif
1968 >                return fopen(path, write_mode ? "r+b" : "rb");
1969   }
1970  
1971  
1972   /*
1973 < *  Convert track/sector to offset
1973 > *  Parse image file and fill in image_file_desc structure
1974   */
1975  
1976 < const int num_sectors[41] = {
1977 <        0,
1978 <        21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,
1979 <        19,19,19,19,19,19,19,
1980 <        18,18,18,18,18,18,
1003 <        17,17,17,17,17,
1004 <        17,17,17,17,17          // Tracks 36..40
1005 < };
1976 > static bool parse_d64_file(FILE *f, image_file_desc &desc, bool has_header_id)
1977 > {
1978 >        // .d64 files have no header
1979 >        desc.type = has_header_id ? TYPE_ED64 : TYPE_D64;
1980 >        desc.header_size = 0;
1981  
1982 < const int sector_offset[41] = {
1983 <        0,
1984 <        0,21,42,63,84,105,126,147,168,189,210,231,252,273,294,315,336,
1985 <        357,376,395,414,433,452,471,
1986 <        490,508,526,544,562,580,
1987 <        598,615,632,649,666,
1988 <        683,700,717,734,751     // Tracks 36..40
1989 < };
1982 >        // Determine number of tracks
1983 >        fseek(f, 0, SEEK_END);
1984 >        long size = ftell(f);
1985 >        if (size == NUM_SECTORS_40 * 256 || size == NUM_SECTORS_40 * 257)
1986 >                desc.num_tracks = 40;
1987 >        else
1988 >                desc.num_tracks = 35;
1989 >
1990 >        if (has_header_id) {
1991 >                // Read header ID from image file (last 2 bytes)
1992 >                fseek(f, -2, SEEK_END);
1993 >                desc.id1 = getc(f);
1994 >                desc.id2 = getc(f);
1995 >        } else {
1996 >                // Read header ID from BAM (use error_info as buffer)
1997 >                fseek(f, accum_num_sectors[18] * 256, SEEK_SET);
1998 >                fread(desc.error_info, 1, 256, f);
1999 >                desc.id1 = desc.error_info[BAM_DISK_ID];
2000 >                desc.id2 = desc.error_info[BAM_DISK_ID + 1];
2001 >        }
2002 >
2003 >        // Read error info
2004 >        memset(desc.error_info, 1, sizeof(desc.error_info));
2005 >        if (size == NUM_SECTORS_35 * 257) {
2006 >                fseek(f, NUM_SECTORS_35 * 256, SEEK_SET);
2007 >                fread(desc.error_info, NUM_SECTORS_35, 1, f);
2008 >                desc.has_error_info = true;
2009 >        } else if (size == NUM_SECTORS_40 * 257) {
2010 >                fseek(f, NUM_SECTORS_40 * 256, SEEK_SET);
2011 >                fread(desc.error_info, NUM_SECTORS_40, 1, f);
2012 >                desc.has_error_info = true;
2013 >        } else
2014 >                desc.has_error_info = false;
2015  
2016 < int D64Drive::offset_from_ts(int track, int sector)
2016 >        return true;
2017 > }
2018 >
2019 > static bool parse_x64_file(FILE *f, image_file_desc &desc)
2020   {
2021 <        if ((track < 1) || (track > NUM_TRACKS) ||
2022 <                (sector < 0) || (sector >= num_sectors[track]))
2023 <                return -1;
2021 >        desc.type = TYPE_X64;
2022 >        desc.header_size = 64;
2023 >
2024 >        // Read number of tracks
2025 >        fseek(f, 7, SEEK_SET);
2026 >        desc.num_tracks = getc(f);
2027 >        if (desc.num_tracks < 35 || desc.num_tracks > 40)
2028 >                return false;
2029  
2030 <        return (sector_offset[track] + sector) << 8;
2030 >        // Read header ID from BAM (use error_info as buffer)
2031 >        fseek(f, desc.header_size + accum_num_sectors[18] * 256, SEEK_SET);
2032 >        fread(desc.error_info, 1, 256, f);
2033 >        desc.id1 = desc.error_info[BAM_DISK_ID];
2034 >        desc.id2 = desc.error_info[BAM_DISK_ID + 1];
2035 >
2036 >        // .x64 files have no error info
2037 >        memset(desc.error_info, 1, sizeof(desc.error_info));
2038 >        desc.has_error_info = false;
2039 >        return true;
2040 > }
2041 >
2042 > bool parse_image_file(FILE *f, image_file_desc &desc)
2043 > {
2044 >        // Read header
2045 >        uint8 header[64];
2046 >        fread(header, 1, sizeof(header), f);
2047 >
2048 >        // Determine file size
2049 >        fseek(f, 0, SEEK_END);
2050 >        long size = ftell(f);
2051 >
2052 >        // Determine file type and fill in image_file_desc structure
2053 >        if (is_x64_file(header, size))
2054 >                return parse_x64_file(f, desc);
2055 >        else if (is_d64_file(header, size))
2056 >                return parse_d64_file(f, desc, false);
2057 >        else if (is_ed64_file(header, size))
2058 >                return parse_d64_file(f, desc, true);
2059 >        else
2060 >                return false;
2061   }
2062  
2063  
2064   /*
2065 < *  Conversion PETSCII->ASCII
2065 > *  Create new blank disk image file, returns false on error
2066   */
2067  
2068 < uint8 D64Drive::conv_from_64(uint8 c, bool map_slash)
2068 > bool CreateImageFile(const char *path)
2069   {
2070 <        if ((c >= 'A') && (c <= 'Z') || (c >= 'a') && (c <= 'z'))
2071 <                return c ^ 0x20;
2072 <        if ((c >= 0xc1) && (c <= 0xda))
2073 <                return c ^ 0x80;
2074 <        if ((c == '/') && map_slash && ThePrefs.MapSlash)
2075 <                return '\\';
2076 <        return c;
2070 >        // Open file for writing
2071 >        FILE *f = fopen(path, "wb");
2072 >        if (f == NULL)
2073 >                return false;
2074 >
2075 >        // Create descriptor
2076 >        image_file_desc desc;
2077 >        desc.type = TYPE_D64;
2078 >        desc.header_size = 0;
2079 >        desc.num_tracks = 35;
2080 >        desc.id1 = 'F';
2081 >        desc.id1 = 'R';
2082 >        memset(desc.error_info, 1, sizeof(desc.error_info));
2083 >        desc.has_error_info = false;
2084 >
2085 >        // Format image file
2086 >        if (!format_image(f, desc, true, 'F', 'R', (uint8 *)"D64 FILE", 8)) {
2087 >                fclose(f);
2088 >                remove(path);
2089 >                return false;
2090 >        }
2091 >
2092 >        // Close file
2093 >        fclose(f);
2094 >        return true;
2095   }

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines