Frodo4/Src/IEC.cpp

/*
 *  IEC.cpp - IEC bus routines, 1541 emulation (DOS level)
 *
 *  Frodo (C) 1994-1997,2002-2005 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
 */

/*
 * Notes:
 * ------
 *
 *  - There are three kinds of devices on the IEC bus: controllers,
 *    listeners and talkers. We are always the controller and we
 *    can additionally be either listener or talker. There can be
 *    only one listener and one talker active at the same time (the
 *    real IEC bus allows multiple listeners, but we don't).
 *  - There is one Drive object for every emulated drive (8..11).
 *    A pointer to one of them is stored in "listener"/"talker"
 *    when talk()/listen() is called and is used by the functions
 *    called afterwards.
 *  - The Drive objects have four virtual functions so that the
 *    interface to them is independent of their implementation:
 *      Open() opens a channel
 *      Close() closes a channel
 *      Read() reads from a channel
 *      Write() writes to a channel
 *  - The EOI/EOF signal is special on the IEC bus in that it is
 *    Sent before the last byte, not after it.
 */

#include "sysdeps.h"

#include "IEC.h"
#include "1541fs.h"
#include "1541d64.h"
#include "1541t64.h"
#include "Prefs.h"
#include "Display.h"
#include "main.h"


// IEC command codes
enum {
        CMD_DATA = 0x60,        // Data transfer
        CMD_CLOSE = 0xe0,       // Close channel
        CMD_OPEN = 0xf0         // Open channel
};

// IEC ATN codes
enum {
        ATN_LISTEN = 0x20,
        ATN_UNLISTEN = 0x30,
        ATN_TALK = 0x40,
        ATN_UNTALK = 0x50
};


/*
 *  Constructor: Initialize variables
 */

Drive *IEC::create_drive(const char *path)
{
        if (IsDirectory(path)) {
                // Mount host directory
                return new FSDrive(this, path);
        } else {
                // Not a directory, check for mountable file type
                int type;
                if (IsMountableFile(path, type)) {
                        if (type == FILE_IMAGE) {
                                // Mount disk image
                                return new ImageDrive(this, path);
                        } else {
                                // Mount archive type file
                                return new ArchDrive(this, path);
                        }
                } else {
                        // Unknown file type
                        // print error?
                }
        }
}

IEC::IEC(C64Display *display) : the_display(display)
{
        int i;

        // Create drives 8..11
        for (i=0; i<4; i++)
                drive[i] = NULL;        // Important because UpdateLEDs is called from the drive constructors (via set_error)

        if (!ThePrefs.Emul1541Proc) {
                for (i=0; i<4; i++)
                        drive[i] = create_drive(ThePrefs.DrivePath[i]);
        }

        listener_active = talker_active = false;
        listening = false;
}


/*
 *  Destructor: Delete drives
 */

IEC::~IEC()
{
        for (int i=0; i<4; i++)
                delete drive[i];
}


/*
 *  Reset all drives
 */

void IEC::Reset(void)
{
        for (int i=0; i<4; i++)
                if (drive[i] != NULL && drive[i]->Ready)
                        drive[i]->Reset();

        UpdateLEDs();
}


/*
 *  Preferences have changed, prefs points to new preferences,
 *  ThePrefs still holds the previous ones. Check if drive settings
 *  have changed.
 */

void IEC::NewPrefs(Prefs *prefs)
{
        // Delete and recreate all changed drives
        for (int i=0; i<4; i++) {
                if (strcmp(ThePrefs.DrivePath[i], prefs->DrivePath[i]) || ThePrefs.Emul1541Proc != prefs->Emul1541Proc) {
                        delete drive[i];
                        drive[i] = NULL;        // Important because UpdateLEDs is called from drive constructors (via set_error())
                        if (!prefs->Emul1541Proc)
                                drive[i] = create_drive(prefs->DrivePath[i]);
                }
        }

        UpdateLEDs();
}


/*
 *  Update drive LED display
 */

void IEC::UpdateLEDs(void)
{
        if (drive[0] != NULL && drive[1] != NULL && drive[2] != NULL && drive[3] != NULL)
                the_display->UpdateLEDs(drive[0]->LED, drive[1]->LED, drive[2]->LED, drive[3]->LED);
}


/*
 *  Output one byte
 */

