Frodo4/Src/1541fs.cpp

/*
 *  1541fs.cpp - 1541 emulation in host file system
 *
 *  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
 */

/*
 * 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;
}
Revision:	1.2
Committed:	2003-07-01T17:51:17Z (21 years, 4 months ago) by cebix
Branch:	MAIN
Changes since 1.1:	+1 -1 lines
Log Message:	updated copyright date
#	Content
1	/*
2	* 1541fs.cpp - 1541 emulation in host file system
3	*
4	* Frodo (C) 1994-1997,2002-2003 Christian Bauer
5	*
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	* Notes:
23	* ------
24	*
25	* - If the directory is opened (file name "$"), a temporary file
26	* with the structure of a 1541 directory file is created and
27	* opened. It can then be accessed in the same way as all other
28	* files.
29	*
30	* Incompatibilities:
31	* ------------------
32	*
33	* - No "raw" directory reading
34	* - No relative/sequential/user files
35	* - Only "I" and "UJ" commands implemented
36	*/
37
38	#include "sysdeps.h"
39
40	#include "1541fs.h"
41	#include "IEC.h"
42	#include "main.h"
43	#include "Prefs.h"
44
45	#ifdef __riscos__
46	#include "ROlib.h"
47	#endif
48
49
50	// Access modes
51	enum {
52	FMODE_READ, FMODE_WRITE, FMODE_APPEND
53	};
54
55	// File types
56	enum {
57	FTYPE_PRG, FTYPE_SEQ
58	};
59
60	// Prototypes
61	static bool match(char p, char n);
62
63
64	/*
65	* Constructor: Prepare emulation
66	*/
67
68	FSDrive::FSDrive(IEC iec, char path) : Drive(iec)
69	{
70	strcpy(orig_dir_path, path);
71	dir_path[0] = 0;
72
73	if (change_dir(orig_dir_path)) {
74	for (int i=0; i<16; i++)
75	file[i] = NULL;
76
77	Reset();
78
79	Ready = true;
80	}
81	}
82
83
84	/*
85	* Destructor
86	*/
87
88	FSDrive::~FSDrive()
89	{
90	if (Ready) {
91	close_all_channels();
92	Ready = false;
93	}
94	}
95
96
97	/*
98	* Change emulation directory
99	*/
100
101	bool FSDrive::change_dir(char *dirpath)
102	{
103	#ifndef __riscos__
104	DIR *dir;
105
106	if ((dir = opendir(dirpath)) != NULL) {
107	closedir(dir);
108	strcpy(dir_path, dirpath);
109	strncpy(dir_title, dir_path, 16);
110	return true;
111	} else
112	return false;
113	#else
114	int Info[4];
115
116	if ((ReadCatalogueInfo(dirpath,Info) & 2) != 0) // Directory or image file
117	{
118	strcpy(dir_path, dirpath);
119	strncpy(dir_title, dir_path, 16);
120	return true;
121	}
122	else
123	{
124	return false;
125	}
126	#endif
127	}
128
129
130	/*
131	* Open channel
132	*/
133
134	uint8 FSDrive::Open(int channel, char *filename)
135	{
136	set_error(ERR_OK);
137
138	// Channel 15: Execute file name as command
139	if (channel == 15) {
140	execute_command(filename);
141	return ST_OK;
142	}
143
144	// Close previous file if still open
145	if (file[channel]) {
146	fclose(file[channel]);
147	file[channel] = NULL;
148	}
149
150	if (filename[0] == '$')
151	return open_directory(channel, filename+1);
152
153	if (filename[0] == '#') {
154	set_error(ERR_NOCHANNEL);
155	return ST_OK;
156	}
157
158	return open_file(channel, filename);
159	}
160
161
162	/*
163	* Open file
164	*/
165
166	uint8 FSDrive::open_file(int channel, char *filename)
167	{
168	char plainname[NAMEBUF_LENGTH];
169	int filemode = FMODE_READ;
170	int filetype = FTYPE_PRG;
171	bool wildflag = false;
172	char *mode = "rb";
173
174	convert_filename(filename, plainname, &filemode, &filetype, &wildflag);
175
176	// Channel 0 is READ PRG, channel 1 is WRITE PRG
177	if (!channel) {
178	filemode = FMODE_READ;
179	filetype = FTYPE_PRG;
180	}
181	if (channel == 1) {
182	filemode = FMODE_WRITE;
183	filetype = FTYPE_PRG;
184	}
185
186	// Wildcards are only allowed on reading
187	if (wildflag) {
188	if (filemode != FMODE_READ) {
189	set_error(ERR_SYNTAX33);
190	return ST_OK;
191	}
192	find_first_file(plainname);
193	}
194
195	// Select fopen() mode according to file mode
196	switch (filemode) {
197	case FMODE_READ:
198	mode = "rb";
199	break;
200	case FMODE_WRITE:
201	mode = "wb";
202	break;
203	case FMODE_APPEND:
204	mode = "ab";
205	break;
206	}
207
208	// Open file
209	#ifndef __riscos__
210	if (chdir(dir_path))
211	set_error(ERR_NOTREADY);
212	else if ((file[channel] = fopen(plainname, mode)) != NULL) {
213	if (filemode == FMODE_READ) // Read and buffer first byte
214	read_char[channel] = fgetc(file[channel]);
215	} else
216	set_error(ERR_FILENOTFOUND);
217	chdir(AppDirPath);
218	#else
219	{
220	char fullname[NAMEBUF_LENGTH];
221
222	// On RISC OS make a full filename
223	sprintf(fullname,"%s.%s",dir_path,plainname);
224	if ((file[channel] = fopen(fullname, mode)) != NULL)
225	{
226	if (filemode == FMODE_READ)
227	{
228	read_char[channel] = fgetc(file[channel]);
229	}
230	}
231	else
232	{
233	set_error(ERR_FILENOTFOUND);
234	}
235	}
236	#endif
237
238	return ST_OK;
239	}
240
241
242	/*
243	* Analyze file name, get access mode and type
244	*/
245
246	void FSDrive::convert_filename(char srcname, char destname, int filemode, int filetype, bool *wildflag)
247	{
248	char p, q;
249	int i;
250
251	// Search for ':', p points to first character after ':'
252	if ((p = strchr(srcname, ':')) != NULL)
253	p++;
254	else
255	p = srcname;
256
257	// Convert char set of the remaining string -> destname
258	q = destname;
259	for (i=0; i<NAMEBUF_LENGTH && (q++ = conv_from_64(p++, true)); i++) ;
260
261	// Look for mode parameters seperated by ','
262	p = destname;
263	while ((p = strchr(p, ',')) != NULL) {
264
265	// Cut string after the first ','
266	*p++ = 0;
267
268	switch (*p) {
269	case 'p':
270	*filetype = FTYPE_PRG;
271	break;
272	case 's':
273	*filetype = FTYPE_SEQ;
274	break;
275	case 'r':
276	*filemode = FMODE_READ;
277	break;
278	case 'w':
279	*filemode = FMODE_WRITE;
280	break;
281	case 'a':
282	*filemode = FMODE_APPEND;
283	break;
284	}
285	}
286
287	// Search for wildcards
288	wildflag = (strchr(destname, '?') != NULL) \|\| (strchr(destname, '') != NULL);
289	}
290
291
292	/*
293	* Find first file matching wildcard pattern and get its real name
294	*/
295
296	// Return true if name 'n' matches pattern 'p'
297	static bool match(char p, char n)
298	{
299	if (!*p) // Null pattern matches everything
300	return true;
301
302	do {
303	if (p == '') // Wildcard '*' matches all following characters
304	return true;
305	if ((p != n) && (*p != '?')) // Wildcard '?' matches single character
306	return false;
307	p++; n++;
308	} while (*p);
309
310	return !*n;
311	}
312
313	void FSDrive::find_first_file(char *name)
314	{
315	#ifndef __riscos__
316	DIR *dir;
317	struct dirent *de;
318
319	// Open directory for reading and skip '.' and '..'
320	if ((dir = opendir(dir_path)) == NULL)
321	return;
322	de = readdir(dir);
323	while (de && (0 == strcmp(".", de->d_name) \|\| 0 == strcmp("..", de->d_name)))
324	de = readdir(dir);
325
326	while (de) {
327
328	// Match found? Then copy real file name
329	if (match(name, de->d_name)) {
330	strncpy(name, de->d_name, NAMEBUF_LENGTH);
331	closedir(dir);
332	return;
333	}
334
335	// Get next directory entry
336	de = readdir(dir);
337	}
338
339	closedir(dir);
340	#else
341	dir_env de;
342	char Buffer[NAMEBUF_LENGTH];
343
344	de.offset = 0; de.buffsize = NAMEBUF_LENGTH; de.match = name;
345	do
346	{
347	de.readno = 1;
348	if (ReadDirName(dir_path,Buffer,&de) != NULL) {de.offset = -1;}
349	else if (de.offset != -1)
350	{
351	if (match(name,Buffer))
352	{
353	strncpy(name, Buffer, NAMEBUF_LENGTH);
354	return;
355	}
356	}
357	}
358	while (de.offset != -1);
359	#endif
360	}
361
362
363	/*
364	* Open directory, create temporary file
365	*/
366
367	uint8 FSDrive::open_directory(int channel, char *filename)
368	{
369	char buf[] = "\001\004\001\001\0\0\022\042 \042 00 2A";
370	char str[NAMEBUF_LENGTH];
371	char pattern[NAMEBUF_LENGTH];
372	char p, q;
373	int i;
374	int filemode;
375	int filetype;
376	bool wildflag;
377
378	#ifndef __riscos__
379	DIR *dir;
380	struct dirent *de;
381	struct stat statbuf;
382
383	// Special treatment for "$0"
384	if (filename[0] == '0' && filename[1] == 0)
385	filename += 1;
386
387	// Convert filename ('$' already stripped), filemode/type are ignored
388	convert_filename(filename, pattern, &filemode, &filetype, &wildflag);
389
390	// Open directory for reading and skip '.' and '..'
391	if ((dir = opendir(dir_path)) == NULL) {
392	set_error(ERR_NOTREADY);
393	return ST_OK;
394	}
395	de = readdir(dir);
396	while (de && (0 == strcmp(".", de->d_name) \|\| 0 == strcmp("..", de->d_name)))
397	de = readdir(dir);
398
399	// Create temporary file
400	if ((file[channel] = tmpfile()) == NULL) {
401	closedir(dir);
402	return ST_OK;
403	}
404
405	// Create directory title
406	p = &buf[8];
407	for (i=0; i<16 && dir_title[i]; i++)
408	*p++ = conv_to_64(dir_title[i], false);
409	fwrite(buf, 1, 32, file[channel]);
410
411	// Create and write one line for every directory entry
412	while (de) {
413
414	// Include only files matching the pattern
415	if (match(pattern, de->d_name)) {
416
417	// Get file statistics
418	chdir(dir_path);
419	stat(de->d_name, &statbuf);
420	chdir(AppDirPath);
421
422	// Clear line with spaces and terminate with null byte
423	memset(buf, ' ', 31);
424	buf[31] = 0;
425
426	p = buf;
427	*p++ = 0x01; // Dummy line link
428	*p++ = 0x01;
429
430	// Calculate size in blocks (254 bytes each)
431	i = (statbuf.st_size + 254) / 254;
432	*p++ = i & 0xff;
433	*p++ = (i >> 8) & 0xff;
434
435	p++;
436	if (i < 10) p++; // Less than 10: add one space
437	if (i < 100) p++; // Less than 100: add another space
438
439	// Convert and insert file name
440	strcpy(str, de->d_name);
441	*p++ = '\"';
442	q = p;
443	for (i=0; i<16 && str[i]; i++)
444	*q++ = conv_to_64(str[i], true);
445	*q++ = '\"';
446	p += 18;
447
448	// File type
449	if (S_ISDIR(statbuf.st_mode)) {
450	*p++ = 'D';
451	*p++ = 'I';
452	*p++ = 'R';
453	} else {
454	*p++ = 'P';
455	*p++ = 'R';
456	*p++ = 'G';
457	}
458
459	// Write line
460	fwrite(buf, 1, 32, file[channel]);
461	}
462
463	// Get next directory entry
464	de = readdir(dir);
465	}
466	#else
467	dir_full_info di;
468	dir_env de;
469
470	// Much of this is very similar to the original
471	if ((filename[0] == '0') && (filename[1] == 0)) {filename++;}
472	// Concatenate dir_path and pattern in buffer pattern ==> read subdirs!
473	strcpy(pattern,dir_path);
474	convert_filename(filename, pattern + strlen(pattern), &filemode, &filetype, &wildflag);
475
476	// We don't use tmpfile() -- problems involved!
477	DeleteFile(RO_TEMPFILE); // first delete it, if it exists
478	if ((file[channel] = fopen(RO_TEMPFILE,"wb+")) == NULL)
479	{
480	return(ST_OK);
481	}
482	de.offset = 0; de.buffsize = NAMEBUF_LENGTH; de.match = filename;
483
484	// Create directory title - copied from above
485	p = &buf[8];
486	for (i=0; i<16 && dir_title[i]; i++)
487	*p++ = conv_to_64(dir_title[i], false);
488	fwrite(buf, 1, 32, file[channel]);
489
490	do
491	{
492	de.readno = 1;
493	if (ReadDirNameInfo(pattern,&di,&de) != NULL) {de.offset = -1;}
494	else if (de.offset != -1) // don't have to check for match here
495	{
496	memset(buf,' ',31); buf[31] = 0; // most of this: see above
497	p = buf; p++ = 0x01; p++ = 0x01;
498	i = (di.length + 254) / 254; p++ = i & 0xff; p++ = (i>>8) & 0xff;
499	p++;
500	if (i < 10) {*p++ = ' ';}
501	if (i < 100) {*p++ = ' ';}
502	strcpy(str, di.name);
503	*p++ = '\"'; q = p;
504	for (i=0; (i<16 && str[i]); i++)
505	{
506	*q++ = conv_to_64(str[i], true);
507	}
508	*q++ = '\"'; p += 18;
509	if ((di.otype & 2) == 0)
510	{
511	p++ = 'P'; p++ = 'R'; *p++ = 'G';
512	}
513	else
514	{
515	p++ = 'D'; p++ = 'I'; *p++ = 'R';
516	}
517	fwrite(buf, 1, 32, file[channel]);
518	}
519	}
520	while (de.offset != -1);
521	#endif
522
523	// Final line
524	fwrite("\001\001\0\0BLOCKS FREE. \0\0", 1, 32, file[channel]);
525
526	// Rewind file for reading and read first byte
527	rewind(file[channel]);
528	read_char[channel] = fgetc(file[channel]);
529
530	#ifndef __riscos
531	// Close directory
532	closedir(dir);
533	#endif
534
535	return ST_OK;
536	}
537
538
539	/*
540	* Close channel
541	*/
542
543	uint8 FSDrive::Close(int channel)
544	{
545	if (channel == 15) {
546	close_all_channels();
547	return ST_OK;
548	}
549
550	if (file[channel]) {
551	fclose(file[channel]);
552	file[channel] = NULL;
553	}
554
555	return ST_OK;
556	}
557
558
559	/*
560	* Close all channels
561	*/
562
563	void FSDrive::close_all_channels(void)
564	{
565	for (int i=0; i<15; i++)
566	Close(i);
567
568	cmd_len = 0;
569	}
570
571
572	/*
573	* Read from channel
574	*/
575
576	uint8 FSDrive::Read(int channel, uint8 *byte)
577	{
578	int c;
579
580	// Channel 15: Error channel
581	if (channel == 15) {
582	byte = error_ptr++;
583
584	if (*byte != '\r')
585	return ST_OK;
586	else { // End of message
587	set_error(ERR_OK);
588	return ST_EOF;
589	}
590	}
591
592	if (!file[channel]) return ST_READ_TIMEOUT;
593
594	// Read one byte
595	*byte = read_char[channel];
596	c = fgetc(file[channel]);
597	if (c == EOF)
598	return ST_EOF;
599	else {
600	read_char[channel] = c;
601	return ST_OK;
602	}
603	}
604
605
606	/*
607	* Write to channel
608	*/
609
610	uint8 FSDrive::Write(int channel, uint8 byte, bool eoi)
611	{
612	// Channel 15: Collect chars and execute command on EOI
613	if (channel == 15) {
614	if (cmd_len >= 40)
615	return ST_TIMEOUT;
616
617	cmd_buffer[cmd_len++] = byte;
618
619	if (eoi) {
620	cmd_buffer[cmd_len] = 0;
621	cmd_len = 0;
622	execute_command(cmd_buffer);
623	}
624	return ST_OK;
625	}
626
627	if (!file[channel]) {
628	set_error(ERR_FILENOTOPEN);
629	return ST_TIMEOUT;
630	}
631
632	if (fputc(byte, file[channel]) == EOF) {
633	set_error(ERR_WRITEERROR);
634	return ST_TIMEOUT;
635	}
636
637	return ST_OK;
638	}
639
640
641	/*
642	* Execute command string
643	*/
644
645	void FSDrive::execute_command(char *command)
646	{
647	switch (command[0]) {
648	case 'I':
649	close_all_channels();
650	set_error(ERR_OK);
651	break;
652
653	case 'U':
654	if ((command[1] & 0x0f) == 0x0a) {
655	Reset();
656	} else
657	set_error(ERR_SYNTAX30);
658	break;
659
660	case 'G':
661	if (command[1] != ':')
662	set_error(ERR_SYNTAX30);
663	else
664	chdir_cmd(&command[2]);
665	break;
666
667	default:
668	set_error(ERR_SYNTAX30);
669	}
670	}
671
672
673	/*
674	* Execute 'G' command
675	*/
676
677	void FSDrive::chdir_cmd(char *dirpath)
678	{
679	char str[NAMEBUF_LENGTH];
680	char *p = str;
681
682	close_all_channels();
683
684	// G:. resets the directory path to its original setting
685	if (dirpath[0] == '.' && dirpath[1] == 0) {
686	change_dir(orig_dir_path);
687	} else {
688
689	// Convert directory name
690	for (int i=0; i<NAMEBUF_LENGTH && (p++ = conv_from_64(dirpath++, false)); i++) ;
691
692	if (!change_dir(str))
693	set_error(ERR_NOTREADY);
694	}
695	}
696
697
698	/*
699	* Reset drive
700	*/
701
702	void FSDrive::Reset(void)
703	{
704	close_all_channels();
705	cmd_len = 0;
706	set_error(ERR_STARTUP);
707	}
708
709
710	/*
711	* Conversion PETSCII->ASCII
712	*/
713
714	uint8 FSDrive::conv_from_64(uint8 c, bool map_slash)
715	{
716	if ((c >= 'A') && (c <= 'Z') \|\| (c >= 'a') && (c <= 'z'))
717	return c ^ 0x20;
718	if ((c >= 0xc1) && (c <= 0xda))
719	return c ^ 0x80;
720	if ((c == '/') && map_slash && ThePrefs.MapSlash)
721	#ifdef __riscos__
722	return '.'; // directory separator is '.' in RO
723	if (c == '.') {return('_');} // convert dot to underscore
724	#else
725	return '\\';
726	#endif
727	return c;
728	}
729
730
731	/*
732	* Conversion ASCII->PETSCII
733	*/
734
735	uint8 FSDrive::conv_to_64(uint8 c, bool map_slash)
736	{
737	if ((c >= 'A') && (c <= 'Z') \|\| (c >= 'a') && (c <= 'z'))
738	return c ^ 0x20;
739	#ifdef __riscos__
740	if ((c == '.') && map_slash && ThePrefs.MapSlash)
741	#else
742	if ((c == '\\') && map_slash && ThePrefs.MapSlash)
743	#endif
744	return '/';
745	#ifdef __riscos__
746	if (c == '_') {return('.');} // convert underscore to dot
747	#endif
748	return c;
749	}