mirror of
https://github.com/Oibaf66/frodo-wii.git
synced 2024-11-29 23:14:23 +01:00
735 lines
13 KiB
C++
735 lines
13 KiB
C++
/*
|
|
* 1541fs.cpp - 1541 emulation in host file system
|
|
*
|
|
* Frodo (C) 1994-1997,2002 Christian Bauer
|
|
|
|
*
|
|
* Notes:
|
|
* ------
|
|
*
|
|
* - If the directory is opened (file name "$"), a temporary file
|
|
* with the structure of a 1541 directory file is created and
|
|
* opened. It can then be accessed in the same way as all other
|
|
* files.
|
|
*
|
|
* Incompatibilities:
|
|
* ------------------
|
|
*
|
|
* - No "raw" directory reading
|
|
* - No relative/sequential/user files
|
|
* - Only "I" and "UJ" commands implemented
|
|
*/
|
|
|
|
#include "sysdeps.h"
|
|
|
|
#include "1541fs.h"
|
|
#include "IEC.h"
|
|
#include "main.h"
|
|
#include "Prefs.h"
|
|
|
|
#ifdef __riscos__
|
|
#include "ROlib.h"
|
|
#endif
|
|
|
|
|
|
// Access modes
|
|
enum {
|
|
FMODE_READ, FMODE_WRITE, FMODE_APPEND
|
|
};
|
|
|
|
// File types
|
|
enum {
|
|
FTYPE_PRG, FTYPE_SEQ
|
|
};
|
|
|
|
// Prototypes
|
|
static bool match(char *p, char *n);
|
|
|
|
|
|
/*
|
|
* Constructor: Prepare emulation
|
|
*/
|
|
|
|
FSDrive::FSDrive(IEC *iec, char *path) : Drive(iec)
|
|
{
|
|
strcpy(orig_dir_path, path);
|
|
dir_path[0] = 0;
|
|
|
|
if (change_dir(orig_dir_path)) {
|
|
for (int i=0; i<16; i++)
|
|
file[i] = NULL;
|
|
|
|
Reset();
|
|
|
|
Ready = true;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Destructor
|
|
*/
|
|
|
|
FSDrive::~FSDrive()
|
|
{
|
|
if (Ready) {
|
|
close_all_channels();
|
|
Ready = false;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Change emulation directory
|
|
*/
|
|
|
|
bool FSDrive::change_dir(char *dirpath)
|
|
{
|
|
#ifndef __riscos__
|
|
DIR *dir;
|
|
|
|
if ((dir = opendir(dirpath)) != NULL) {
|
|
closedir(dir);
|
|
strcpy(dir_path, dirpath);
|
|
strncpy(dir_title, dir_path, 16);
|
|
return true;
|
|
} else
|
|
return false;
|
|
#else
|
|
int Info[4];
|
|
|
|
if ((ReadCatalogueInfo(dirpath,Info) & 2) != 0) // Directory or image file
|
|
{
|
|
strcpy(dir_path, dirpath);
|
|
strncpy(dir_title, dir_path, 16);
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
|
|
/*
|
|
* Open channel
|
|
*/
|
|
|
|
uint8 FSDrive::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;
|
|
}
|
|
|
|
// Close previous file if still open
|
|
if (file[channel]) {
|
|
fclose(file[channel]);
|
|
file[channel] = NULL;
|
|
}
|
|
|
|
if (filename[0] == '$')
|
|
return open_directory(channel, filename+1);
|
|
|
|
if (filename[0] == '#') {
|
|
set_error(ERR_NOCHANNEL);
|
|
return ST_OK;
|
|
}
|
|
|
|
return open_file(channel, filename);
|
|
}
|
|
|
|
|
|
/*
|
|
* Open file
|
|
*/
|
|
|
|
uint8 FSDrive::open_file(int channel, char *filename)
|
|
{
|
|
char plainname[NAMEBUF_LENGTH];
|
|
int filemode = FMODE_READ;
|
|
int filetype = FTYPE_PRG;
|
|
bool wildflag = false;
|
|
char *mode = "rb";
|
|
|
|
convert_filename(filename, plainname, &filemode, &filetype, &wildflag);
|
|
|
|
// 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;
|
|
}
|
|
|
|
// Wildcards are only allowed on reading
|
|
if (wildflag) {
|
|
if (filemode != FMODE_READ) {
|
|
set_error(ERR_SYNTAX33);
|
|
return ST_OK;
|
|
}
|
|
find_first_file(plainname);
|
|
}
|
|
|
|
// Select fopen() mode according to file mode
|
|
switch (filemode) {
|
|
case FMODE_READ:
|
|
mode = "rb";
|
|
break;
|
|
case FMODE_WRITE:
|
|
mode = "wb";
|
|
break;
|
|
case FMODE_APPEND:
|
|
mode = "ab";
|
|
break;
|
|
}
|
|
|
|
// Open file
|
|
#ifndef __riscos__
|
|
if (chdir(dir_path))
|
|
set_error(ERR_NOTREADY);
|
|
else if ((file[channel] = fopen(plainname, mode)) != NULL) {
|
|
if (filemode == FMODE_READ) // Read and buffer first byte
|
|
read_char[channel] = fgetc(file[channel]);
|
|
} else
|
|
set_error(ERR_FILENOTFOUND);
|
|
chdir(AppDirPath);
|
|
#else
|
|
{
|
|
char fullname[NAMEBUF_LENGTH];
|
|
|
|
// On RISC OS make a full filename
|
|
sprintf(fullname,"%s.%s",dir_path,plainname);
|
|
if ((file[channel] = fopen(fullname, mode)) != NULL)
|
|
{
|
|
if (filemode == FMODE_READ)
|
|
{
|
|
read_char[channel] = fgetc(file[channel]);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
set_error(ERR_FILENOTFOUND);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
return ST_OK;
|
|
}
|
|
|
|
|
|
/*
|
|
* Analyze file name, get access mode and type
|
|
*/
|
|
|
|
void FSDrive::convert_filename(char *srcname, char *destname, int *filemode, int *filetype, bool *wildflag)
|
|
{
|
|
char *p, *q;
|
|
int i;
|
|
|
|
// Search for ':', p points to first character after ':'
|
|
if ((p = strchr(srcname, ':')) != NULL)
|
|
p++;
|
|
else
|
|
p = srcname;
|
|
|
|
// Convert char set of the remaining string -> destname
|
|
q = destname;
|
|
for (i=0; i<NAMEBUF_LENGTH && (*q++ = conv_from_64(*p++, true)); i++) ;
|
|
|
|
// 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 'r':
|
|
*filemode = FMODE_READ;
|
|
break;
|
|
case 'w':
|
|
*filemode = FMODE_WRITE;
|
|
break;
|
|
case 'a':
|
|
*filemode = FMODE_APPEND;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Search for wildcards
|
|
*wildflag = (strchr(destname, '?') != NULL) || (strchr(destname, '*') != NULL);
|
|
}
|
|
|
|
|
|
/*
|
|
* Find first file matching wildcard pattern and get its real name
|
|
*/
|
|
|
|
// Return true if name 'n' matches pattern 'p'
|
|
static bool match(char *p, char *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;
|
|
}
|
|
|
|
void FSDrive::find_first_file(char *name)
|
|
{
|
|
#ifndef __riscos__
|
|
DIR *dir;
|
|
struct dirent *de;
|
|
|
|
// Open directory for reading and skip '.' and '..'
|
|
if ((dir = opendir(dir_path)) == NULL)
|
|
return;
|
|
de = readdir(dir);
|
|
while (de && (0 == strcmp(".", de->d_name) || 0 == strcmp("..", de->d_name)))
|
|
de = readdir(dir);
|
|
|
|
while (de) {
|
|
|
|
// Match found? Then copy real file name
|
|
if (match(name, de->d_name)) {
|
|
strncpy(name, de->d_name, NAMEBUF_LENGTH);
|
|
closedir(dir);
|
|
return;
|
|
}
|
|
|
|
// Get next directory entry
|
|
de = readdir(dir);
|
|
}
|
|
|
|
closedir(dir);
|
|
#else
|
|
dir_env de;
|
|
char Buffer[NAMEBUF_LENGTH];
|
|
|
|
de.offset = 0; de.buffsize = NAMEBUF_LENGTH; de.match = name;
|
|
do
|
|
{
|
|
de.readno = 1;
|
|
if (ReadDirName(dir_path,Buffer,&de) != NULL) {de.offset = -1;}
|
|
else if (de.offset != -1)
|
|
{
|
|
if (match(name,Buffer))
|
|
{
|
|
strncpy(name, Buffer, NAMEBUF_LENGTH);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
while (de.offset != -1);
|
|
#endif
|
|
}
|
|
|
|
|
|
/*
|
|
* Open directory, create temporary file
|
|
*/
|
|
|
|
uint8 FSDrive::open_directory(int channel, char *filename)
|
|
{
|
|
char buf[] = "\001\004\001\001\0\0\022\042 \042 00 2A";
|
|
char str[NAMEBUF_LENGTH];
|
|
char pattern[NAMEBUF_LENGTH];
|
|
char *p, *q;
|
|
int i;
|
|
int filemode;
|
|
int filetype;
|
|
bool wildflag;
|
|
|
|
#ifndef __riscos__
|
|
DIR *dir;
|
|
struct dirent *de;
|
|
struct stat statbuf;
|
|
|
|
// Special treatment for "$0"
|
|
if (filename[0] == '0' && filename[1] == 0)
|
|
filename += 1;
|
|
|
|
// Convert filename ('$' already stripped), filemode/type are ignored
|
|
convert_filename(filename, pattern, &filemode, &filetype, &wildflag);
|
|
|
|
// Open directory for reading and skip '.' and '..'
|
|
if ((dir = opendir(dir_path)) == NULL) {
|
|
set_error(ERR_NOTREADY);
|
|
return ST_OK;
|
|
}
|
|
de = readdir(dir);
|
|
while (de && (0 == strcmp(".", de->d_name) || 0 == strcmp("..", de->d_name)))
|
|
de = readdir(dir);
|
|
|
|
// Create temporary file
|
|
if ((file[channel] = tmpfile()) == NULL) {
|
|
closedir(dir);
|
|
return ST_OK;
|
|
}
|
|
|
|
// Create directory title
|
|
p = &buf[8];
|
|
for (i=0; i<16 && dir_title[i]; i++)
|
|
*p++ = conv_to_64(dir_title[i], false);
|
|
fwrite(buf, 1, 32, file[channel]);
|
|
|
|
// Create and write one line for every directory entry
|
|
while (de) {
|
|
|
|
// Include only files matching the pattern
|
|
if (match(pattern, de->d_name)) {
|
|
|
|
// Get file statistics
|
|
chdir(dir_path);
|
|
stat(de->d_name, &statbuf);
|
|
chdir(AppDirPath);
|
|
|
|
// Clear line with spaces and terminate with null byte
|
|
memset(buf, ' ', 31);
|
|
buf[31] = 0;
|
|
|
|
p = buf;
|
|
*p++ = 0x01; // Dummy line link
|
|
*p++ = 0x01;
|
|
|
|
// Calculate size in blocks (254 bytes each)
|
|
i = (statbuf.st_size + 254) / 254;
|
|
*p++ = i & 0xff;
|
|
*p++ = (i >> 8) & 0xff;
|
|
|
|
p++;
|
|
if (i < 10) p++; // Less than 10: add one space
|
|
if (i < 100) p++; // Less than 100: add another space
|
|
|
|
// Convert and insert file name
|
|
strcpy(str, de->d_name);
|
|
*p++ = '\"';
|
|
q = p;
|
|
for (i=0; i<16 && str[i]; i++)
|
|
*q++ = conv_to_64(str[i], true);
|
|
*q++ = '\"';
|
|
p += 18;
|
|
|
|
// File type
|
|
if (S_ISDIR(statbuf.st_mode)) {
|
|
*p++ = 'D';
|
|
*p++ = 'I';
|
|
*p++ = 'R';
|
|
} else {
|
|
*p++ = 'P';
|
|
*p++ = 'R';
|
|
*p++ = 'G';
|
|
}
|
|
|
|
// Write line
|
|
fwrite(buf, 1, 32, file[channel]);
|
|
}
|
|
|
|
// Get next directory entry
|
|
de = readdir(dir);
|
|
}
|
|
#else
|
|
dir_full_info di;
|
|
dir_env de;
|
|
|
|
// Much of this is very similar to the original
|
|
if ((filename[0] == '0') && (filename[1] == 0)) {filename++;}
|
|
// Concatenate dir_path and pattern in buffer pattern ==> read subdirs!
|
|
strcpy(pattern,dir_path);
|
|
convert_filename(filename, pattern + strlen(pattern), &filemode, &filetype, &wildflag);
|
|
|
|
// We don't use tmpfile() -- problems involved!
|
|
DeleteFile(RO_TEMPFILE); // first delete it, if it exists
|
|
if ((file[channel] = fopen(RO_TEMPFILE,"wb+")) == NULL)
|
|
{
|
|
return(ST_OK);
|
|
}
|
|
de.offset = 0; de.buffsize = NAMEBUF_LENGTH; de.match = filename;
|
|
|
|
// Create directory title - copied from above
|
|
p = &buf[8];
|
|
for (i=0; i<16 && dir_title[i]; i++)
|
|
*p++ = conv_to_64(dir_title[i], false);
|
|
fwrite(buf, 1, 32, file[channel]);
|
|
|
|
do
|
|
{
|
|
de.readno = 1;
|
|
if (ReadDirNameInfo(pattern,&di,&de) != NULL) {de.offset = -1;}
|
|
else if (de.offset != -1) // don't have to check for match here
|
|
{
|
|
memset(buf,' ',31); buf[31] = 0; // most of this: see above
|
|
p = buf; *p++ = 0x01; *p++ = 0x01;
|
|
i = (di.length + 254) / 254; *p++ = i & 0xff; *p++ = (i>>8) & 0xff;
|
|
p++;
|
|
if (i < 10) {*p++ = ' ';}
|
|
if (i < 100) {*p++ = ' ';}
|
|
strcpy(str, di.name);
|
|
*p++ = '\"'; q = p;
|
|
for (i=0; (i<16 && str[i]); i++)
|
|
{
|
|
*q++ = conv_to_64(str[i], true);
|
|
}
|
|
*q++ = '\"'; p += 18;
|
|
if ((di.otype & 2) == 0)
|
|
{
|
|
*p++ = 'P'; *p++ = 'R'; *p++ = 'G';
|
|
}
|
|
else
|
|
{
|
|
*p++ = 'D'; *p++ = 'I'; *p++ = 'R';
|
|
}
|
|
fwrite(buf, 1, 32, file[channel]);
|
|
}
|
|
}
|
|
while (de.offset != -1);
|
|
#endif
|
|
|
|
// Final line
|
|
fwrite("\001\001\0\0BLOCKS FREE. \0\0", 1, 32, file[channel]);
|
|
|
|
// Rewind file for reading and read first byte
|
|
rewind(file[channel]);
|
|
read_char[channel] = fgetc(file[channel]);
|
|
|
|
#ifndef __riscos
|
|
// Close directory
|
|
closedir(dir);
|
|
#endif
|
|
|
|
return ST_OK;
|
|
}
|
|
|
|
|
|
/*
|
|
* Close channel
|
|
*/
|
|
|
|
uint8 FSDrive::Close(int channel)
|
|
{
|
|
if (channel == 15) {
|
|
close_all_channels();
|
|
return ST_OK;
|
|
}
|
|
|
|
if (file[channel]) {
|
|
fclose(file[channel]);
|
|
file[channel] = NULL;
|
|
}
|
|
|
|
return ST_OK;
|
|
}
|
|
|
|
|
|
/*
|
|
* Close all channels
|
|
*/
|
|
|
|
void FSDrive::close_all_channels(void)
|
|
{
|
|
for (int i=0; i<15; i++)
|
|
Close(i);
|
|
|
|
cmd_len = 0;
|
|
}
|
|
|
|
|
|
/*
|
|
* Read from channel
|
|
*/
|
|
|
|
uint8 FSDrive::Read(int channel, uint8 *byte)
|
|
{
|
|
int c;
|
|
|
|
// Channel 15: Error channel
|
|
if (channel == 15) {
|
|
*byte = *error_ptr++;
|
|
|
|
if (*byte != '\r')
|
|
return ST_OK;
|
|
else { // End of message
|
|
set_error(ERR_OK);
|
|
return ST_EOF;
|
|
}
|
|
}
|
|
|
|
if (!file[channel]) return ST_READ_TIMEOUT;
|
|
|
|
// Read one byte
|
|
*byte = read_char[channel];
|
|
c = fgetc(file[channel]);
|
|
if (c == EOF)
|
|
return ST_EOF;
|
|
else {
|
|
read_char[channel] = c;
|
|
return ST_OK;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Write to channel
|
|
*/
|
|
|
|
uint8 FSDrive::Write(int channel, uint8 byte, bool eoi)
|
|
{
|
|
// Channel 15: Collect chars and execute command on EOI
|
|
if (channel == 15) {
|
|
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;
|
|
}
|
|
|
|
if (!file[channel]) {
|
|
set_error(ERR_FILENOTOPEN);
|
|
return ST_TIMEOUT;
|
|
}
|
|
|
|
if (fputc(byte, file[channel]) == EOF) {
|
|
set_error(ERR_WRITEERROR);
|
|
return ST_TIMEOUT;
|
|
}
|
|
|
|
return ST_OK;
|
|
}
|
|
|
|
|
|
/*
|
|
* Execute command string
|
|
*/
|
|
|
|
void FSDrive::execute_command(char *command)
|
|
{
|
|
switch (command[0]) {
|
|
case 'I':
|
|
close_all_channels();
|
|
set_error(ERR_OK);
|
|
break;
|
|
|
|
case 'U':
|
|
if ((command[1] & 0x0f) == 0x0a) {
|
|
Reset();
|
|
} else
|
|
set_error(ERR_SYNTAX30);
|
|
break;
|
|
|
|
case 'G':
|
|
if (command[1] != ':')
|
|
set_error(ERR_SYNTAX30);
|
|
else
|
|
chdir_cmd(&command[2]);
|
|
break;
|
|
|
|
default:
|
|
set_error(ERR_SYNTAX30);
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Execute 'G' command
|
|
*/
|
|
|
|
void FSDrive::chdir_cmd(char *dirpath)
|
|
{
|
|
char str[NAMEBUF_LENGTH];
|
|
char *p = str;
|
|
|
|
close_all_channels();
|
|
|
|
// G:. resets the directory path to its original setting
|
|
if (dirpath[0] == '.' && dirpath[1] == 0) {
|
|
change_dir(orig_dir_path);
|
|
} else {
|
|
|
|
// Convert directory name
|
|
for (int i=0; i<NAMEBUF_LENGTH && (*p++ = conv_from_64(*dirpath++, false)); i++) ;
|
|
|
|
if (!change_dir(str))
|
|
set_error(ERR_NOTREADY);
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Reset drive
|
|
*/
|
|
|
|
void FSDrive::Reset(void)
|
|
{
|
|
close_all_channels();
|
|
cmd_len = 0;
|
|
set_error(ERR_STARTUP);
|
|
}
|
|
|
|
|
|
/*
|
|
* Conversion PETSCII->ASCII
|
|
*/
|
|
|
|
uint8 FSDrive::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)
|
|
#ifdef __riscos__
|
|
return '.'; // directory separator is '.' in RO
|
|
if (c == '.') {return('_');} // convert dot to underscore
|
|
#else
|
|
return '\\';
|
|
#endif
|
|
return c;
|
|
}
|
|
|
|
|
|
/*
|
|
* Conversion ASCII->PETSCII
|
|
*/
|
|
|
|
uint8 FSDrive::conv_to_64(uint8 c, bool map_slash)
|
|
{
|
|
if ((c >= 'A') && (c <= 'Z') || (c >= 'a') && (c <= 'z'))
|
|
return c ^ 0x20;
|
|
#ifdef __riscos__
|
|
if ((c == '.') && map_slash && ThePrefs.MapSlash)
|
|
#else
|
|
if ((c == '\\') && map_slash && ThePrefs.MapSlash)
|
|
#endif
|
|
return '/';
|
|
#ifdef __riscos__
|
|
if (c == '_') {return('.');} // convert underscore to dot
|
|
#endif
|
|
return c;
|
|
}
|