uint8 IEC::Out(uint8 byte, bool eoi)
{
        if (listener_active) {
                if (received_cmd == CMD_OPEN)
                        return open_out(byte, eoi);
                if (received_cmd == CMD_DATA)
                        return data_out(byte, eoi);
                return ST_TIMEOUT;
        } else
                return ST_TIMEOUT;
}


/*
 *  Output one byte with ATN (Talk/Listen/Untalk/Unlisten)
 */

uint8 IEC::OutATN(uint8 byte)
{
        received_cmd = sec_addr = 0;    // Command is sent with secondary address
        switch (byte & 0xf0) {
                case ATN_LISTEN:
                        listening = true;
                        return listen(byte & 0x0f);
                case ATN_UNLISTEN:
                        listening = false;
                        return unlisten();
                case ATN_TALK:
                        listening = false;
                        return talk(byte & 0x0f);
                case ATN_UNTALK:
                        listening = false;
                        return untalk();
        }
        return ST_TIMEOUT;
}


/*
 *  Output secondary address
 */

uint8 IEC::OutSec(uint8 byte)
{
        if (listening) {
                if (listener_active) {
                        sec_addr = byte & 0x0f;
                        received_cmd = byte & 0xf0;
                        return sec_listen();
                }
        } else {
                if (talker_active) {
                        sec_addr = byte & 0x0f;
                        received_cmd = byte & 0xf0;
                        return sec_talk();
                }
        }
        return ST_TIMEOUT;
}


/*
 *  Read one byte
 */

uint8 IEC::In(uint8 &byte)
{
        if (talker_active && (received_cmd == CMD_DATA))
                return data_in(byte);

        byte = 0;
        return ST_TIMEOUT;
}


/*
 *  Assert ATN (for Untalk)
 */

void IEC::SetATN(void)
{
        // Only needed for real IEC
}


/*
 *  Release ATN
 */

void IEC::RelATN(void)
{
        // Only needed for real IEC
}


/*
 *  Talk-attention turn-around
 */

void IEC::Turnaround(void)
{
        // Only needed for real IEC
}


/*
 *  System line release
 */

void IEC::Release(void)
{
        // Only needed for real IEC
}


/*
 *  Listen
 */

uint8 IEC::listen(int device)
{
        if ((device >= 8) && (device <= 11)) {
                if ((listener = drive[device-8]) != NULL && listener->Ready) {
                        listener_active = true;
                        return ST_OK;
                }
        }

        listener_active = false;
        return ST_NOTPRESENT;
}


/*
 *  Talk
 */

uint8 IEC::talk(int device)
{
        if ((device >= 8) && (device <= 11)) {
                if ((talker = drive[device-8]) != NULL && talker->Ready) {
                        talker_active = true;
                        return ST_OK;
                }
        }

        talker_active = false;
        return ST_NOTPRESENT;
}


/*
 *  Unlisten
 */

uint8 IEC::unlisten(void)
{
        listener_active = false;
        return ST_OK;
}


/*
 *  Untalk
 */

uint8 IEC::untalk(void)
{
        talker_active = false;
        return ST_OK;
}


/*
 *  Secondary address after Listen
 */

uint8 IEC::sec_listen(void)
{
        switch (received_cmd) {

                case CMD_OPEN:  // Prepare for receiving the file name
                        name_ptr = name_buf;
                        name_len = 0;
                        return ST_OK;

                case CMD_CLOSE: // Close channel
                        if (listener->LED != DRVLED_ERROR) {
                                listener->LED = DRVLED_OFF;             // Turn off drive LED
                                UpdateLEDs();
                        }
                        return listener->Close(sec_addr);
        }
        return ST_OK;
}


/*
 *  Secondary address after Talk
 */

uint8 IEC::sec_talk(void)
{
        return ST_OK;
}


/*
 *  Byte after Open command: Store character in file name, open file on EOI
 */

uint8 IEC::open_out(uint8 byte, bool eoi)
{
        if (name_len < NAMEBUF_LENGTH) {
                *name_ptr++ = byte;
                name_len++;
        }

        if (eoi) {
                *name_ptr = 0;                          // End string
                listener->LED = DRVLED_ON;      // Turn on drive LED
                UpdateLEDs();
                return listener->Open(sec_addr, name_buf, name_len);
        }

        return ST_OK;
}


/*
 *  Write byte to channel
 */

