the10thwiz/cc65
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Added support for building targetutils.

Browse Source
This commit is contained in:
Oliver Schmidt
2013-05-09 01:12:26 +02:00
parent bf59515a9e
commit 092653cb5b
11 changed files with 74 additions and 165 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
libsrc/geos-apple/targetutil/Makefile.inc Normal file
View File

@@ -0,0 +1,9 @@
../wrk/$(TARGET)/convert.o: TARGET = apple2enh
../wrk/$(TARGET)/convert.o: $(SRCDIR)/targetutil/convert.c | ../wrk/$(TARGET)
$(COMPILE_recipe)
../targetutil/convert.system: ../wrk/$(TARGET)/convert.o | ../targetutil
$(LD) -o $@ -C apple2enh-system.cfg $^ apple2enh.lib
$(TARGET): ../targetutil/convert.system

346
libsrc/geos-apple/targetutil/convert.c Normal file
View File

@@ -0,0 +1,346 @@
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <dirent.h>
#include <device.h>
#include <dio.h>
unsigned char info_signature[3] = {3, 21, 63 | 0x80};
dhandle_t dhandle;
struct dir_entry_t {
struct {
unsigned name_length :4;
unsigned storage_type :4;
} storage_length;
char file_name[15];
unsigned char file_type;
unsigned key_pointer;
unsigned blocks_used;
unsigned char size[3];
unsigned long creation;
unsigned char version;
unsigned char min_version;
unsigned char access;
unsigned aux_type;
unsigned long last_mod;
unsigned header_pointer;
}* dir_entry;
union {
unsigned char bytes[512];
struct {
unsigned prev_block;
unsigned next_block;
unsigned char entries[1];
} content;
} dir_block;
union {
unsigned char bytes[512];
struct {
unsigned char addr_lo[254];
unsigned char size_lo[2];
unsigned char addr_hi[254];
unsigned char size_hi[2];
} content;
} index_block, master_block, vlir_block;
union {
unsigned char bytes[512];
struct {
unsigned reserved;
unsigned char info_block[254];
unsigned char vlir_records[128];
struct dir_entry_t dir_entry;
} content;
} header_block;
static void err_exit(char *operation, unsigned char oserr)
{
if (oserr) {
fprintf(stderr, "%s - err:%02x - %s",
operation, (int)_oserror, _stroserror(_oserror));
} else {
fprintf(stderr, "%s",
operation);
}
getchar();
exit(EXIT_FAILURE);
}
static unsigned get_dir_entry(char* p_name)
{
char* d_name;
char* f_name;
size_t f_namelen;
DIR* dir;
struct dirent* dirent;
unsigned cur_addr;
unsigned char entry_length;
unsigned char entries_per_block;
unsigned char cur_entry;
/* Split path name into directory name and file name */
f_name = strrchr(p_name, '/');
if (f_name) {
d_name = p_name;
*f_name++ = '\0';
} else {
d_name = ".";
f_name = p_name;
}
f_namelen = strlen(f_name);
/* Start with high level functions to get handling
of relative path and current drive for free */
dir = opendir(d_name);
if (!dir) {
err_exit("opendir", 1);
}
dirent = readdir(dir);
if (!dirent) {
err_exit("readdir", 1);
}
/* Field header_pointer directly follows field last_mod */
cur_addr = *(unsigned*)(&dirent->d_mtime.hour + 1);
dhandle = dio_open(getcurrentdevice());
if (!dhandle) {
err_exit("dio_open", 1);
}
if (dio_read(dhandle, cur_addr, &dir_block)) {
err_exit("dio_read.1", 1);
}
/* Get directory entry infos from directory header */
entry_length = dir_block.bytes[0x23];
entries_per_block = dir_block.bytes[0x24];
/* Skip directory header entry */
cur_entry = 1;
do {
/* Search for next active directory entry */
do {
/* Check if next directory block is necessary */
if (cur_entry == entries_per_block) {
/* Check if another directory block is present */
cur_addr = dir_block.content.next_block;
if (!cur_addr) {
_mappederrno(0x46);
err_exit("dio_read.2", 1);
}
/* Read next directory block */
if (dio_read(dhandle, cur_addr, &dir_block)) {
err_exit("dio_read.3", 1);
}
/* Start with first entry in next block */
cur_entry = 0;
}
/* Compute pointer to current entry */
dir_entry = (struct dir_entry_t*)(dir_block.content.entries +
cur_entry * entry_length);
/* Switch to next entry */
++cur_entry;
} while (!dir_entry->storage_length.storage_type);
} while (dir_entry->storage_length.name_length != f_namelen ||
strncasecmp(dir_entry->file_name, f_name, f_namelen));
return cur_addr;
}
int main(int argc, char* argv[])
{
char input[80];
char* p_name;
unsigned dir_addr;
unsigned header_addr;
unsigned char index;
unsigned long size;
if (argc > 1) {
p_name = argv[1];
} else {
printf("\n"
"Apple GEOS Convert 1.0\n"
"----------------------\n"
"\n"
"Pathname:");
p_name = gets(input);
}
dir_addr = get_dir_entry(p_name);
/* Read index block */
if (dio_read(dhandle, dir_entry->key_pointer, &index_block)) {
err_exit("dio_read.4", 1);
}
/* First pointer is header block */
header_addr = index_block.content.addr_lo[0] |
index_block.content.addr_hi[0] << 8;
/* Read header block */
if (dio_read(dhandle, header_addr, &header_block)) {
err_exit("dio_read.5", 1);
}
/* Do some sanity check */
for (index = 0; index < sizeof(info_signature); ++index) {
if (header_block.content.info_block[index] != info_signature[index]) {
err_exit("file signature mismatch", 0);
}
}
/* Check ProDOS storage type in directory entry template */
if (header_block.content.dir_entry.storage_length.storage_type == 2)
{
/* ProDOS sapling file means GEOS Sequential file*/
printf("\nSequential file\n");
/* Remove header block pointer from pointer list */
memmove(&index_block.content.addr_lo[0],
&index_block.content.addr_lo[1], sizeof(index_block.content.addr_lo) - 1);
memmove(&index_block.content.addr_hi[0],
&index_block.content.addr_hi[1], sizeof(index_block.content.addr_hi) - 1);
/* Get file size from ProDOS directory entry template */
size = (unsigned long)(header_block.content.dir_entry.size[0]) |
(unsigned long)(header_block.content.dir_entry.size[1]) << 8 |
(unsigned long)(header_block.content.dir_entry.size[2]) << 16;
} else {
/* ProDOS tree file means GEOS VLIR file */
unsigned vlir_addr;
unsigned long vlir_size;
unsigned char vlir_blocks;
unsigned char record = 0;
printf("\nVLIR file\n");
/* Skip header block pointer */
index = 1;
size = 0;
while (1) {
/* Get next VLIR index pointer from index block */
vlir_addr = index_block.content.addr_lo[index] |
index_block.content.addr_hi[index] << 8;
++index;
/* Check for end of pointer list */
if (vlir_addr == 0) {
break;
}
/* Check for empty VLIRs */
while (header_block.content.vlir_records[record] == 0xFF) {
/* Add empty VLIR index pointer to to master index block */
master_block.content.addr_lo[record] = 0xFF;
master_block.content.addr_hi[record] = 0xFF;
++record;
}
/* Add VLIR index pointer to master index block */
master_block.content.addr_lo[record] = (unsigned char)(vlir_addr );
master_block.content.addr_hi[record] = (unsigned char)(vlir_addr >> 8);
++record;
/* Read VLIR index block */
if (dio_read(dhandle, vlir_addr, &vlir_block)) {
err_exit("dio_read.6", 1);
}
/* Get VLIR size from VLIR index block */
vlir_size = (unsigned long)(vlir_block.content.size_lo[1]) |
(unsigned long)(vlir_block.content.size_hi[1]) << 8 |
(unsigned long)(vlir_block.content.size_lo[0]) << 16 |
(unsigned long)(vlir_block.content.size_hi[0]) << 24;
printf("VLIR %u size %lu bytes\n", record - 1, vlir_size);
/* Compute VLIR block size */
vlir_blocks = (unsigned char)((vlir_size + 511) / 512);
/* Copy VLIR block pointers from index block to VLIR index block */
memcpy(&vlir_block.content.addr_lo[0],
&index_block.content.addr_lo[index], vlir_blocks);
memcpy(&vlir_block.content.addr_hi[0],
&index_block.content.addr_hi[index], vlir_blocks);
index += vlir_blocks;
/* Write back VLIR index block */
if (dio_write(dhandle, vlir_addr, &vlir_block)) {
err_exit("dio_write.1", 1);
}
/* Add VLIR size to file size */
size += vlir_size;
}
/* Replace (by now completely read) index block with
(by now completely created) master index block */
index_block = master_block;
}
printf("File size %lu bytes\n\n", size);
/* Set file size in index block */
index_block.content.size_lo[1] = (unsigned char)(size );
index_block.content.size_hi[1] = (unsigned char)(size >> 8);
index_block.content.size_lo[0] = (unsigned char)(size >> 16);
index_block.content.size_hi[0] = (unsigned char)(size >> 24);
/* Write index block */
if (dio_write(dhandle, dir_entry->key_pointer, &index_block)) {
err_exit("dio_write.2", 1);
}
/* Copy selected fields from directory entry template to directory block */
dir_entry->storage_length = header_block.content.dir_entry.storage_length;
memcpy(dir_entry->file_name, header_block.content.dir_entry.file_name, 15);
dir_entry->file_type = header_block.content.dir_entry.file_type;
dir_entry->size[0] = (unsigned char)(size );
dir_entry->size[1] = (unsigned char)(size >> 8);
dir_entry->size[2] = (unsigned char)(size >> 16);
dir_entry->creation = header_block.content.dir_entry.creation;
dir_entry->version = header_block.content.dir_entry.version;
dir_entry->min_version = header_block.content.dir_entry.min_version;
dir_entry->aux_type = header_addr;
dir_entry->last_mod = header_block.content.dir_entry.last_mod;
/* Write directory block */
if (dio_write(dhandle, dir_addr, &dir_block)) {
err_exit("dio_write.3", 1);
}
/* We're done */
if (dio_close(dhandle)) {
err_exit("dio_close", 1);
}
printf("Convert to '%.*s' successful", dir_entry->storage_length.name_length,
dir_entry->file_name);
getchar();
return EXIT_SUCCESS;
}