Frodo4/Src/1541d64.cpp

/*
 *  1541d64.cpp - 1541 emulation in .d64 file
 *
 *  Frodo (C) 1994-1997,2002-2003 Christian Bauer
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

/*
 * Incompatibilities:
 * ------------------
 *
 *  - Only read accesses possible
 *  - Not all commands implemented
 *  - The .d64 error info is read, but unused
 */

#include "sysdeps.h"

#include "1541d64.h"
#include "IEC.h"
#include "Prefs.h"
#include "C64.h"


// Channel modes (IRC users listen up :-)
enum {
        CHMOD_FREE,                     // Channel free
        CHMOD_COMMAND,          // Command/error channel
        CHMOD_DIRECTORY,        // Reading directory
        CHMOD_FILE,                     // Sequential file open
        CHMOD_DIRECT            // Direct buffer access ('#')
};

// Access modes
enum {
        FMODE_READ, FMODE_WRITE, FMODE_APPEND
};

// File types
enum {
        FTYPE_PRG, FTYPE_SEQ, FTYPE_USR, FTYPE_REL
};

// Number of tracks/sectors
const int NUM_TRACKS = 35;
const int NUM_SECTORS = 683;

// Prototypes
static bool match(uint8 *p, uint8 *n);


/*
 *  Constructor: Prepare emulation, open .d64 file
 */

D64Drive::D64Drive(IEC *iec, char *filepath) : Drive(iec)
{
        the_file = NULL;
        ram = NULL;

        Ready = false;
        strcpy(orig_d64_name, filepath);
        for (int i=0; i<=14; i++) {
                chan_mode[i] = CHMOD_FREE;
                chan_buf[i] = NULL;
        }
        chan_mode[15] = CHMOD_COMMAND;

        // Open .d64 file
        open_close_d64_file(filepath);
        if (the_file != NULL) {

                // Allocate 1541 RAM
                ram = new uint8[DRIVE_RAM_SIZE];
                bam = (BAM *)(ram + 0x700);

                Reset();
                Ready = true;
        }
}


/*
 *  Destructor
 */

D64Drive::~D64Drive()
{
        // Close .d64 file
        open_close_d64_file("");

        delete[] ram;
        Ready = false;
}


/*
 *  Open/close the .d64 file
 */

void D64Drive::open_close_d64_file(char *d64name)
{
        long size;
        uint8 magic[4];

        // Close old .d64, if open
        if (the_file != NULL) {
                close_all_channels();
                fclose(the_file);
                the_file = NULL;
        }

        // Open new .d64 file
        if (d64name[0]) {
                if ((the_file = fopen(d64name, "rb")) != NULL) {

                        // Check length
                        fseek(the_file, 0, SEEK_END);
                        if ((size = ftell(the_file)) < NUM_SECTORS * 256) {
                                fclose(the_file);
                                the_file = NULL;
                                return;
                        }

                        // x64 image?
                        rewind(the_file);
                        fread(&magic, 4, 1, the_file);
                        if (magic[0] == 0x43 && magic[1] == 0x15 && magic[2] == 0x41 && magic[3] == 0x64)
                                image_header = 64;
                        else
                                image_header = 0;

                        // Preset error info (all sectors no error)
                        memset(error_info, 1, NUM_SECTORS);

                        // Load sector error info from .d64 file, if present
                        if (!image_header && size == NUM_SECTORS * 257) {
                                fseek(the_file, NUM_SECTORS * 256, SEEK_SET);
                                fread(&error_info, NUM_SECTORS, 1, the_file);
                        }
                }
        }
}


/*
 *  Open channel
 */

uint8 D64Drive::Open(int channel, char *filename)
{
        set_error(ERR_OK);

        // Channel 15: execute file name as command
        if (channel == 15) {
                execute_command(filename);
                return ST_OK;
        }

        if (chan_mode[channel] != CHMOD_FREE) {
                set_error(ERR_NOCHANNEL);
                return ST_OK;
        }

        if (filename[0] == '$')
                if (channel)
                        return open_file_ts(channel, 18, 0);
                else
                        return open_directory(filename+1);

        if (filename[0] == '#')
                return open_direct(channel, filename);

        return open_file(channel, filename);
}


/*
 *  Open file
 */

uint8 D64Drive::open_file(int channel, char *filename)
{
        char plainname[256];
        int filemode = FMODE_READ;
        int filetype = FTYPE_PRG;
        int track, sector;

        convert_filename(filename, plainname, &filemode, &filetype);

        // Channel 0 is READ PRG, channel 1 is WRITE PRG
        if (!channel) {
                filemode = FMODE_READ;
                filetype = FTYPE_PRG;
        }
        if (channel == 1) {
                filemode = FMODE_WRITE;
                filetype = FTYPE_PRG;
        }

        // Allow only read accesses
        if (filemode != FMODE_READ) {
                set_error(ERR_WRITEPROTECT);
                return ST_OK;
        }

        // Find file in directory and open it
        if (find_file(plainname, &track, &sector))
                return open_file_ts(channel, track, sector);
        else
                set_error(ERR_FILENOTFOUND);

        return ST_OK;
}


/*
 *  Analyze file name, get access mode and type
 */

void D64Drive::convert_filename(char *srcname, char *destname, int *filemode, int *filetype)
{
        char *p;

        // Search for ':', p points to first character after ':'
        if ((p = strchr(srcname, ':')) != NULL)
                p++;
        else
                p = srcname;

        // Remaining string -> destname
        strncpy(destname, p, NAMEBUF_LENGTH);

        // Search for ','
        p = destname;
        while (*p && (*p != ',')) p++;

        // Look for mode parameters seperated by ','
        p = destname;
        while ((p = strchr(p, ',')) != NULL) {

                // Cut string after the first ','
                *p++ = 0;

                switch (*p) {
                        case 'P':
                                *filetype = FTYPE_PRG;
                                break;
                        case 'S':
                                *filetype = FTYPE_SEQ;
                                break;
                        case 'U':
                                *filetype = FTYPE_USR;
                                break;
                        case 'L':
                                *filetype = FTYPE_REL;
                                break;
                        case 'R':
                                *filemode = FMODE_READ;
                                break;
                        case 'W':
                                *filemode = FMODE_WRITE;
                                break;
                        case 'A':
                                *filemode = FMODE_APPEND;
                                break;
                }
        }
}


/*
 *  Search file in directory, find first track and sector
 *  false: not found, true: found
 */