uint8 IEC::data_out(uint8 byte, bool eoi)
{
        return listener->Write(sec_addr, byte, eoi);
}


/*
 *  Read byte from channel
 */

uint8 IEC::data_in(uint8 &byte)
{
        return talker->Read(sec_addr, byte);
}


/*
 *  Drive constructor
 */

Drive::Drive(IEC *iec)
{
        the_iec = iec;
        LED = DRVLED_OFF;
        Ready = false;
        set_error(ERR_STARTUP);
}


/*
 *  Set error message on drive
 */

// 1541 error messages
static const char *Errors_1541[] = {
        "00, OK,%02d,%02d\x0d",
        "01, FILES SCRATCHED,%02d,%02d\x0d",
        "03, UNIMPLEMENTED,%02d,%02d\x0d",
        "20, READ ERROR,%02d,%02d\x0d",
        "21, READ ERROR,%02d,%02d\x0d",
        "22, READ ERROR,%02d,%02d\x0d",
        "23, READ ERROR,%02d,%02d\x0d",
        "24, READ ERROR,%02d,%02d\x0d",
        "25, WRITE ERROR,%02d,%02d\x0d",
        "26, WRITE PROTECT ON,%02d,%02d\x0d",
        "27, READ ERROR,%02d,%02d\x0d",
        "28, WRITE ERROR,%02d,%02d\x0d",
        "29, DISK ID MISMATCH,%02d,%02d\x0d",
        "30, SYNTAX ERROR,%02d,%02d\x0d",
        "31, SYNTAX ERROR,%02d,%02d\x0d",
        "32, SYNTAX ERROR,%02d,%02d\x0d",
        "33, SYNTAX ERROR,%02d,%02d\x0d",
        "34, SYNTAX ERROR,%02d,%02d\x0d",
        "60, WRITE FILE OPEN,%02d,%02d\x0d",
        "61, FILE NOT OPEN,%02d,%02d\x0d",
        "62, FILE NOT FOUND,%02d,%02d\x0d",
        "63, FILE EXISTS,%02d,%02d\x0d",
        "64, FILE TYPE MISMATCH,%02d,%02d\x0d",
        "65, NO BLOCK,%02d,%02d\x0d",
        "66, ILLEGAL TRACK OR SECTOR,%02d,%02d\x0d",
        "70, NO CHANNEL,%02d,%02d\x0d",
        "71, DIR ERROR,%02d,%02d\x0d",
        "72, DISK FULL,%02d,%02d\x0d",
        "73, CBM DOS V2.6 1541,%02d,%02d\x0d",
        "74, DRIVE NOT READY,%02d,%02d\x0d"
};

void Drive::set_error(int error, int track, int sector)
{
        // Write error message to buffer
        sprintf(error_buf, Errors_1541[error], track, sector);
        error_ptr = error_buf;
        error_len = strlen(error_buf);
        current_error = error;

        // Set drive condition
        if (error != ERR_OK && error != ERR_SCRATCHED)
                if (error == ERR_STARTUP)
                        LED = DRVLED_OFF;
                else
                        LED = DRVLED_ERROR;
        else if (LED == DRVLED_ERROR)
                LED = DRVLED_OFF;
        the_iec->UpdateLEDs();
}


/*
 *  Parse file name, determine access mode and file type
 */

void Drive::parse_file_name(const uint8 *src, int src_len, uint8 *dest, int &dest_len, int &mode, int &type, int &rec_len, bool convert_charset)
{
        // If the string contains a ':', the file name starts after that
        const uint8 *p = (const uint8 *)memchr(src, ':', src_len);
        if (p) {
                p++;
                src_len -= p - src;
        } else
                p = src;

        // Transfer file name upto ','
        dest_len = 0;
        uint8 *q = dest;
        while (*p != ',' && src_len-- > 0) {
                if (convert_charset)
                        *q++ = petscii2ascii(*p++);
                else
                        *q++ = *p++;
                dest_len++;
        }
        *q++ = 0;

        // Strip trailing CRs
        while (dest_len > 0 && dest[dest_len - 1] == 0x0d)
                dest[--dest_len] = 0;

        // Look for mode and type parameters separated by ','
        p++; src_len--;
        while (src_len > 0) {
                switch (*p) {
                        case 'D':
                                type = FTYPE_DEL;
                                break;
                        case 'S':
                                type = FTYPE_SEQ;
                                break;
                        case 'P':
                                type = FTYPE_PRG;
                                break;
                        case 'U':
                                type = FTYPE_USR;
                                break;
                        case 'L':
                                type = FTYPE_REL;
                                while (*p != ',' && src_len-- > 0) p++;
                                p++; src_len--;
                                rec_len = *p++; src_len--;
                                if (src_len < 0)
                                        rec_len = 0;
                                break;
                        case 'R':
                                mode = FMODE_READ;
                                break;
                        case 'W':
                                mode = FMODE_WRITE;
                                break;
                        case 'A':
                                mode = FMODE_APPEND;
                                break;
                        case 'M':
                                mode = FMODE_M;
                                break;
                }

                // Skip to ','
                while (*p != ',' && src_len-- > 0) p++;
                p++; src_len--;
        }
}


