ViewVC Help
View File | Revision Log | Show Annotations | Revision Graph | Root Listing
root/cebix/Frodo4/Src/1541t64.cpp
Revision: 1.1
Committed: 2003-07-01T17:09:43Z (19 years, 7 months ago) by cebix
Branch: MAIN
Log Message:
imported files

File Contents

# User Rev Content
1 cebix 1.1 /*
2     * 1541t64.cpp - 1541 emulation in .t64/LYNX file
3     *
4     * Frodo (C) 1994-1997,2002 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 any file is opened, the contents of the file in the
26     * .t64 file are copied into a temporary file which is used
27     * for reading. This is done to insert the load address.
28     * - C64 LYNX archives are also handled by these routines
29     *
30     * Incompatibilities:
31     * ------------------
32     *
33     * - Only read accesses possible
34     * - No "raw" directory reading
35     * - No relative/sequential/user files
36     * - Only "I" and "UJ" commands implemented
37     */
38    
39     #include "sysdeps.h"
40    
41     #include "1541t64.h"
42     #include "IEC.h"
43     #include "Prefs.h"
44    
45    
46     // Access modes
47     enum {
48     FMODE_READ, FMODE_WRITE, FMODE_APPEND
49     };
50    
51     // File types
52     enum {
53     FTYPE_PRG, FTYPE_SEQ, FTYPE_USR, FTYPE_REL
54     };
55    
56     // Prototypes
57     static bool match(char *p, char *n);
58    
59    
60     /*
61     * Constructor: Prepare emulation
62     */
63    
64     T64Drive::T64Drive(IEC *iec, char *filepath) : Drive(iec)
65     {
66     the_file = NULL;
67     file_info = NULL;
68    
69     Ready = false;
70     strcpy(orig_t64_name, filepath);
71     for (int i=0; i<16; i++)
72     file[i] = NULL;
73    
74     // Open .t64 file
75     open_close_t64_file(filepath);
76     if (the_file != NULL) {
77     Reset();
78     Ready = true;
79     }
80     }
81    
82    
83     /*
84     * Destructor
85     */
86    
87     T64Drive::~T64Drive()
88     {
89     // Close .t64 file
90     open_close_t64_file("");
91    
92     Ready = false;
93     }
94    
95    
96     /*
97     * Open/close the .t64/LYNX file
98     */
99    
100     void T64Drive::open_close_t64_file(char *t64name)
101     {
102     uint8 buf[64];
103     bool parsed_ok = false;
104    
105     // Close old .t64, if open
106     if (the_file != NULL) {
107     close_all_channels();
108     fclose(the_file);
109     the_file = NULL;
110     delete[] file_info;
111     file_info = NULL;
112     }
113    
114     // Open new .t64 file
115     if (t64name[0]) {
116     if ((the_file = fopen(t64name, "rb")) != NULL) {
117    
118     // Check file ID
119     fread(&buf, 64, 1, the_file);
120     if (buf[0] == 0x43 && buf[1] == 0x36 && buf[2] == 0x34) {
121     is_lynx = false;
122     parsed_ok = parse_t64_file();
123     } else if (buf[0x3c] == 0x4c && buf[0x3d] == 0x59 && buf[0x3e] == 0x4e && buf[0x3f] == 0x58) {
124     is_lynx = true;
125     parsed_ok = parse_lynx_file();
126     }
127    
128     if (!parsed_ok) {
129     fclose(the_file);
130     the_file = NULL;
131     delete[] file_info;
132     file_info = NULL;
133     return;
134     }
135     }
136     }
137     }
138    
139    
140     /*
141     * Parse .t64 file and construct FileInfo array
142     */
143    
144     bool T64Drive::parse_t64_file(void)
145     {
146     uint8 buf[32];
147     uint8 *buf2;
148     char *p;
149     int max, i, j;
150    
151     // Read header and get maximum number of files contained
152     fseek(the_file, 32, SEEK_SET);
153     fread(&buf, 32, 1, the_file);
154     max = (buf[3] << 8) | buf[2];
155    
156     memcpy(dir_title, buf+8, 16);
157    
158     // Allocate buffer for file records and read them
159     buf2 = new uint8[max*32];
160     fread(buf2, 32, max, the_file);
161    
162     // Determine number of files contained
163     for (i=0, num_files=0; i<max; i++)
164     if (buf2[i*32] == 1)
165     num_files++;
166    
167     if (!num_files)
168     return false;
169    
170     // Construct file information array
171     file_info = new FileInfo[num_files];
172     for (i=0, j=0; i<max; i++)
173     if (buf2[i*32] == 1) {
174     memcpy(file_info[j].name, buf2+i*32+16, 16);
175    
176     // Strip trailing spaces
177     file_info[j].name[16] = 0x20;
178     p = file_info[j].name + 16;
179     while (*p-- == 0x20) ;
180     p[2] = 0;
181    
182     file_info[j].type = FTYPE_PRG;
183     file_info[j].sa_lo = buf2[i*32+2];
184     file_info[j].sa_hi = buf2[i*32+3];
185     file_info[j].offset = (buf2[i*32+11] << 24) | (buf2[i*32+10] << 16) | (buf2[i*32+9] << 8) | buf2[i*32+8];
186     file_info[j].length = ((buf2[i*32+5] << 8) | buf2[i*32+4]) - ((buf2[i*32+3] << 8) | buf2[i*32+2]);
187     j++;
188     }
189    
190     delete[] buf2;
191     return true;
192     }
193    
194    
195     /*
196     * Parse LYNX file and construct FileInfo array
197     */
198    
199     bool T64Drive::parse_lynx_file(void)
200     {
201     uint8 *p;
202     int dir_blocks, cur_offset, num_blocks, last_block, i;
203     char type_char;
204    
205     // Dummy directory title
206     strcpy(dir_title, "LYNX ARCHIVE ");
207    
208     // Read header and get number of directory blocks and files contained
209     fseek(the_file, 0x60, SEEK_SET);
210     fscanf(the_file, "%d", &dir_blocks);
211     while (fgetc(the_file) != 0x0d)
212     if (feof(the_file))
213     return false;
214     fscanf(the_file, "%d\015", &num_files);
215    
216     // Construct file information array
217     file_info = new FileInfo[num_files];
218     cur_offset = dir_blocks * 254;
219     for (i=0; i<num_files; i++) {
220    
221     // Read file name
222     fread(file_info[i].name, 16, 1, the_file);
223    
224     // Strip trailing shift-spaces
225     file_info[i].name[16] = 0xa0;
226     p = (uint8 *)file_info[i].name + 16;
227     while (*p-- == 0xa0) ;
228     p[2] = 0;
229    
230     // Read file length and type
231     fscanf(the_file, "\015%d\015%c\015%d\015", &num_blocks, &type_char, &last_block);
232    
233     switch (type_char) {
234     case 'S':
235     file_info[i].type = FTYPE_SEQ;
236     break;
237     case 'U':
238     file_info[i].type = FTYPE_USR;
239     break;
240     case 'R':
241     file_info[i].type = FTYPE_REL;
242     break;
243     default:
244     file_info[i].type = FTYPE_PRG;
245     break;
246     }
247     file_info[i].sa_lo = 0; // Only used for .t64 files
248     file_info[i].sa_hi = 0;
249     file_info[i].offset = cur_offset;
250     file_info[i].length = (num_blocks-1) * 254 + last_block;
251    
252     cur_offset += num_blocks * 254;
253     }
254    
255     return true;
256     }
257    
258    
259     /*
260     * Open channel
261     */
262    
263     uint8 T64Drive::Open(int channel, char *filename)
264     {
265     set_error(ERR_OK);
266    
267     // Channel 15: Execute file name as command
268     if (channel == 15) {
269     execute_command(filename);
270     return ST_OK;
271     }
272    
273     // Close previous file if still open
274     if (file[channel]) {
275     fclose(file[channel]);
276     file[channel] = NULL;
277     }
278    
279     if (filename[0] == '#') {
280     set_error(ERR_NOCHANNEL);
281     return ST_OK;
282     }
283    
284     if (the_file == NULL) {
285     set_error(ERR_NOTREADY);
286     return ST_OK;
287     }
288    
289     if (filename[0] == '$')
290     return open_directory(channel, filename+1);
291    
292     return open_file(channel, filename);
293     }
294    
295    
296     /*
297     * Open file
298     */
299    
300     uint8 T64Drive::open_file(int channel, char *filename)
301     {
302     char plainname[NAMEBUF_LENGTH];
303     int filemode = FMODE_READ;
304     int filetype = FTYPE_PRG;
305     int num;
306    
307     convert_filename(filename, plainname, &filemode, &filetype);
308    
309     // Channel 0 is READ PRG, channel 1 is WRITE PRG
310     if (!channel) {
311     filemode = FMODE_READ;
312     filetype = FTYPE_PRG;
313     }
314     if (channel == 1) {
315     filemode = FMODE_WRITE;
316     filetype = FTYPE_PRG;
317     }
318    
319     // Allow only read accesses
320     if (filemode != FMODE_READ) {
321     set_error(ERR_WRITEPROTECT);
322     return ST_OK;
323     }
324    
325     // Find file
326     if (find_first_file(plainname, filetype, &num)) {
327    
328     // Open temporary file
329     if ((file[channel] = tmpfile()) != NULL) {
330    
331     // Write load address (.t64 only)
332     if (!is_lynx) {
333     fwrite(&file_info[num].sa_lo, 1, 1, file[channel]);
334     fwrite(&file_info[num].sa_hi, 1, 1, file[channel]);
335     }
336    
337     // Copy file contents from .t64 file to temp file
338     uint8 *buf = new uint8[file_info[num].length];
339     fseek(the_file, file_info[num].offset, SEEK_SET);
340     fread(buf, file_info[num].length, 1, the_file);
341     fwrite(buf, file_info[num].length, 1, file[channel]);
342     rewind(file[channel]);
343     delete[] buf;
344    
345     if (filemode == FMODE_READ) // Read and buffer first byte
346     read_char[channel] = fgetc(file[channel]);
347     }
348     } else
349     set_error(ERR_FILENOTFOUND);
350    
351     return ST_OK;
352     }
353    
354    
355     /*
356     * Analyze file name, get access mode and type
357     */
358    
359     void T64Drive::convert_filename(char *srcname, char *destname, int *filemode, int *filetype)
360     {
361     char *p;
362    
363     // Search for ':', p points to first character after ':'
364     if ((p = strchr(srcname, ':')) != NULL)
365     p++;
366     else
367     p = srcname;
368    
369     // Remaining string -> destname
370     strncpy(destname, p, NAMEBUF_LENGTH);
371    
372     // Search for ','
373     p = destname;
374     while (*p && (*p != ',')) p++;
375    
376     // Look for mode parameters seperated by ','
377     p = destname;
378     while ((p = strchr(p, ',')) != NULL) {
379    
380     // Cut string after the first ','
381     *p++ = 0;
382    
383     switch (*p) {
384     case 'P':
385     *filetype = FTYPE_PRG;
386     break;
387     case 'S':
388     *filetype = FTYPE_SEQ;
389     break;
390     case 'U':
391     *filetype = FTYPE_USR;
392     break;
393     case 'L':
394     *filetype = FTYPE_REL;
395     break;
396     case 'R':
397     *filemode = FMODE_READ;
398     break;
399     case 'W':
400     *filemode = FMODE_WRITE;
401     break;
402     case 'A':
403     *filemode = FMODE_APPEND;
404     break;
405     }
406     }
407     }
408    
409    
410     /*
411     * Find first file matching wildcard pattern
412     */
413    
414     // Return true if name 'n' matches pattern 'p'
415     static bool match(char *p, char *n)
416     {
417     if (!*p) // Null pattern matches everything
418     return true;
419    
420     do {
421     if (*p == '*') // Wildcard '*' matches all following characters
422     return true;
423     if ((*p != *n) && (*p != '?')) // Wildcard '?' matches single character
424     return false;
425     p++; n++;
426     } while (*p);
427    
428     return !(*n);
429     }
430    
431     bool T64Drive::find_first_file(char *name, int type, int *num)
432     {
433     for (int i=0; i<num_files; i++)
434     if (match(name, file_info[i].name) && type == file_info[i].type) {
435     *num = i;
436     return true;
437     }
438    
439     return false;
440     }
441    
442    
443     /*
444     * Open directory, create temporary file
445     */
446    
447     uint8 T64Drive::open_directory(int channel, char *filename)
448     {
449     char buf[] = "\001\004\001\001\0\0\022\042 \042 00 2A";
450     char str[NAMEBUF_LENGTH];
451     char pattern[NAMEBUF_LENGTH];
452     char *p, *q;
453     int i, num;
454     int filemode;
455     int filetype;
456    
457     // Special treatment for "$0"
458     if (strlen(filename) == 1 && filename[0] == '0')
459     filename += 1;
460    
461     // Convert filename ('$' already stripped), filemode/type are ignored
462     convert_filename(filename, pattern, &filemode, &filetype);
463    
464     // Create temporary file
465     if ((file[channel] = tmpfile()) == NULL)
466     return ST_OK;
467    
468     // Create directory title
469     p = &buf[8];
470     for (i=0; i<16 && dir_title[i]; i++)
471     *p++ = dir_title[i];
472     fwrite(buf, 1, 32, file[channel]);
473    
474     // Create and write one line for every directory entry
475     for (num=0; num<num_files; num++) {
476    
477     // Include only files matching the pattern
478     if (match(pattern, file_info[num].name)) {
479    
480     // Clear line with spaces and terminate with null byte
481     memset(buf, ' ', 31);
482     buf[31] = 0;
483    
484     p = buf;
485     *p++ = 0x01; // Dummy line link
486     *p++ = 0x01;
487    
488     // Calculate size in blocks (254 bytes each)
489     i = (file_info[num].length + 254) / 254;
490     *p++ = i & 0xff;
491     *p++ = (i >> 8) & 0xff;
492    
493     p++;
494     if (i < 10) p++; // Less than 10: add one space
495     if (i < 100) p++; // Less than 100: add another space
496    
497     // Convert and insert file name
498     strcpy(str, file_info[num].name);
499     *p++ = '\"';
500     q = p;
501     for (i=0; i<16 && str[i]; i++)
502     *q++ = str[i];
503     *q++ = '\"';
504     p += 18;
505    
506     // File type
507     switch (file_info[num].type) {
508     case FTYPE_PRG:
509     *p++ = 'P';
510     *p++ = 'R';
511     *p++ = 'G';
512     break;
513     case FTYPE_SEQ:
514     *p++ = 'S';
515     *p++ = 'E';
516     *p++ = 'Q';
517     break;
518     case FTYPE_USR:
519     *p++ = 'U';
520     *p++ = 'S';
521     *p++ = 'R';
522     break;
523     case FTYPE_REL:
524     *p++ = 'R';
525     *p++ = 'E';
526     *p++ = 'L';
527     break;
528     default:
529     *p++ = '?';
530     *p++ = '?';
531     *p++ = '?';
532     break;
533     }
534    
535     // Write line
536     fwrite(buf, 1, 32, file[channel]);
537     }
538     }
539    
540     // Final line
541     fwrite("\001\001\0\0BLOCKS FREE. \0\0", 1, 32, file[channel]);
542    
543     // Rewind file for reading and read first byte
544     rewind(file[channel]);
545     read_char[channel] = fgetc(file[channel]);
546    
547     return ST_OK;
548     }
549    
550    
551     /*
552     * Close channel
553     */
554    
555     uint8 T64Drive::Close(int channel)
556     {
557     if (channel == 15) {
558     close_all_channels();
559     return ST_OK;
560     }
561    
562     if (file[channel]) {
563     fclose(file[channel]);
564     file[channel] = NULL;
565     }
566    
567     return ST_OK;
568     }
569    
570    
571     /*
572     * Close all channels
573     */
574    
575     void T64Drive::close_all_channels(void)
576     {
577     for (int i=0; i<15; i++)
578     Close(i);
579    
580     cmd_len = 0;
581     }
582    
583    
584     /*
585     * Read from channel
586     */
587    
588     uint8 T64Drive::Read(int channel, uint8 *byte)
589     {
590     int c;
591    
592     // Channel 15: Error channel
593     if (channel == 15) {
594     *byte = *error_ptr++;
595    
596     if (*byte != '\r')
597     return ST_OK;
598     else { // End of message
599     set_error(ERR_OK);
600     return ST_EOF;
601     }
602     }
603    
604     if (!file[channel]) return ST_READ_TIMEOUT;
605    
606     // Get char from buffer and read next
607     *byte = read_char[channel];
608     c = fgetc(file[channel]);
609     if (c == EOF)
610     return ST_EOF;
611     else {
612     read_char[channel] = c;
613     return ST_OK;
614     }
615     }
616    
617    
618     /*
619     * Write to channel
620     */
621    
622     uint8 T64Drive::Write(int channel, uint8 byte, bool eoi)
623     {
624     // Channel 15: Collect chars and execute command on EOI
625     if (channel == 15) {
626     if (cmd_len >= 40)
627     return ST_TIMEOUT;
628    
629     cmd_buffer[cmd_len++] = byte;
630    
631     if (eoi) {
632     cmd_buffer[cmd_len] = 0;
633     cmd_len = 0;
634     execute_command(cmd_buffer);
635     }
636     return ST_OK;
637     }
638    
639     if (!file[channel])
640     set_error(ERR_FILENOTOPEN);
641     else
642     set_error(ERR_WRITEPROTECT);
643    
644     return ST_TIMEOUT;
645     }
646    
647    
648     /*
649     * Execute command string
650     */
651    
652     void T64Drive::execute_command(char *command)
653     {
654     switch (command[0]) {
655     case 'I':
656     close_all_channels();
657     set_error(ERR_OK);
658     break;
659    
660     case 'U':
661     if ((command[1] & 0x0f) == 0x0a) {
662     Reset();
663     } else
664     set_error(ERR_SYNTAX30);
665     break;
666    
667     case 'G':
668     if (command[1] != ':')
669     set_error(ERR_SYNTAX30);
670     else
671     cht64_cmd(&command[2]);
672     break;
673    
674     default:
675     set_error(ERR_SYNTAX30);
676     }
677     }
678    
679    
680     /*
681     * Execute 'G' command
682     */
683    
684     void T64Drive::cht64_cmd(char *t64name)
685     {
686     char str[NAMEBUF_LENGTH];
687     char *p = str;
688    
689     // Convert .t64 file name
690     for (int i=0; i<NAMEBUF_LENGTH && (*p++ = conv_from_64(*t64name++, false)); i++) ;
691    
692     close_all_channels();
693    
694     // G:. resets the .t64 file name to its original setting
695     if (str[0] == '.' && str[1] == 0)
696     open_close_t64_file(orig_t64_name);
697     else
698     open_close_t64_file(str);
699    
700     if (the_file == NULL)
701     set_error(ERR_NOTREADY);
702     }
703    
704    
705     /*
706     * Reset drive
707     */
708    
709     void T64Drive::Reset(void)
710     {
711     close_all_channels();
712     cmd_len = 0;
713     set_error(ERR_STARTUP);
714     }
715    
716    
717     /*
718     * Conversion PETSCII->ASCII
719     */
720    
721     uint8 T64Drive::conv_from_64(uint8 c, bool map_slash)
722     {
723     if ((c >= 'A') && (c <= 'Z') || (c >= 'a') && (c <= 'z'))
724     return c ^ 0x20;
725     if ((c >= 0xc1) && (c <= 0xda))
726     return c ^ 0x80;
727     if ((c == '/') && map_slash && ThePrefs.MapSlash)
728     return '\\';
729     return c;
730     }