bool D64Drive::find_file(char *filename, int *track, int *sector)
{
        int i, j;
        uint8 *p, *q;
        DirEntry *de;

        // Scan all directory blocks
        dir.next_track = bam->dir_track;
        dir.next_sector = bam->dir_sector;

        while (dir.next_track) {
                if (!read_sector(dir.next_track, dir.next_sector, (uint8 *) &dir.next_track))
                        return false;

                // Scan all 8 entries of a block
                for (j=0; j<8; j++) {
                        de = &dir.entry[j];
                        *track = de->track;
                        *sector = de->sector;

                        if (de->type) {
                                p = (uint8 *)filename;
                                q = de->name;
                                for (i=0; i<16 && *p; i++, p++, q++) {
                                        if (*p == '*')  // Wildcard '*' matches all following characters
                                                return true;
                                        if (*p != *q) {
                                                if (*p != '?') goto next_entry; // Wildcard '?' matches single character
                                                if (*q == 0xa0) goto next_entry;
                                        }
                                }

                                if (i == 16 || *q == 0xa0)
                                        return true;
                        }
next_entry: ;
                }
        }

        return false;
}


/*
 *  Open file given track/sector of first block
 */

uint8 D64Drive::open_file_ts(int channel, int track, int sector)
{
        chan_buf[channel] = new uint8[256];
        chan_mode[channel] = CHMOD_FILE;

        // On the next call to Read, the first block will be read
        chan_buf[channel][0] = track;
        chan_buf[channel][1] = sector;
        buf_len[channel] = 0;

        return ST_OK;
}


/*
 *  Prepare directory as BASIC program (channel 0)
 */

const char type_char_1[] = "DSPUREERSELQGRL?";
const char type_char_2[] = "EERSELQGRL??????";
const char type_char_3[] = "LQGRL???????????";

// Return true if name 'n' matches pattern 'p'
static bool match(uint8 *p, uint8 *n)
{
        if (!*p)                // Null pattern matches everything
                return true;

        do {
                if (*p == '*')  // Wildcard '*' matches all following characters
                        return true;
                if ((*p != *n) && (*p != '?'))  // Wildcard '?' matches single character
                        return false;
                p++; n++;
        } while (*p);

        return *n == 0xa0;
}

uint8 D64Drive::open_directory(char *pattern)
{
        int i, j, n, m;
        uint8 *p, *q;
        DirEntry *de;
        uint8 c;
        char *tmppat;

        // Special treatment for "$0"
        if (pattern[0] == '0' && pattern[1] == 0)
                pattern += 1;

        // Skip everything before the ':' in the pattern
        if ((tmppat = strchr(pattern, ':')) != NULL)
                pattern = tmppat + 1;

        p = buf_ptr[0] = chan_buf[0] = new uint8[8192];
        chan_mode[0] = CHMOD_DIRECTORY;

        // Create directory title
        *p++ = 0x01;    // Load address $0401 (from PET days :-)
        *p++ = 0x04;
        *p++ = 0x01;    // Dummy line link
        *p++ = 0x01;
        *p++ = 0;               // Drive number (0) as line number
        *p++ = 0;
        *p++ = 0x12;    // RVS ON
        *p++ = '\"';

        q = bam->disk_name;
        for (i=0; i<23; i++) {
                if ((c = *q++) == 0xa0)
                        *p++ = ' ';             // Replace 0xa0 by space
                else
                        *p++ = c;
        }
        *(p-7) = '\"';
        *p++ = 0;

        // Scan all directory blocks
        dir.next_track = bam->dir_track;
        dir.next_sector = bam->dir_sector;

        while (dir.next_track) {
                if (!read_sector(dir.next_track, dir.next_sector, (uint8 *) &dir.next_track))
                        return ST_OK;

                // Scan all 8 entries of a block
                for (j=0; j<8; j++) {
                        de = &dir.entry[j];

                        if (de->type && match((uint8 *)pattern, de->name)) {
                                *p++ = 0x01; // Dummy line link
                                *p++ = 0x01;

                                *p++ = de->num_blocks_l; // Line number
                                *p++ = de->num_blocks_h;

                                *p++ = ' ';
                                n = (de->num_blocks_h << 8) + de->num_blocks_l;
                                if (n<10) *p++ = ' ';
                                if (n<100) *p++ = ' ';

                                *p++ = '\"';
                                q = de->name;
                                m = 0;
                                for (i=0; i<16; i++) {
                                        if ((c = *q++) == 0xa0) {
                                                if (m)
                                                        *p++ = ' ';             // Replace all 0xa0 by spaces
                                                else
                                                        m = *p++ = '\"';        // But the first by a '"'
                                        } else
                                                *p++ = c;
                                }
                                if (m)
                                        *p++ = ' ';
                                else
                                        *p++ = '\"';                    // No 0xa0, then append a space

                                if (de->type & 0x80)
                                        *p++ = ' ';
                                else
                                        *p++ = '*';

                                *p++ = type_char_1[de->type & 0x0f];
                                *p++ = type_char_2[de->type & 0x0f];
                                *p++ = type_char_3[de->type & 0x0f];

                                if (de->type & 0x40)
                                        *p++ = '<';
                                else
                                        *p++ = ' ';

                                *p++ = ' ';
                                if (n >= 10) *p++ = ' ';
                                if (n >= 100) *p++ = ' ';
                                *p++ = 0;
                        }
                }
        }

        // Final line
        q = p;
        for (i=0; i<29; i++)
                *q++ = ' ';

        n = 0;
        for (i=0; i<35; i++)
                n += bam->bitmap[i*4];

        *p++ = 0x01;            // Dummy line link
        *p++ = 0x01;
        *p++ = n & 0xff;        // Number of free blocks as line number
        *p++ = (n >> 8) & 0xff;

        *p++ = 'B';
        *p++ = 'L';
        *p++ = 'O';
        *p++ = 'C';
        *p++ = 'K';
        *p++ = 'S';
        *p++ = ' ';
        *p++ = 'F';
        *p++ = 'R';
        *p++ = 'E';
        *p++ = 'E';
        *p++ = '.';

        p = q;
        *p++ = 0;
        *p++ = 0;
        *p++ = 0;

        buf_len[0] = p - chan_buf[0];

        return ST_OK;
}


/*
 *  Open channel for direct buffer access
 */

uint8 D64Drive::open_direct(int channel, char *filename)
{
        int buf = -1;

        if (filename[1] == 0)
                buf = alloc_buffer(-1);
        else
                if ((filename[1] >= '0') && (filename[1] <= '3') && (filename[2] == 0))
                        buf = alloc_buffer(filename[1] - '0');

        if (buf == -1) {
                set_error(ERR_NOCHANNEL);
                return ST_OK;
        }

        // The buffers are in the 1541 RAM at $300 and are 256 bytes each
        chan_buf[channel] = buf_ptr[channel] = ram + 0x300 + (buf << 8);
        chan_mode[channel] = CHMOD_DIRECT;
        chan_buf_num[channel] = buf;

        // Store actual buffer number in buffer
        *chan_buf[channel] = buf + '0';
        buf_len[channel] = 1;

        return ST_OK;
}


/*
 *  Close channel
 */