/*
 *  Execute DOS command (parse command and call appropriate routine)
 */

static void parse_block_cmd_args(const uint8 *p, int &arg1, int &arg2, int &arg3, int &arg4)
{
        arg1 = arg2 = arg3 = arg4 = 0;

        while (*p == ' ' || *p == 0x1d || *p == ',') p++;
        while (*p >= '0' && *p < '@')
                arg1 = arg1 * 10 + (*p++ & 0x0f);

        while (*p == ' ' || *p == 0x1d || *p == ',') p++;
        while (*p >= '0' && *p < '@')
                arg2 = arg2 * 10 + (*p++ & 0x0f);

        while (*p == ' ' || *p == 0x1d || *p == ',') p++;
        while (*p >= '0' && *p < '@')
                arg3 = arg3 * 10 + (*p++ & 0x0f);

        while (*p == ' ' || *p == 0x1d || *p == ',') p++;
        while (*p >= '0' && *p < '@')
                arg4 = arg4 * 10 + (*p++ & 0x0f);
}

void Drive::execute_cmd(const uint8 *cmd, int cmd_len)
{
        // Strip trailing CRs
        while (cmd_len > 0 && cmd[cmd_len - 1] == 0x0d)
                cmd_len--;

        // Find token delimiters
        const uint8 *colon = (const uint8 *)memchr(cmd, ':', cmd_len);
        const uint8 *equal = colon ? (const uint8 *)memchr(colon, '=', cmd_len - (colon - cmd)) : NULL;
        const uint8 *comma = (const uint8 *)memchr(cmd, ',', cmd_len);
        const uint8 *minus = (const uint8 *)memchr(cmd, '-', cmd_len);

        // Parse command name
        set_error(ERR_OK);
        switch (cmd[0]) {
                case 'B':       // Block/buffer
                        if (!minus)
                                set_error(ERR_SYNTAX31);
                        else {
                                // Parse arguments (up to 4 decimal numbers separated by
                                // space, cursor right or comma)
                                const uint8 *p = colon ? colon + 1 : cmd + 3;
                                int arg1, arg2, arg3, arg4;
                                parse_block_cmd_args(p, arg1, arg2, arg3, arg4);

                                // Switch on command
                                switch (minus[1]) {
                                        case 'R':
                                                block_read_cmd(arg1, arg3, arg4);
                                                break;
                                        case 'W':
                                                block_write_cmd(arg1, arg3, arg4);
                                                break;
                                        case 'E':
                                                block_execute_cmd(arg1, arg3, arg4);
                                                break;
                                        case 'A':
                                                block_allocate_cmd(arg2, arg3);
                                                break;
                                        case 'F':
                                                block_free_cmd(arg2, arg3);
                                                break;
                                        case 'P':
                                                buffer_pointer_cmd(arg1, arg2);
                                                break;
                                        default:
                                                set_error(ERR_SYNTAX31);
                                                break;
                                }
                        }
                        break;

                case 'M':       // Memory
                        if (cmd[1] != '-')
                                set_error(ERR_SYNTAX31);
                        else {
                                // Read parameters
                                uint16 adr = uint8(cmd[3]) | (uint8(cmd[4]) << 8);
                                uint8 len = uint8(cmd[5]);

                                // Switch on command
                                switch (cmd[2]) {
                                        case 'R':
                                                mem_read_cmd(adr, (cmd_len < 6) ? 1 : len);
                                                break;
                                        case 'W':
                                                mem_write_cmd(adr, len, (uint8 *)cmd + 6);
                                                break;
                                        case 'E':
                                                mem_execute_cmd(adr);
                                                break;
                                        default:
                                                set_error(ERR_SYNTAX31);
                                                break;
                                }
                        }
                        break;

                case 'C':       // Copy
                        if (!colon)
                                set_error(ERR_SYNTAX31);
                        else if (!equal || memchr(cmd, '*', cmd_len) || memchr(cmd, '?', cmd_len) || (comma && comma < equal))
                                set_error(ERR_SYNTAX30);
                        else
                                copy_cmd(colon + 1, equal - colon - 1, equal + 1, cmd_len - (equal + 1 - cmd));
                        break;

                case 'R':       // Rename
                        if (!colon)
                                set_error(ERR_SYNTAX34);
                        else if (!equal || comma || memchr(cmd, '*', cmd_len) || memchr(cmd, '?', cmd_len))
                                set_error(ERR_SYNTAX30);
                        else
                                rename_cmd(colon + 1, equal - colon - 1, equal + 1, cmd_len - (equal + 1 - cmd));
                        break;

                case 'S':       // Scratch
                        if (!colon)
                                set_error(ERR_SYNTAX34);
                        else
                                scratch_cmd(colon + 1, cmd_len - (colon + 1 - cmd));
                        break;

                case 'P':       // Position
                        position_cmd(cmd + 1, cmd_len - 1);
                        break;

                case 'I':       // Initialize
                        initialize_cmd();
                        break;

                case 'N':       // New (format)
                        if (!colon)
                                set_error(ERR_SYNTAX34);
                        else
                                new_cmd(colon + 1, comma ? (comma - colon - 1) : cmd_len - (colon + 1 - cmd), comma);
                        break;

                case 'V':       // Validate
                        validate_cmd();
                        break;

                case 'U':       // User
                        if (cmd[1] == '0')
                                break;
                        switch (cmd[1] & 0x0f) {
                                case 1: {       // U1/UA: Read block
                                        const uint8 *p = colon ? colon + 1 : cmd + 2;
                                        int arg1, arg2, arg3, arg4;
                                        parse_block_cmd_args(p, arg1, arg2, arg3, arg4);
                                        block_read_cmd(arg1, arg3, arg4, true);
                                        break;
                                }
                                case 2: {       // U2/UB: Write block
                                        const uint8 *p = colon ? colon + 1 : cmd + 2;
                                        int arg1, arg2, arg3, arg4;
                                        parse_block_cmd_args(p, arg1, arg2, arg3, arg4);
                                        block_write_cmd(arg1, arg3, arg4, true);
                                        break;
                                }
                                case 9:         // U9/UI: C64/VC20 mode switch
                                        if (cmd[2] != '+' && cmd[2] != '-')
                                                Reset();
                                        break;
                                case 10:        // U:/UJ: Reset
                                        Reset();
                                        break;
                                default:
                                        set_error(ERR_UNIMPLEMENTED);
                                        break;
                        }
                        break;

                default:
                        set_error(ERR_SYNTAX31);
                        break;
        }
}

// BLOCK-READ:channel,0,track,sector
void Drive::block_read_cmd(int channel, int track, int sector, bool user_cmd)
{
        set_error(ERR_UNIMPLEMENTED);
}

// BLOCK-WRITE:channel,0,track,sector
void Drive::block_write_cmd(int channel, int track, int sector, bool user_cmd)
{
        set_error(ERR_UNIMPLEMENTED);
}

// BLOCK-EXECUTE:channel,0,track,sector
void Drive::block_execute_cmd(int channel, int track, int sector)
{
        set_error(ERR_UNIMPLEMENTED);
}

// BLOCK-ALLOCATE:0,track,sector
void Drive::block_allocate_cmd(int track, int sector)
{
        set_error(ERR_UNIMPLEMENTED);
}

// BLOCK-FREE:0,track,sector
void Drive::block_free_cmd(int track, int sector)
{
        set_error(ERR_UNIMPLEMENTED);
}

// BUFFER-POINTER:channel,pos
void Drive::buffer_pointer_cmd(int channel, int pos)
{
        set_error(ERR_UNIMPLEMENTED);
}

// M-R<adr low><adr high>[<number>]
void Drive::mem_read_cmd(uint16 adr, uint8 len)
{
        unsupp_cmd();
        error_ptr = error_buf;
        error_buf[0] = 0;
        error_len = 0;
        set_error(ERR_OK);
}