uint8 D64Drive::Close(int channel)
{
        if (channel == 15) {
                close_all_channels();
                return ST_OK;
        }

        switch (chan_mode[channel]) {
                case CHMOD_FREE:
                        break;
 
                case CHMOD_DIRECT:
                        free_buffer(chan_buf_num[channel]);
                        chan_buf[channel] = NULL;
                        chan_mode[channel] = CHMOD_FREE;
                        break;

                default:
                        delete[] chan_buf[channel];
                        chan_buf[channel] = NULL;
                        chan_mode[channel] = CHMOD_FREE;
                        break;
        }

        return ST_OK;
}


/*
 *  Close all channels
 */

void D64Drive::close_all_channels()
{
        for (int i=0; i<15; i++)
                Close(i);

        cmd_len = 0;
}


/*
 *  Read from channel
 */

uint8 D64Drive::Read(int channel, uint8 *byte)
{
        switch (chan_mode[channel]) {
                case CHMOD_COMMAND:
                        *byte = *error_ptr++;
                        if (--error_len)
                                return ST_OK;
                        else {
                                set_error(ERR_OK);
                                return ST_EOF;
                        }
                        break;

                case CHMOD_FILE:
                        // Read next block if necessary
                        if (chan_buf[channel][0] && !buf_len[channel]) {
                                if (!read_sector(chan_buf[channel][0], chan_buf[channel][1], chan_buf[channel]))
                                        return ST_READ_TIMEOUT;
                                buf_ptr[channel] = chan_buf[channel] + 2;

                                // Determine block length
                                buf_len[channel] = chan_buf[channel][0] ? 254 : (uint8)chan_buf[channel][1]-1;
                        }

                        if (buf_len[channel] > 0) {
                                *byte = *buf_ptr[channel]++;
                                if (!--buf_len[channel] && !chan_buf[channel][0])
                                        return ST_EOF;
                                else
                                        return ST_OK;
                        } else
                                return ST_READ_TIMEOUT;
                        break;

                case CHMOD_DIRECTORY:
                case CHMOD_DIRECT:
                        if (buf_len[channel] > 0) {
                                *byte = *buf_ptr[channel]++;
                                if (--buf_len[channel])
                                        return ST_OK;
                                else
                                        return ST_EOF;
                        } else
                                return ST_READ_TIMEOUT;
                        break;
        }
        return ST_READ_TIMEOUT;
}


/*
 *  Write byte to channel
 */

uint8 D64Drive::Write(int channel, uint8 byte, bool eoi)
{
        switch (chan_mode[channel]) {
                case CHMOD_FREE:
                        set_error(ERR_FILENOTOPEN);
                        break;

                case CHMOD_COMMAND:
                        // Collect characters and execute command on EOI
                        if (cmd_len >= 40)
                                return ST_TIMEOUT;

                        cmd_buffer[cmd_len++] = byte;

                        if (eoi) {
                                cmd_buffer[cmd_len++] = 0;
                                cmd_len = 0;
                                execute_command(cmd_buffer);
                        }
                        return ST_OK;

                case CHMOD_DIRECTORY:
                        set_error(ERR_WRITEFILEOPEN);
                        break;
        }
        return ST_TIMEOUT;
}


/*
 *  Execute command string
 */

void D64Drive::execute_command(char *command)
{
        uint16 adr;
        int len;

        switch (command[0]) {
                case 'B':
                        if (command[1] != '-')
                                set_error(ERR_SYNTAX30);
                        else
                                switch (command[2]) {
                                        case 'R':
                                                block_read_cmd(&command[3]);
                                                break;

                                        case 'P':
                                                buffer_ptr_cmd(&command[3]);
                                                break;

                                        case 'A':
                                        case 'F':
                                        case 'W':
                                                set_error(ERR_WRITEPROTECT);
                                                break;

                                        default:
                                                set_error(ERR_SYNTAX30);
                                                break;
                                }
                        break;

                case 'M':
                        if (command[1] != '-')
                                set_error(ERR_SYNTAX30);
                        else
                                switch (command[2]) {
                                        case 'R':
                                                adr = ((uint8)command[4] << 8) | ((uint8)command[3]);
                                                error_ptr = (char *)(ram + (adr & 0x07ff));
                                                if (!(error_len = (uint8)command[5]))
                                                        error_len = 1;
                                                break;

                                        case 'W':
                                                adr = ((uint8)command[4] << 8) | ((uint8)command[3]);
                                                len = (uint8)command[5];
                                                for (int i=0; i<len; i++)
                                                        ram[adr+i] = (uint8)command[i+6];
                                                break;

                                        default:
                                                set_error(ERR_SYNTAX30);
                                }
                        break;

                case 'I':
                        close_all_channels();
                        read_sector(18, 0, (uint8 *)bam);
                        set_error(ERR_OK);
                        break;

                case 'U':
                        switch (command[1] & 0x0f) {
                                case 1:         // U1/UA: Block-Read
                                        block_read_cmd(&command[2]);
                                        break;

                                case 2:         // U2/UB: Block-Write
                                        set_error(ERR_WRITEPROTECT);
                                        break;

                                case 10:        // U:/UJ: Reset
                                        Reset();
                                        break;

                                default:
                                        set_error(ERR_SYNTAX30);
                                        break;
                        }
                        break;

                case 'G':
                        if (command[1] != ':')
                                set_error(ERR_SYNTAX30);
                        else
                                chd64_cmd(&command[2]);
                        break;

                case 'C':
                case 'N':
                case 'R':
                case 'S':
                case 'V':
                        set_error(ERR_WRITEPROTECT);
                        break;

                default:
                        set_error(ERR_SYNTAX30);
                        break;
        }
}


/*
 *  Execute B-R command
 */

void D64Drive::block_read_cmd(char *command)
{
        int channel, drvnum, track, sector;

        if (parse_bcmd(command, &channel, &drvnum, &track, &sector)) {
                if (chan_mode[channel] == CHMOD_DIRECT) {
                        read_sector(track, sector, buf_ptr[channel] = chan_buf[channel]);
                        buf_len[channel] = 256;
                        set_error(ERR_OK);
                } else
                        set_error(ERR_NOCHANNEL);
        } else
                set_error(ERR_SYNTAX30);
}


/*
 *  Execute B-P command
 */

void D64Drive::buffer_ptr_cmd(char *command)
{
        int channel, pointer, i;

        if (parse_bcmd(command, &channel, &pointer, &i, &i)) {
                if (chan_mode[channel] == CHMOD_DIRECT) {
                        buf_ptr[channel] = chan_buf[channel] + pointer;
                        buf_len[channel] = 256 - pointer;
                        set_error(ERR_OK);
                } else
                        set_error(ERR_NOCHANNEL);
        } else
                set_error(ERR_SYNTAX30);
}


/*
 *  Parse block command parameters
 *  true: OK, false: error
 */