// M-W<adr low><adr high><number><data...>
void Drive::mem_write_cmd(uint16 adr, uint8 len, uint8 *p)
{
        set_error(ERR_UNIMPLEMENTED);
}

// M-E<adr low><adr high>
void Drive::mem_execute_cmd(uint16 adr)
{
        set_error(ERR_UNIMPLEMENTED);
}

//   COPY:new=file1,file2,...
//        ^   ^
// new_file   old_files
void Drive::copy_cmd(const uint8 *new_file, int new_file_len, const uint8 *old_files, int old_files_len)
{
        set_error(ERR_UNIMPLEMENTED);
}

// RENAME:new=old
//        ^   ^
// new_file   old_file
void Drive::rename_cmd(const uint8 *new_file, int new_file_len, const uint8 *old_file, int old_file_len)
{
        set_error(ERR_UNIMPLEMENTED);
}

// SCRATCH:file1,file2,...
//         ^
//         files
void Drive::scratch_cmd(const uint8 *files, int files_len)
{
        set_error(ERR_UNIMPLEMENTED);
}

// P<channel><record low><record high><byte>
//  ^
//  cmd
void Drive::position_cmd(const uint8 *cmd, int cmd_len)
{
        set_error(ERR_UNIMPLEMENTED);
}

// INITIALIZE
void Drive::initialize_cmd(void)
{
        set_error(ERR_UNIMPLEMENTED);
}

// NEW:name,id
//     ^   ^
//  name   comma (or NULL)
void Drive::new_cmd(const uint8 *name, int name_len, const uint8 *comma)
{
        set_error(ERR_UNIMPLEMENTED);
}

// VALIDATE
void Drive::validate_cmd(void)
{
        set_error(ERR_UNIMPLEMENTED);
}


/*
 *  Notice user of unsupported drive command
 */

void Drive::unsupp_cmd(void)
{
}


/*
 *  Convert PETSCII<->ASCII
 */

uint8 ascii2petscii(char c)
{
        if ((c >= 'A') && (c <= 'Z') || (c >= 'a') && (c <= 'z'))
                return c ^ 0x20;
        return c;
}

void ascii2petscii(uint8 *dest, const char *src, int n)
{
        while (n-- && (*dest++ = ascii2petscii(*src++))) ;
}

char petscii2ascii(uint8 c)
{
        if ((c >= 'A') && (c <= 'Z') || (c >= 'a') && (c <= 'z'))
                return c ^ 0x20;
        if ((c >= 0xc1) && (c <= 0xda))
                return c ^ 0x80;
        return c;
}

void petscii2ascii(char *dest, const uint8 *src, int n)
{
        while (n-- && (*dest++ = petscii2ascii(*src++))) ;
}


/*
 *  Check whether file is a mountable disk image or archive file, return type
 */

bool IsMountableFile(const char *path, int &type)
{
        // Read header and determine file size
        uint8 header[64];
        memset(header, 0, sizeof(header));
        FILE *f = fopen(path, "rb");
        if (f == NULL)
                return false;
        fseek(f, 0, SEEK_END);
        long size = ftell(f);
        fseek(f, 0, SEEK_SET);
        fread(header, 1, sizeof(header), f);
        fclose(f);

        if (IsImageFile(path, header, size)) {
                type = FILE_IMAGE;
                return true;
        } else if (IsArchFile(path, header, size)) {
                type = FILE_ARCH;
                return true;
        } else
                return false;
}


/*
 *  Read directory of mountable disk image or archive file into c64_dir_entry vector,
 *  returns false on error
 */

bool ReadDirectory(const char *path, int type, vector<c64_dir_entry> &vec)
{
        vec.clear();
        switch (type) {
                case FILE_IMAGE:
                        return ReadImageDirectory(path, vec);
                case FILE_ARCH:
                        return ReadArchDirectory(path, vec);
                default:
                        return false;
        }
}
Revision:	1.9
Committed:	2005-06-27T19:55:48Z (18 years, 10 months ago) by cebix
Branch:	MAIN
CVS Tags:	VERSION_4_2, HEAD
Changes since 1.8:	+1 -1 lines
Log Message:	updated copyright dates