bool D64Drive::parse_bcmd(char *cmd, int *arg1, int *arg2, int *arg3, int *arg4)
{
        int i;

        if (*cmd == ':') cmd++;

        // Read four parameters separated by space, cursor right or comma
        while (*cmd == ' ' || *cmd == 0x1d || *cmd == 0x2c) cmd++;
        if (!*cmd) return false;

        i = 0;
        while (*cmd >= 0x30 && *cmd < 0x40) {
                i *= 10;
                i += *cmd++ & 0x0f;
        }
        *arg1 = i & 0xff;

        while (*cmd == ' ' || *cmd == 0x1d || *cmd == 0x2c) cmd++;
        if (!*cmd) return false;

        i = 0;
        while (*cmd >= 0x30 && *cmd < 0x40) {
                i *= 10;
                i += *cmd++ & 0x0f;
        }
        *arg2 = i & 0xff;

        while (*cmd == ' ' || *cmd == 0x1d || *cmd == 0x2c) cmd++;
        if (!*cmd) return false;

        i = 0;
        while (*cmd >= 0x30 && *cmd < 0x40) {
                i *= 10;
                i += *cmd++ & 0x0f;
        }
        *arg3 = i & 0xff;

        while (*cmd == ' ' || *cmd == 0x1d || *cmd == 0x2c) cmd++;
        if (!*cmd) return false;

        i = 0;
        while (*cmd >= 0x30 && *cmd < 0x40) {
                i *= 10;
                i += *cmd++ & 0x0f;
        }
        *arg4 = i & 0xff;

        return true;
}


/*
 *  Execute 'G' command
 */

void D64Drive::chd64_cmd(char *d64name)
{
        char str[NAMEBUF_LENGTH];
        char *p = str;

        // Convert .d64 file name
        for (int i=0; i<NAMEBUF_LENGTH && (*p++ = conv_from_64(*d64name++, false)); i++) ;

        close_all_channels();

        // G:. resets the .d64 file name to its original setting
        if (str[0] == '.' && str[1] == 0)
                open_close_d64_file(orig_d64_name);
        else
                open_close_d64_file(str);

        // Read BAM
        read_sector(18, 0, (uint8 *)bam);
}


/*
 *  Reset drive
 */

void D64Drive::Reset(void)
{
        close_all_channels();

        read_sector(18, 0, (uint8 *)bam);

        cmd_len = 0;
        for (int i=0; i<4; i++)
                buf_free[i] = true;

        set_error(ERR_STARTUP);
}


/*
 *  Allocate floppy buffer
 *   -> Desired buffer number or -1
 *   <- Allocated buffer number or -1
 */

int D64Drive::alloc_buffer(int want)
{
        if (want == -1) {
                for (want=3; want>=0; want--)
                        if (buf_free[want]) {
                                buf_free[want] = false;
                                return want;
                        }
                return -1;
        }

        if (want < 4)
                if (buf_free[want]) {
                        buf_free[want] = false;
                        return want;
                } else
                        return -1;
        else
                return -1;
}


/*
 *  Free floppy buffer
 */

void D64Drive::free_buffer(int buf)
{
        buf_free[buf] = true;
}


/*
 *  Read sector (256 bytes)
 *  true: success, false: error
 */

bool D64Drive::read_sector(int track, int sector, uint8 *buffer)
{
        int offset;

        // Convert track/sector to byte offset in file
        if ((offset = offset_from_ts(track, sector)) < 0) {
                set_error(ERR_ILLEGALTS);
                return false;
        }

        if (the_file == NULL) {
                set_error(ERR_NOTREADY);
                return false;
        }

#ifdef AMIGA
        if (offset != ftell(the_file))
                fseek(the_file, offset + image_header, SEEK_SET);
#else
        fseek(the_file, offset + image_header, SEEK_SET);
#endif
        fread(buffer, 256, 1, the_file);
        return true;
}


/*
 *  Convert track/sector to offset
 */

const int num_sectors[41] = {
        0,
        21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,
        19,19,19,19,19,19,19,
        18,18,18,18,18,18,
        17,17,17,17,17,
        17,17,17,17,17          // Tracks 36..40
};

const int sector_offset[41] = {
        0,
        0,21,42,63,84,105,126,147,168,189,210,231,252,273,294,315,336,
        357,376,395,414,433,452,471,
        490,508,526,544,562,580,
        598,615,632,649,666,
        683,700,717,734,751     // Tracks 36..40
};

int D64Drive::offset_from_ts(int track, int sector)
{
        if ((track < 1) || (track > NUM_TRACKS) ||
                (sector < 0) || (sector >= num_sectors[track]))
                return -1;

        return (sector_offset[track] + sector) << 8;
}


/*
 *  Conversion PETSCII->ASCII
 */

uint8 D64Drive::conv_from_64(uint8 c, bool map_slash)
{
        if ((c >= 'A') && (c <= 'Z') || (c >= 'a') && (c <= 'z'))
                return c ^ 0x20;
        if ((c >= 0xc1) && (c <= 0xda))
                return c ^ 0x80;
        if ((c == '/') && map_slash && ThePrefs.MapSlash)
                return '\\';
        return c;
}
Revision:	1.3
Committed:	2003-07-02T14:46:24Z (21 years, 4 months ago) by cebix
Branch:	MAIN
Changes since 1.2:	+2 -1 lines
Log Message:	when the ROM files are not found, builtin defaults are used
#	User	Rev	Content
1	cebix	1.1	/*
2			* 1541d64.cpp - 1541 emulation in .d64 file
3			*
4	cebix	1.2	* Frodo (C) 1994-1997,2002-2003 Christian Bauer
5	cebix	1.1	*
6			* This program is free software; you can redistribute it and/or modify
7			* it under the terms of the GNU General Public License as published by
8			* the Free Software Foundation; either version 2 of the License, or
9			* (at your option) any later version.
10			*
11			* This program is distributed in the hope that it will be useful,
12			* but WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			* GNU General Public License for more details.
15			*
16			* You should have received a copy of the GNU General Public License
17			* along with this program; if not, write to the Free Software
18			* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19			*/
20
21			/*
22			* Incompatibilities:
23			* ------------------
24			*
25			* - Only read accesses possible
26			* - Not all commands implemented
27			* - The .d64 error info is read, but unused
28			*/
29
30			#include "sysdeps.h"
31
32			#include "1541d64.h"
33			#include "IEC.h"
34			#include "Prefs.h"
35	cebix	1.3	#include "C64.h"
36	cebix	1.1
37
38			// Channel modes (IRC users listen up :-)
39			enum {
40			CHMOD_FREE, // Channel free
41			CHMOD_COMMAND, // Command/error channel
42			CHMOD_DIRECTORY, // Reading directory
43			CHMOD_FILE, // Sequential file open
44			CHMOD_DIRECT // Direct buffer access ('#')
45			};
46
47			// Access modes
48			enum {
49			FMODE_READ, FMODE_WRITE, FMODE_APPEND
50			};
51
52			// File types
53			enum {
54			FTYPE_PRG, FTYPE_SEQ, FTYPE_USR, FTYPE_REL
55			};
56
57			// Number of tracks/sectors
58			const int NUM_TRACKS = 35;
59			const int NUM_SECTORS = 683;
60
61			// Prototypes
62			static bool match(uint8 p, uint8 n);
63
64
65			/*
66			* Constructor: Prepare emulation, open .d64 file
67			*/
68
69			D64Drive::D64Drive(IEC iec, char filepath) : Drive(iec)
70			{
71			the_file = NULL;
72			ram = NULL;
73
74			Ready = false;
75			strcpy(orig_d64_name, filepath);
76			for (int i=0; i<=14; i++) {
77			chan_mode[i] = CHMOD_FREE;
78			chan_buf[i] = NULL;
79			}
80			chan_mode[15] = CHMOD_COMMAND;
81
82			// Open .d64 file
83			open_close_d64_file(filepath);
84			if (the_file != NULL) {
85
86			// Allocate 1541 RAM
87	cebix	1.3	ram = new uint8[DRIVE_RAM_SIZE];
88	cebix	1.1	bam = (BAM *)(ram + 0x700);
89
90			Reset();
91			Ready = true;
92			}
93			}
94
95
96			/*
97			* Destructor
98			*/
99
100			D64Drive::~D64Drive()
101			{
102			// Close .d64 file
103			open_close_d64_file("");
104
105			delete[] ram;
106			Ready = false;
107			}
108
109
110			/*
111			* Open/close the .d64 file
112			*/
113
114			void D64Drive::open_close_d64_file(char *d64name)
115			{
116			long size;
117			uint8 magic[4];
118
119			// Close old .d64, if open
120			if (the_file != NULL) {
121			close_all_channels();
122			fclose(the_file);
123			the_file = NULL;
124			}
125
126			// Open new .d64 file
127			if (d64name[0]) {
128			if ((the_file = fopen(d64name, "rb")) != NULL) {
129
130			// Check length
131			fseek(the_file, 0, SEEK_END);
132			if ((size = ftell(the_file)) < NUM_SECTORS * 256) {
133			fclose(the_file);
134			the_file = NULL;
135			return;
136			}
137
138			// x64 image?
139			rewind(the_file);
140			fread(&magic, 4, 1, the_file);
141			if (magic[0] == 0x43 && magic[1] == 0x15 && magic[2] == 0x41 && magic[3] == 0x64)
142			image_header = 64;
143			else
144			image_header = 0;
145
146			// Preset error info (all sectors no error)
147			memset(error_info, 1, NUM_SECTORS);
148
149			// Load sector error info from .d64 file, if present
150			if (!image_header && size == NUM_SECTORS * 257) {
151			fseek(the_file, NUM_SECTORS * 256, SEEK_SET);
152			fread(&error_info, NUM_SECTORS, 1, the_file);
153			}
154			}
155			}
156			}
157
158
159			/*
160			* Open channel
161			*/
162
163			uint8 D64Drive::Open(int channel, char *filename)
164			{
165			set_error(ERR_OK);
166
167			// Channel 15: execute file name as command
168			if (channel == 15) {
169			execute_command(filename);
170			return ST_OK;
171			}
172
173			if (chan_mode[channel] != CHMOD_FREE) {
174			set_error(ERR_NOCHANNEL);
175			return ST_OK;
176			}
177
178			if (filename[0] == '$')
179			if (channel)
180			return open_file_ts(channel, 18, 0);
181			else
182			return open_directory(filename+1);
183
184			if (filename[0] == '#')
185			return open_direct(channel, filename);
186
187			return open_file(channel, filename);
188			}
189
190
191			/*
192			* Open file
193			*/
194
195			uint8 D64Drive::open_file(int channel, char *filename)
196			{
197			char plainname[256];
198			int filemode = FMODE_READ;
199			int filetype = FTYPE_PRG;
200			int track, sector;
201
202			convert_filename(filename, plainname, &filemode, &filetype);
203
204			// Channel 0 is READ PRG, channel 1 is WRITE PRG
205			if (!channel) {
206			filemode = FMODE_READ;
207			filetype = FTYPE_PRG;
208			}
209			if (channel == 1) {
210			filemode = FMODE_WRITE;
211			filetype = FTYPE_PRG;
212			}
213
214			// Allow only read accesses
215			if (filemode != FMODE_READ) {
216			set_error(ERR_WRITEPROTECT);
217			return ST_OK;
218			}
219
220			// Find file in directory and open it
221			if (find_file(plainname, &track, &sector))
222			return open_file_ts(channel, track, sector);
223			else
224			set_error(ERR_FILENOTFOUND);
225
226			return ST_OK;
227			}
228
229
230			/*
231			* Analyze file name, get access mode and type
232			*/
233
234			void D64Drive::convert_filename(char srcname, char destname, int filemode, int filetype)
235			{
236			char *p;
237
238			// Search for ':', p points to first character after ':'
239			if ((p = strchr(srcname, ':')) != NULL)
240			p++;
241			else
242			p = srcname;
243
244			// Remaining string -> destname
245			strncpy(destname, p, NAMEBUF_LENGTH);
246
247			// Search for ','
248			p = destname;
249			while (p && (p != ',')) p++;
250
251			// Look for mode parameters seperated by ','
252			p = destname;
253			while ((p = strchr(p, ',')) != NULL) {
254
255			// Cut string after the first ','
256			*p++ = 0;
257
258			switch (*p) {
259			case 'P':
260			*filetype = FTYPE_PRG;
261			break;
262			case 'S':
263			*filetype = FTYPE_SEQ;
264			break;
265			case 'U':
266			*filetype = FTYPE_USR;
267			break;
268			case 'L':
269			*filetype = FTYPE_REL;
270			break;
271			case 'R':
272			*filemode = FMODE_READ;
273			break;
274			case 'W':
275			*filemode = FMODE_WRITE;
276			break;
277			case 'A':
278			*filemode = FMODE_APPEND;
279			break;
280			}
281			}
282			}
283
284
285			/*
286			* Search file in directory, find first track and sector
287			* false: not found, true: found
288			*/
289
290			bool D64Drive::find_file(char filename, int track, int *sector)
291			{
292			int i, j;
293			uint8 p, q;
294			DirEntry *de;
295
296			// Scan all directory blocks
297			dir.next_track = bam->dir_track;
298			dir.next_sector = bam->dir_sector;
299
300			while (dir.next_track) {
301			if (!read_sector(dir.next_track, dir.next_sector, (uint8 *) &dir.next_track))
302			return false;
303
304			// Scan all 8 entries of a block
305			for (j=0; j<8; j++) {
306			de = &dir.entry[j];
307			*track = de->track;
308			*sector = de->sector;
309
310			if (de->type) {
311			p = (uint8 *)filename;
312			q = de->name;
313			for (i=0; i<16 && *p; i++, p++, q++) {
314			if (p == '') // Wildcard '*' matches all following characters
315			return true;
316			if (p != q) {
317			if (*p != '?') goto next_entry; // Wildcard '?' matches single character
318			if (*q == 0xa0) goto next_entry;
319			}
320			}
321
322			if (i == 16 \|\| *q == 0xa0)
323			return true;
324			}
325			next_entry: ;
326			}
327			}
328
329			return false;
330			}
331
332
333			/*
334			* Open file given track/sector of first block
335			*/
336
337			uint8 D64Drive::open_file_ts(int channel, int track, int sector)
338			{
339			chan_buf[channel] = new uint8[256];
340			chan_mode[channel] = CHMOD_FILE;
341
342			// On the next call to Read, the first block will be read
343			chan_buf[channel][0] = track;
344			chan_buf[channel][1] = sector;
345			buf_len[channel] = 0;
346
347			return ST_OK;
348			}
349
350
351			/*
352			* Prepare directory as BASIC program (channel 0)
353			*/
354
355			const char type_char_1[] = "DSPUREERSELQGRL?";
356			const char type_char_2[] = "EERSELQGRL??????";
357			const char type_char_3[] = "LQGRL???????????";
358
359			// Return true if name 'n' matches pattern 'p'
360			static bool match(uint8 p, uint8 n)
361			{
362			if (!*p) // Null pattern matches everything
363			return true;
364
365			do {
366			if (p == '') // Wildcard '*' matches all following characters
367			return true;
368			if ((p != n) && (*p != '?')) // Wildcard '?' matches single character
369			return false;
370			p++; n++;
371			} while (*p);
372
373			return *n == 0xa0;
374			}
375
376			uint8 D64Drive::open_directory(char *pattern)
377			{
378			int i, j, n, m;
379			uint8 p, q;
380			DirEntry *de;
381			uint8 c;
382			char *tmppat;
383
384			// Special treatment for "$0"
385			if (pattern[0] == '0' && pattern[1] == 0)
386			pattern += 1;
387
388			// Skip everything before the ':' in the pattern
389			if ((tmppat = strchr(pattern, ':')) != NULL)
390			pattern = tmppat + 1;
391
392			p = buf_ptr[0] = chan_buf[0] = new uint8[8192];
393			chan_mode[0] = CHMOD_DIRECTORY;
394
395			// Create directory title
396			*p++ = 0x01; // Load address $0401 (from PET days :-)
397			*p++ = 0x04;
398			*p++ = 0x01; // Dummy line link
399			*p++ = 0x01;
400			*p++ = 0; // Drive number (0) as line number
401			*p++ = 0;
402			*p++ = 0x12; // RVS ON
403			*p++ = '\"';
404
405			q = bam->disk_name;
406			for (i=0; i<23; i++) {
407			if ((c = *q++) == 0xa0)
408			*p++ = ' '; // Replace 0xa0 by space
409			else
410			*p++ = c;
411			}
412			*(p-7) = '\"';
413			*p++ = 0;
414
415			// Scan all directory blocks
416			dir.next_track = bam->dir_track;
417			dir.next_sector = bam->dir_sector;
418
419			while (dir.next_track) {
420			if (!read_sector(dir.next_track, dir.next_sector, (uint8 *) &dir.next_track))
421			return ST_OK;
422
423			// Scan all 8 entries of a block
424			for (j=0; j<8; j++) {
425			de = &dir.entry[j];
426
427			if (de->type && match((uint8 *)pattern, de->name)) {
428			*p++ = 0x01; // Dummy line link
429			*p++ = 0x01;
430
431			*p++ = de->num_blocks_l; // Line number
432			*p++ = de->num_blocks_h;
433
434			*p++ = ' ';
435			n = (de->num_blocks_h << 8) + de->num_blocks_l;
436			if (n<10) *p++ = ' ';
437			if (n<100) *p++ = ' ';
438
439			*p++ = '\"';
440			q = de->name;
441			m = 0;
442			for (i=0; i<16; i++) {
443			if ((c = *q++) == 0xa0) {
444			if (m)
445			*p++ = ' '; // Replace all 0xa0 by spaces
446			else
447			m = *p++ = '\"'; // But the first by a '"'
448			} else
449			*p++ = c;
450			}
451			if (m)
452			*p++ = ' ';
453			else
454			*p++ = '\"'; // No 0xa0, then append a space
455
456			if (de->type & 0x80)
457			*p++ = ' ';
458			else
459			p++ = '';
460
461			*p++ = type_char_1[de->type & 0x0f];
462			*p++ = type_char_2[de->type & 0x0f];
463			*p++ = type_char_3[de->type & 0x0f];
464
465			if (de->type & 0x40)
466			*p++ = '<';
467			else
468			*p++ = ' ';
469
470			*p++ = ' ';
471			if (n >= 10) *p++ = ' ';
472			if (n >= 100) *p++ = ' ';
473			*p++ = 0;
474			}
475			}
476			}
477
478			// Final line
479			q = p;
480			for (i=0; i<29; i++)
481			*q++ = ' ';
482
483			n = 0;
484			for (i=0; i<35; i++)
485			n += bam->bitmap[i*4];
486
487			*p++ = 0x01; // Dummy line link
488			*p++ = 0x01;
489			*p++ = n & 0xff; // Number of free blocks as line number
490			*p++ = (n >> 8) & 0xff;
491
492			*p++ = 'B';
493			*p++ = 'L';
494			*p++ = 'O';
495			*p++ = 'C';
496			*p++ = 'K';
497			*p++ = 'S';
498			*p++ = ' ';
499			*p++ = 'F';
500			*p++ = 'R';
501			*p++ = 'E';
502			*p++ = 'E';
503			*p++ = '.';
504
505			p = q;
506			*p++ = 0;
507			*p++ = 0;
508			*p++ = 0;
509
510			buf_len[0] = p - chan_buf[0];
511
512			return ST_OK;
513			}
514
515
516			/*
517			* Open channel for direct buffer access
518			*/
519
520			uint8 D64Drive::open_direct(int channel, char *filename)
521			{
522			int buf = -1;
523
524			if (filename[1] == 0)
525			buf = alloc_buffer(-1);
526			else
527			if ((filename[1] >= '0') && (filename[1] <= '3') && (filename[2] == 0))
528			buf = alloc_buffer(filename[1] - '0');
529
530			if (buf == -1) {
531			set_error(ERR_NOCHANNEL);
532			return ST_OK;
533			}
534
535			// The buffers are in the 1541 RAM at $300 and are 256 bytes each
536			chan_buf[channel] = buf_ptr[channel] = ram + 0x300 + (buf << 8);
537			chan_mode[channel] = CHMOD_DIRECT;
538			chan_buf_num[channel] = buf;
539
540			// Store actual buffer number in buffer
541			*chan_buf[channel] = buf + '0';
542			buf_len[channel] = 1;
543
544			return ST_OK;
545			}
546
547
548			/*
549			* Close channel
550			*/
551
552			uint8 D64Drive::Close(int channel)
553			{
554			if (channel == 15) {
555			close_all_channels();
556			return ST_OK;
557			}
558
559			switch (chan_mode[channel]) {
560			case CHMOD_FREE:
561			break;
562
563			case CHMOD_DIRECT:
564			free_buffer(chan_buf_num[channel]);
565			chan_buf[channel] = NULL;
566			chan_mode[channel] = CHMOD_FREE;
567			break;
568
569			default:
570			delete[] chan_buf[channel];
571			chan_buf[channel] = NULL;
572			chan_mode[channel] = CHMOD_FREE;
573			break;
574			}
575
576			return ST_OK;
577			}
578
579
580			/*
581			* Close all channels
582			*/
583
584			void D64Drive::close_all_channels()
585			{
586			for (int i=0; i<15; i++)
587			Close(i);
588
589			cmd_len = 0;
590			}
591
592
593			/*
594			* Read from channel
595			*/
596
597			uint8 D64Drive::Read(int channel, uint8 *byte)
598			{
599			switch (chan_mode[channel]) {
600			case CHMOD_COMMAND:
601			byte = error_ptr++;
602			if (--error_len)
603			return ST_OK;
604			else {
605			set_error(ERR_OK);
606			return ST_EOF;
607			}
608			break;
609
610			case CHMOD_FILE:
611			// Read next block if necessary
612			if (chan_buf[channel][0] && !buf_len[channel]) {
613			if (!read_sector(chan_buf[channel][0], chan_buf[channel][1], chan_buf[channel]))
614			return ST_READ_TIMEOUT;
615			buf_ptr[channel] = chan_buf[channel] + 2;
616
617			// Determine block length
618			buf_len[channel] = chan_buf[channel][0] ? 254 : (uint8)chan_buf[channel][1]-1;
619			}
620
621			if (buf_len[channel] > 0) {
622			byte = buf_ptr[channel]++;
623			if (!--buf_len[channel] && !chan_buf[channel][0])
624			return ST_EOF;
625			else
626			return ST_OK;
627			} else
628			return ST_READ_TIMEOUT;
629			break;
630
631			case CHMOD_DIRECTORY:
632			case CHMOD_DIRECT:
633			if (buf_len[channel] > 0) {
634			byte = buf_ptr[channel]++;
635			if (--buf_len[channel])
636			return ST_OK;
637			else
638			return ST_EOF;
639			} else
640			return ST_READ_TIMEOUT;
641			break;
642			}
643			return ST_READ_TIMEOUT;
644			}
645
646
647			/*
648			* Write byte to channel
649			*/
650
651			uint8 D64Drive::Write(int channel, uint8 byte, bool eoi)
652			{
653			switch (chan_mode[channel]) {
654			case CHMOD_FREE:
655			set_error(ERR_FILENOTOPEN);
656			break;
657
658			case CHMOD_COMMAND:
659			// Collect characters and execute command on EOI
660			if (cmd_len >= 40)
661			return ST_TIMEOUT;
662
663			cmd_buffer[cmd_len++] = byte;
664
665			if (eoi) {
666			cmd_buffer[cmd_len++] = 0;
667			cmd_len = 0;
668			execute_command(cmd_buffer);
669			}
670			return ST_OK;
671
672			case CHMOD_DIRECTORY:
673			set_error(ERR_WRITEFILEOPEN);
674			break;
675			}
676			return ST_TIMEOUT;
677			}
678
679
680			/*
681			* Execute command string
682			*/
683
684			void D64Drive::execute_command(char *command)
685			{
686			uint16 adr;
687			int len;
688
689			switch (command[0]) {
690			case 'B':
691			if (command[1] != '-')
692			set_error(ERR_SYNTAX30);
693			else
694			switch (command[2]) {
695			case 'R':
696			block_read_cmd(&command[3]);
697			break;
698
699			case 'P':
700			buffer_ptr_cmd(&command[3]);
701			break;
702
703			case 'A':
704			case 'F':
705			case 'W':
706			set_error(ERR_WRITEPROTECT);
707			break;
708
709			default:
710			set_error(ERR_SYNTAX30);
711			break;
712			}
713			break;
714
715			case 'M':
716			if (command[1] != '-')
717			set_error(ERR_SYNTAX30);
718			else
719			switch (command[2]) {
720			case 'R':
721			adr = ((uint8)command[4] << 8) \| ((uint8)command[3]);
722			error_ptr = (char *)(ram + (adr & 0x07ff));
723			if (!(error_len = (uint8)command[5]))
724			error_len = 1;
725			break;
726
727			case 'W':
728			adr = ((uint8)command[4] << 8) \| ((uint8)command[3]);
729			len = (uint8)command[5];
730			for (int i=0; i<len; i++)
731			ram[adr+i] = (uint8)command[i+6];
732			break;
733
734			default:
735			set_error(ERR_SYNTAX30);
736			}
737			break;
738
739			case 'I':
740			close_all_channels();
741			read_sector(18, 0, (uint8 *)bam);
742			set_error(ERR_OK);
743			break;
744
745			case 'U':
746			switch (command[1] & 0x0f) {
747			case 1: // U1/UA: Block-Read
748			block_read_cmd(&command[2]);
749			break;
750
751			case 2: // U2/UB: Block-Write
752			set_error(ERR_WRITEPROTECT);
753			break;
754
755			case 10: // U:/UJ: Reset
756			Reset();
757			break;
758
759			default:
760			set_error(ERR_SYNTAX30);
761			break;
762			}
763			break;
764
765			case 'G':
766			if (command[1] != ':')
767			set_error(ERR_SYNTAX30);
768			else
769			chd64_cmd(&command[2]);
770			break;
771
772			case 'C':
773			case 'N':
774			case 'R':
775			case 'S':
776			case 'V':
777			set_error(ERR_WRITEPROTECT);
778			break;
779
780			default:
781			set_error(ERR_SYNTAX30);
782			break;
783			}
784			}
785
786
787			/*
788			* Execute B-R command
789			*/
790
791			void D64Drive::block_read_cmd(char *command)
792			{
793			int channel, drvnum, track, sector;
794
795			if (parse_bcmd(command, &channel, &drvnum, &track, &sector)) {
796			if (chan_mode[channel] == CHMOD_DIRECT) {
797			read_sector(track, sector, buf_ptr[channel] = chan_buf[channel]);
798			buf_len[channel] = 256;
799			set_error(ERR_OK);
800			} else
801			set_error(ERR_NOCHANNEL);
802			} else
803			set_error(ERR_SYNTAX30);
804			}
805
806
807			/*
808			* Execute B-P command
809			*/
810
811			void D64Drive::buffer_ptr_cmd(char *command)
812			{
813			int channel, pointer, i;
814
815			if (parse_bcmd(command, &channel, &pointer, &i, &i)) {
816			if (chan_mode[channel] == CHMOD_DIRECT) {
817			buf_ptr[channel] = chan_buf[channel] + pointer;
818			buf_len[channel] = 256 - pointer;
819			set_error(ERR_OK);
820			} else
821			set_error(ERR_NOCHANNEL);
822			} else
823			set_error(ERR_SYNTAX30);
824			}
825
826
827			/*
828			* Parse block command parameters
829			* true: OK, false: error
830			*/
831
832			bool D64Drive::parse_bcmd(char cmd, int arg1, int arg2, int arg3, int *arg4)
833			{
834			int i;
835
836			if (*cmd == ':') cmd++;
837
838			// Read four parameters separated by space, cursor right or comma
839			while (cmd == ' ' \|\| cmd == 0x1d \|\| *cmd == 0x2c) cmd++;
840			if (!*cmd) return false;
841
842			i = 0;
843			while (cmd >= 0x30 && cmd < 0x40) {
844			i *= 10;
845			i += *cmd++ & 0x0f;
846			}
847			*arg1 = i & 0xff;
848
849			while (cmd == ' ' \|\| cmd == 0x1d \|\| *cmd == 0x2c) cmd++;
850			if (!*cmd) return false;
851
852			i = 0;
853			while (cmd >= 0x30 && cmd < 0x40) {
854			i *= 10;
855			i += *cmd++ & 0x0f;
856			}
857			*arg2 = i & 0xff;
858
859			while (cmd == ' ' \|\| cmd == 0x1d \|\| *cmd == 0x2c) cmd++;
860			if (!*cmd) return false;
861
862			i = 0;
863			while (cmd >= 0x30 && cmd < 0x40) {
864			i *= 10;
865			i += *cmd++ & 0x0f;
866			}
867			*arg3 = i & 0xff;
868
869			while (cmd == ' ' \|\| cmd == 0x1d \|\| *cmd == 0x2c) cmd++;
870			if (!*cmd) return false;
871
872			i = 0;
873			while (cmd >= 0x30 && cmd < 0x40) {
874			i *= 10;
875			i += *cmd++ & 0x0f;
876			}
877			*arg4 = i & 0xff;
878
879			return true;
880			}
881
882
883			/*
884			* Execute 'G' command
885			*/
886
887			void D64Drive::chd64_cmd(char *d64name)
888			{
889			char str[NAMEBUF_LENGTH];
890			char *p = str;
891
892			// Convert .d64 file name
893			for (int i=0; i<NAMEBUF_LENGTH && (p++ = conv_from_64(d64name++, false)); i++) ;
894
895			close_all_channels();
896
897			// G:. resets the .d64 file name to its original setting
898			if (str[0] == '.' && str[1] == 0)
899			open_close_d64_file(orig_d64_name);
900			else
901			open_close_d64_file(str);
902
903			// Read BAM
904			read_sector(18, 0, (uint8 *)bam);
905			}
906
907
908			/*
909			* Reset drive
910			*/
911
912			void D64Drive::Reset(void)
913			{
914			close_all_channels();
915
916			read_sector(18, 0, (uint8 *)bam);
917
918			cmd_len = 0;
919			for (int i=0; i<4; i++)
920			buf_free[i] = true;
921
922			set_error(ERR_STARTUP);
923			}
924
925
926			/*
927			* Allocate floppy buffer
928			* -> Desired buffer number or -1
929			* <- Allocated buffer number or -1
930			*/
931
932			int D64Drive::alloc_buffer(int want)
933			{
934			if (want == -1) {
935			for (want=3; want>=0; want--)
936			if (buf_free[want]) {
937			buf_free[want] = false;
938			return want;
939			}
940			return -1;
941			}
942
943			if (want < 4)
944			if (buf_free[want]) {
945			buf_free[want] = false;
946			return want;
947			} else
948			return -1;
949			else
950			return -1;
951			}
952
953
954			/*
955			* Free floppy buffer
956			*/
957
958			void D64Drive::free_buffer(int buf)
959			{
960			buf_free[buf] = true;
961			}
962
963
964			/*
965			* Read sector (256 bytes)
966			* true: success, false: error
967			*/
968
969			bool D64Drive::read_sector(int track, int sector, uint8 *buffer)
970			{
971			int offset;
972
973			// Convert track/sector to byte offset in file
974			if ((offset = offset_from_ts(track, sector)) < 0) {
975			set_error(ERR_ILLEGALTS);
976			return false;
977			}
978
979			if (the_file == NULL) {
980			set_error(ERR_NOTREADY);
981			return false;
982			}
983
984			#ifdef AMIGA
985			if (offset != ftell(the_file))
986			fseek(the_file, offset + image_header, SEEK_SET);
987			#else
988			fseek(the_file, offset + image_header, SEEK_SET);
989			#endif
990			fread(buffer, 256, 1, the_file);
991			return true;
992			}
993
994
995			/*
996			* Convert track/sector to offset
997			*/
998
999			const int num_sectors[41] = {
1000			0,
1001			21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,
1002			19,19,19,19,19,19,19,
1003			18,18,18,18,18,18,
1004			17,17,17,17,17,
1005			17,17,17,17,17 // Tracks 36..40
1006			};
1007
1008			const int sector_offset[41] = {
1009			0,
1010			0,21,42,63,84,105,126,147,168,189,210,231,252,273,294,315,336,
1011			357,376,395,414,433,452,471,
1012			490,508,526,544,562,580,
1013			598,615,632,649,666,
1014			683,700,717,734,751 // Tracks 36..40
1015			};
1016
1017			int D64Drive::offset_from_ts(int track, int sector)
1018			{
1019			if ((track < 1) \|\| (track > NUM_TRACKS) \|\|
1020			(sector < 0) \|\| (sector >= num_sectors[track]))
1021			return -1;
1022
1023			return (sector_offset[track] + sector) << 8;
1024			}
1025
1026
1027			/*
1028			* Conversion PETSCII->ASCII
1029			*/
1030
1031			uint8 D64Drive::conv_from_64(uint8 c, bool map_slash)
1032			{
1033			if ((c >= 'A') && (c <= 'Z') \|\| (c >= 'a') && (c <= 'z'))
1034			return c ^ 0x20;
1035			if ((c >= 0xc1) && (c <= 0xda))
1036			return c ^ 0x80;
1037			if ((c == '/') && map_slash && ThePrefs.MapSlash)
1038			return '\\';
1039			return c;
1040			}