summaryrefslogtreecommitdiff
path: root/command_line
diff options
context:
space:
mode:
Diffstat (limited to 'command_line')
-rw-r--r--command_line/CmdLine/Src/MacEmul/Resources.c765
1 files changed, 603 insertions, 162 deletions
diff --git a/command_line/CmdLine/Src/MacEmul/Resources.c b/command_line/CmdLine/Src/MacEmul/Resources.c
index 7c2bea8..fcbed0b 100644
--- a/command_line/CmdLine/Src/MacEmul/Resources.c
+++ b/command_line/CmdLine/Src/MacEmul/Resources.c
@@ -1,23 +1,27 @@
#include "mwcc_decomp.h"
-// base is 0,51, ptr is 0,54
-typedef struct MemRefList {
- UInt16 id;
- OSType type;
- StringPtr name;
- unsigned char attr;
- Handle hand;
- struct MemRefList *next;
-} MemRefList;
-
-// base is 0,50, ptr is 0,55
-typedef struct MemRsrcTypeList {
- OSType type;
- MemRefList *ref_list;
- struct MemRsrcTypeList *next;
-} MemRsrcTypeList;
-
-// base is 0,56
+#define OPTION_ASSERT(cond) do { if (!(cond)) { printf("%s:%u: failed assertion\n", __FILE__, __LINE__); abort(); } } while(0)
+
+// Fork Attributes
+enum {
+ mapReadOnly = 0x80,
+ mapCompact = 0x40,
+ mapChanged = 0x20
+};
+
+// Resources
+enum {
+ resSysHeap = 0x40,
+ resPurgeable = 0x20,
+ resLocked = 0x10,
+ resProtected = 8,
+ resPreload = 4,
+ resChanged = 2
+};
+
+#ifdef __MWERKS__
+#pragma options align=mac68k
+#endif
typedef struct {
char sysdata[66];
char type[4];
@@ -26,48 +30,65 @@ typedef struct {
char appdata[128];
} MemRsrcSysData; // assumed name
-// base is 0,49, ptr is 0,62, ptrptr is 0,63
-typedef struct MemRsrcMap {
- SInt16 refnum;
- UInt16 fork_attr;
- MemRsrcTypeList *type_list;
- MemRsrcSysData sys_data;
- struct MemRsrcMap *prev;
-} MemRsrcMap;
-
-typedef struct {
+typedef struct { // Resource Header
UInt32 data_offs;
UInt32 map_offs;
UInt32 data_len;
UInt32 map_len;
} Ty70;
-typedef struct {
+typedef struct { // Resource Map
Ty70 mem_hdr;
- Handle mem_next_map_handle;
+ Handle mem_next_map_handle; // fixme for 64-bit probably
SInt16 mem_refnum;
- UInt16 fork_addr;
+ UInt16 fork_attr;
UInt16 typelist_offs;
UInt16 namelist_offs;
UInt16 types_idx;
} Ty73;
-typedef struct {
+typedef struct { // Resource Type List Item
OSType type;
UInt16 rsrc_idx;
UInt16 ref_list_offs;
} Ty75;
-typedef struct {
+typedef struct { // Reference List Item
UInt16 id;
UInt16 name_offs;
unsigned char attr;
unsigned char data_offs[3];
Handle mem_rsrc_handle;
} Ty77;
-typedef struct {
+typedef struct { // Name List Item
unsigned char len;
} Ty80;
-typedef struct {
+typedef struct { // Resource
UInt32 len;
} Ty82;
+#ifdef __MWERKS__
+#pragma options align=reset
+#endif
+
+typedef struct MemRefList {
+ UInt16 id;
+ OSType type;
+ StringPtr name;
+ unsigned char attr;
+ Handle hand;
+ struct MemRefList *next;
+} MemRefList;
+
+typedef struct MemRsrcTypeList {
+ OSType type;
+ MemRefList *ref_list;
+ struct MemRsrcTypeList *next;
+} MemRsrcTypeList;
+
+typedef struct MemRsrcMap {
+ SInt16 refnum;
+ UInt16 fork_attr;
+ MemRsrcTypeList *type_list;
+ MemRsrcSysData sys_data;
+ struct MemRsrcMap *prev;
+} MemRsrcMap;
typedef struct ResRef {
OSSpec spec;
@@ -95,6 +116,7 @@ void OS_UseMacResourceForkInfo(Boolean which) {
}
OSErr SystemInitResources(OSSpec *spec) {
+ FSSpec prog;
void *file_data;
SInt32 file_len;
@@ -107,7 +129,6 @@ OSErr SystemInitResources(OSSpec *spec) {
resError = noErr;
return noErr;
} else {
- FSSpec prog;
if (!OS_OSSpec_To_FSSpec(spec, &prog) && !FSpOpenResFile(&prog, 1)) {
resError = noErr;
return noErr;
@@ -118,9 +139,9 @@ OSErr SystemInitResources(OSSpec *spec) {
}
}
-static MemRsrcMap *NewResourceMap(SInt16 ref, UInt16 attr, MemRsrcTypeList *list) {
- MemRsrcMap *nw;
+static MemRsrcMap *NewResourceMap(SInt16 ref, UInt16 attr, MemRsrcTypeList *list, void *unk) {
MemRsrcMap **scan;
+ MemRsrcMap *nw;
scan = &maplist;
nw = malloc(sizeof(MemRsrcMap));
@@ -158,9 +179,9 @@ static MemRsrcTypeList *NewTypeListEntry(MemRsrcTypeList **scan, OSType type, Me
}
static MemRefList *NewRefListEntry(MemRefList **scan, UInt16 id, OSType type, StringPtr name, unsigned char attr, Handle hand) {
- char mname[256];
MemRefList *prev;
MemRefList *nw;
+ char mname[256];
prev = 0;
if (name)
@@ -252,35 +273,154 @@ static void DeleteResources(SInt16 refNum) {
}
}
+#define RF_READ(buf, offset, count, failBranch) \
+do { \
+SInt32 __offs = (offset); \
+if (!file_data) { \
+if ((resError = SetFPos(ref, fsFromStart, __offs)) != noErr) goto failBranch; \
+if ((resError = FSRead(ref, (SInt32 *) &(count), buf)) != noErr) goto failBranch; \
+} else { \
+if ((__offs + (count)) > file_size) goto failBranch; \
+memcpy(buf, ((unsigned char *) file_data) + __offs, (count)); \
+} \
+} while(0)
+
static void ReadResourceFork(SInt16 ref, SInt8 permission, void *file_data, SInt32 file_size) {
- unsigned char *nameptr;
- unsigned char *name;
- Handle hand;
- SInt32 offs;
- SInt32 esize;
- Ty82 tent;
- MemRsrcTypeList *mtyp;
- int rcnt;
- SInt32 ref_offs;
- SInt32 cnt;
- SInt32 msize;
- void *buffer;
- Ty80 *dnam;
- Ty77 *drle;
- Ty75 *dtyp;
- Ty73 *dmap;
- MemRsrcSysData *dsys;
- MemRsrcSysData tsys;
- Ty70 *dhdr;
- Ty70 thdr;
MemRsrcMap *rm;
+ Ty70 thdr;
+ Ty70 *dhdr;
+ MemRsrcSysData tsys;
+ MemRsrcSysData *dsys;
+ Ty73 *dmap;
+ Ty75 *dtyp;
+ Ty77 *drle;
+ Ty80 *dnam;
+ void *buffer;
+ SInt32 msize;
+ SInt32 cnt;
+ SInt32 ref_offs;
+ int rcnt;
+ MemRsrcTypeList *mtyp;
+ Ty82 tent;
+ SInt32 esize;
+ SInt32 offs;
+ Handle hand;
+ unsigned char *name;
+ unsigned char *nameptr;
+
+ if (!file_data) {
+ if ((resError = GetEOF(ref, &file_size)) != noErr)
+ goto mapFail;
+ }
+
+ if (file_size < 90)
+ goto mapFail;
+
+ cnt = sizeof(Ty70);
+ RF_READ(&thdr, 0, cnt, mapFail);
+
+ ref_offs = cnt;
+ cnt = ((thdr.map_offs < thdr.data_offs) ? thdr.map_offs : thdr.data_offs) - sizeof(Ty70);
+ if (cnt > sizeof(MemRsrcSysData))
+ cnt = sizeof(MemRsrcSysData);
+ RF_READ(&tsys, ref_offs, cnt, mapFail);
+
+ msize = thdr.map_len;
+ buffer = malloc(msize);
+ if (!buffer)
+ goto memFail;
+
+ ref_offs = thdr.map_offs;
+ RF_READ(buffer, ref_offs, msize, mapFail);
+
+ if (
+ (thdr.map_offs > file_size)
+ || ((thdr.map_offs + thdr.map_len) > file_size)
+ || (thdr.data_offs > file_size)
+ || ((thdr.data_offs + thdr.data_len) > file_size)
+ || ((thdr.map_offs < thdr.data_offs) ? ((thdr.map_offs + thdr.map_len) != thdr.data_offs) : ((thdr.data_offs + thdr.data_len) != thdr.map_offs))
+ )
+ goto mapFail;
+
+ rm = NewResourceMap(ref, ((permission == 1) ? mapReadOnly : 0) | mapCompact, 0, 0);
+ if (!rm)
+ goto memFail;
+
+ rm->sys_data = tsys;
+
+ dmap = (Ty73 *) buffer;
+ if ((dmap->typelist_offs + thdr.map_offs) > file_size)
+ goto freeAndMapFail;
+ dtyp = (Ty75 *) (((unsigned char *) buffer) + dmap->typelist_offs + 2);
+ if ((dmap->namelist_offs + thdr.map_offs) > file_size)
+ goto freeAndMapFail;
+ dnam = (Ty80 *) (((unsigned char *) buffer) + dmap->namelist_offs);
+ if (dmap->types_idx != 0xFFFF) {
+ for (cnt = 0; cnt <= dmap->types_idx; cnt++) {
+ mtyp = NewTypeListEntry(&rm->type_list, dtyp[cnt].type, 0, 0);
+ if (!mtyp)
+ goto freeAndReturn;
+
+ if ((thdr.map_offs + dmap->typelist_offs + dtyp[cnt].ref_list_offs) > file_size)
+ goto freeAndMapFail;
+
+ drle = (Ty77 *) (((unsigned char *) dtyp) + dtyp[cnt].ref_list_offs - 2);
+ if (dtyp[cnt].rsrc_idx != 0xFFFF) {
+ for (rcnt = 0; rcnt <= dtyp[cnt].rsrc_idx; rcnt++) {
+ ref_offs = (drle[rcnt].data_offs[0] << 16) | (drle[rcnt].data_offs[1] << 8) | drle[rcnt].data_offs[2];
+ offs = thdr.data_offs + ref_offs;
+ if (offs > file_size)
+ goto freeAndMapFail;
+ esize = 4;
+ RF_READ(&tent, offs, esize, freeAndMapFail);
+
+ offs += esize;
+ if ((thdr.data_offs + ref_offs + tent.len) > file_size)
+ goto freeAndMapFail;
+
+ hand = NewHandle(tent.len);
+ if (!hand)
+ goto freeAndMapFail;
+
+ HLock(hand);
+ RF_READ(*hand, offs, tent.len, freeAndMapFail);
+ HUnlock(hand);
+
+ if (drle[rcnt].name_offs != 0xFFFF) {
+ nameptr = (StringPtr) (dnam + drle[rcnt].name_offs);
+ name = malloc(nameptr[0] + 1);
+ memcpy(name, nameptr, nameptr[0] + 1);
+ } else {
+ name = 0;
+ }
+
+ if (!NewRefListEntry(&mtyp->ref_list, drle[rcnt].id, dtyp[cnt].type, name, drle[rcnt].attr, hand))
+ goto freeAndReturn;
+ }
+ }
+ }
+ }
- // Not Right Now Folk's
+ free(buffer);
+ resError = noErr;
+ return;
+freeAndMapFail:
+ resError = mapReadErr;
+freeAndReturn:
+ DeleteResources(ref);
+ if (buffer)
+ free(buffer);
+ return;
+memFail:
+ resError = memFullErr;
+ return;
+mapFail:
+ resError = mapReadErr;
}
static void GetResourceSizes(MemRsrcMap *rm, SInt32 *data_size, SInt32 *name_size, SInt32 *reflist_size, SInt32 *typelist_size) {
- MemRefList *mrle;
MemRsrcTypeList *mtyp;
+ MemRefList *mrle;
*data_size = *name_size = *reflist_size = *typelist_size = 0;
@@ -299,8 +439,8 @@ static void GetResourceSizes(MemRsrcMap *rm, SInt32 *data_size, SInt32 *name_siz
}
static SInt32 GetResourceTypesCount(MemRsrcMap *dm) {
- MemRsrcTypeList *mtyp;
SInt32 tmp;
+ MemRsrcTypeList *mtyp;
tmp = 0;
mtyp = dm->type_list;
@@ -313,8 +453,8 @@ static SInt32 GetResourceTypesCount(MemRsrcMap *dm) {
}
static SInt32 GetResourceEntriesCount(MemRsrcTypeList *mtyp) {
- MemRefList *mrle;
SInt32 tmp;
+ MemRefList *mrle;
tmp = 0;
mrle = mtyp->ref_list;
@@ -326,52 +466,207 @@ static SInt32 GetResourceEntriesCount(MemRsrcTypeList *mtyp) {
return tmp;
}
+#define RF_HANDLE_INSERT(hand, what, offset, size) \
+do { \
+SInt32 __offs = (offset); \
+SInt32 __len = (size); \
+if ((SInt32) (__offs + __len) > GetHandleSize(hand)) { \
+resError = mapReadErr; \
+return; \
+} else { \
+memcpy(*hand + __offs, (what), __len); \
+} \
+} \
+while (0)
+
static void WriteResourceFork(SInt16 ref) {
- // some weird shit going on with locals here
- // there's probably a bunch of macros
- // may be able to refer to the Windows binary for assert values
- SInt32 sz;
- SInt32 __len;
- SInt32 __offs;
- SInt32 __offs_2;
- SInt32 __len_2;
- SInt32 __offs_3;
- SInt32 __offs_4;
- Ty82 tent;
- Ty82 dent;
- Ty77 trle;
- Ty77 drle;
- SInt32 __offs_5;
- MemRefList *mrle;
- Ty75 ttyp;
- Ty75 dtyp;
- MemRsrcTypeList *mtyp;
- SInt32 __offs_6;
- SInt32 data_offs;
- SInt32 name_offs;
- SInt32 typelist_offs;
- SInt32 reflist_offs;
- SInt32 data_size;
- SInt32 name_size;
- SInt32 typelist_size;
- SInt32 reflist_size;
- Handle hand_ref;
- Ty73 tmap;
- Ty73 dmap;
- MemRsrcSysData tsys;
- Ty70 thdr;
- Ty70 dhdr;
MemRsrcMap *rm;
+ Ty70 dhdr;
+ Ty70 thdr;
+ MemRsrcSysData tsys;
+ Ty73 dmap;
+ Ty73 tmap;
+ Handle hand_ref;
+ SInt32 reflist_size, typelist_size;
+ SInt32 name_size, data_size;
+ SInt32 reflist_offs, typelist_offs;
+ SInt32 name_offs, data_offs;
+ MemRsrcTypeList *mtyp;
+ Ty75 dtyp;
+ Ty75 ttyp;
+ MemRefList *mrle;
+ Ty77 drle;
+ Ty77 trle;
+ Ty82 dent;
+ Ty82 tent;
+ SInt32 sz;
+
+ rm = FindResourceMap(ref);
+ if (!rm) {
+ resError = resFNotFound;
+ return;
+ }
+
+ if (rm->refnum == -1) {
+ resError = resFNotFound;
+ return;
+ }
+
+ if (rm->fork_attr & mapReadOnly) {
+ resError = resAttrErr;
+ return;
+ }
+
+ if (!(rm->fork_attr & mapChanged)) {
+ return;
+ }
+
+ GetResourceSizes(rm, &data_size, &name_size, &reflist_size, &typelist_size);
+ dhdr.data_offs = sizeof(dhdr) + sizeof(tsys);
+ dhdr.data_len = data_size;
+ dhdr.map_offs = sizeof(dhdr) + sizeof(tsys) + data_size;
+ dhdr.map_len = name_size + reflist_size + typelist_size + sizeof(dmap);
+
+ hand_ref = NewHandle(dhdr.map_offs + dhdr.map_len);
+ if (!hand_ref) {
+ resError = MemError();
+ return;
+ }
+
+ HLock(hand_ref);
+ memset(*hand_ref, 0, dhdr.map_offs + dhdr.map_len);
+ thdr = dhdr;
+ // This is where it would be endian-swapped i guess
+ RF_HANDLE_INSERT(hand_ref, &thdr, 0, sizeof(thdr));
+
+ tsys = rm->sys_data;
+ RF_HANDLE_INSERT(hand_ref, &tsys, sizeof(thdr), sizeof(tsys));
+
+ dmap.mem_hdr = thdr;
+ dmap.mem_next_map_handle = 0;
+ dmap.mem_refnum = 0;
+ dmap.fork_attr = rm->fork_attr & ~resChanged; // bug! should be mapChanged
+ dmap.typelist_offs = sizeof(dmap) - 2;
+ dmap.namelist_offs = typelist_size + reflist_size + sizeof(dmap);
+ dmap.types_idx = GetResourceTypesCount(rm) - 1;
+ tmap = dmap;
+ RF_HANDLE_INSERT(hand_ref, &tmap, dhdr.map_offs, sizeof(tmap));
+
+ // Now write the actual shit
+ name_offs = 0;
+ data_offs = 0;
+ reflist_offs = 0;
+ typelist_offs = 0;
+ mtyp = rm->type_list;
+ while (mtyp) {
+ dtyp.type = mtyp->type;
+ dtyp.rsrc_idx = GetResourceEntriesCount(mtyp) - 1;
+ dtyp.ref_list_offs = typelist_size + reflist_offs + 2;
+ ttyp = dtyp;
+ RF_HANDLE_INSERT(hand_ref, &ttyp, (dhdr.map_offs + dmap.typelist_offs + 2) + typelist_offs, sizeof(ttyp));
+
+ mrle = mtyp->ref_list;
+ while (mrle) {
+#line 943
+ OPTION_ASSERT(reflist_offs < dmap.namelist_offs);
+
+ drle.id = mrle->id;
+ drle.name_offs = (mrle->name) ? name_offs : -1;
+ drle.attr = mrle->attr & ~resChanged;
+ drle.data_offs[0] = (data_offs & 0xFF0000) >> 16;
+ drle.data_offs[1] = (data_offs & 0x00FF00) >> 8;
+ drle.data_offs[2] = (data_offs & 0x0000FF);
+ drle.mem_rsrc_handle = 0;
+ trle = drle;
+ RF_HANDLE_INSERT(hand_ref, &trle, (dhdr.map_offs + dmap.typelist_offs + 2) + typelist_size + reflist_offs, sizeof(trle));
+
+ reflist_offs += sizeof(trle);
+ if (mrle->name) {
+#line 962
+ if (dhdr.map_offs < dhdr.data_offs)
+ OPTION_ASSERT(name_offs + dmap.namelist_offs + dhdr.map_offs < dhdr.data_offs);
+ RF_HANDLE_INSERT(hand_ref, mrle->name, dhdr.map_offs + dmap.namelist_offs + drle.name_offs, mrle->name[0] + 1);
+ name_offs += mrle->name[0] + 1;
+ }
+
+#line 970
+ OPTION_ASSERT(data_offs < dhdr.data_len);
+ OPTION_ASSERT(mrle->hand!=NULL);
+ if (dhdr.map_offs > dhdr.data_offs)
+ OPTION_ASSERT(data_offs + dhdr.data_offs < dhdr.map_offs);
+
+ HLock(mrle->hand);
+ dent.len = GetHandleSize(mrle->hand);
+ tent = dent;
+ RF_HANDLE_INSERT(hand_ref, &tent, dhdr.data_offs + data_offs, sizeof(tent));
+ data_offs += sizeof(tent);
+ RF_HANDLE_INSERT(hand_ref, *mrle->hand, dhdr.data_offs + data_offs, dent.len);
+ data_offs += dent.len;
+ HUnlock(mrle->hand);
+
+ mrle = mrle->next;
+ }
+
+ mtyp = mtyp->next;
+ typelist_offs += sizeof(ttyp);
+ }
+
+ sz = GetHandleSize(hand_ref);
+ if ((resError = SetFPos(ref, fsFromStart, 0)) != noErr)
+ return;
+ if ((resError = SetEOF(ref, sz)) != noErr)
+ return;
+ if ((resError = FSWrite(ref, &sz, *hand_ref)) != noErr)
+ return;
+ HUnlock(hand_ref);
+ DisposeHandle(hand_ref);
}
static void WriteEmptyResourceFork(SInt16 ref) {
- SInt32 sz;
- Handle hand_ref;
- Ty73 dmap;
- MemRsrcSysData dsys;
Ty70 dhdr;
+ MemRsrcSysData dsys;
+ Ty73 dmap;
+ Handle hand_ref;
+ SInt32 sz;
+
+ dhdr.map_offs = sizeof(dhdr) + sizeof(dsys);
+ dhdr.map_len = sizeof(dmap);
+ dhdr.data_offs = sizeof(dhdr) + sizeof(dsys) + sizeof(dmap);
+ dhdr.data_len = 0;
+
+ memset(&dsys, 0, sizeof(dsys));
+ memset(&dsys.creator, 0, sizeof(dsys.creator));
+ memset(&dsys.type, 0, sizeof(dsys.type));
+
+ dmap.mem_hdr = dhdr;
+ dmap.mem_next_map_handle = 0;
+ dmap.mem_refnum = 0;
+ dmap.fork_attr = 0;
+ dmap.typelist_offs = sizeof(dmap) - 2;
+ dmap.namelist_offs = sizeof(dmap) - 2;
+ dmap.types_idx = 0xFFFF;
+
+ hand_ref = NewHandle(sizeof(dhdr) + sizeof(dsys) + sizeof(dmap));
+ if (!hand_ref) {
+ resError = MemError();
+ return;
+ }
- // i'll do this one later lol
+ HLock(hand_ref);
+ memset(*hand_ref, 0, sizeof(dhdr) + sizeof(dsys) + sizeof(dmap));
+ RF_HANDLE_INSERT(hand_ref, &dhdr, 0, sizeof(dhdr));
+ RF_HANDLE_INSERT(hand_ref, &dsys, sizeof(dhdr), sizeof(dsys));
+ RF_HANDLE_INSERT(hand_ref, &dmap, sizeof(dhdr) + sizeof(dsys), sizeof(dmap));
+
+ sz = GetHandleSize(hand_ref);
+ if ((resError = SetFPos(ref, fsFromStart, 0)) != noErr)
+ return;
+ if ((resError = SetEOF(ref, sz)) != noErr)
+ return;
+ if ((resError = FSWrite(ref, &sz, *hand_ref)) != noErr)
+ return;
+ HUnlock(hand_ref);
+ DisposeHandle(hand_ref);
}
static MemRsrcTypeList *FindResourceType1(MemRsrcMap *rm, OSType theType) {
@@ -416,8 +711,8 @@ static SInt32 CountResourceType(OSType theType) {
}
static MemRefList *FindIndResource1(MemRsrcMap *rm, OSType theType, SInt16 index) {
- MemRefList *mrle;
MemRsrcTypeList *mtyp;
+ MemRefList *mrle;
mtyp = rm->type_list;
while (mtyp) {
@@ -435,8 +730,8 @@ static MemRefList *FindIndResource1(MemRsrcMap *rm, OSType theType, SInt16 index
}
static MemRefList *FindIndResource(OSType theType, SInt16 index) {
- MemRefList *mrle;
MemRsrcMap *rm = FindResourceMap(cur_res_file);
+ MemRefList *mrle;
while (rm) {
mrle = FindIndResource1(rm, theType, index);
@@ -449,8 +744,8 @@ static MemRefList *FindIndResource(OSType theType, SInt16 index) {
}
static MemRefList *FindResourceTypeAndID1(MemRsrcMap *rm, OSType theType, SInt16 theID) {
- MemRefList *mref;
MemRsrcTypeList *mtyp = FindResourceType1(rm, theType);
+ MemRefList *mref;
if (mtyp) {
mref = mtyp->ref_list;
@@ -465,8 +760,8 @@ static MemRefList *FindResourceTypeAndID1(MemRsrcMap *rm, OSType theType, SInt16
}
static MemRefList *FindResourceTypeAndID(OSType theType, SInt16 theID) {
- MemRefList *mref;
MemRsrcMap *rm = FindResourceMap(cur_res_file);
+ MemRefList *mref;
while (rm) {
mref = FindResourceTypeAndID1(rm, theType, theID);
@@ -479,8 +774,8 @@ static MemRefList *FindResourceTypeAndID(OSType theType, SInt16 theID) {
}
static MemRefList *FindResourceTypeAndName1(MemRsrcMap *rm, OSType theType, ConstStringPtr theName) {
- MemRefList *mref;
MemRsrcTypeList *mtyp;
+ MemRefList *mref;
mtyp = FindResourceType1(rm, theType);
if (mtyp) {
@@ -496,8 +791,8 @@ static MemRefList *FindResourceTypeAndName1(MemRsrcMap *rm, OSType theType, Cons
}
static MemRefList *FindResourceTypeAndName(OSType theType, ConstStringPtr theName) {
- MemRefList *mref;
MemRsrcMap *rm = FindResourceMap(cur_res_file);
+ MemRefList *mref;
while (rm) {
mref = FindResourceTypeAndName1(rm, theType, theName);
@@ -510,8 +805,8 @@ static MemRefList *FindResourceTypeAndName(OSType theType, ConstStringPtr theNam
}
static MemRefList *FindResourceHandle1(MemRsrcMap *rm, Handle theResource) {
- MemRefList *mrle;
MemRsrcTypeList *mtyp;
+ MemRefList *mrle;
for (mtyp = rm->type_list; mtyp; mtyp = mtyp->next) {
for (mrle = mtyp->ref_list; mrle; mrle = mrle->next) {
@@ -524,8 +819,8 @@ static MemRefList *FindResourceHandle1(MemRsrcMap *rm, Handle theResource) {
}
static MemRefList *FindResourceHandle(Handle theResource) {
- MemRefList *mrle;
MemRsrcMap *rm;
+ MemRefList *mrle;
for (rm = FindResourceMap(cur_res_file); rm; rm = rm->prev) {
mrle = FindResourceHandle1(rm, theResource);
@@ -537,8 +832,8 @@ static MemRefList *FindResourceHandle(Handle theResource) {
}
static int RemoveResourceHandle1(MemRsrcMap *rm, Handle theResource) {
- MemRefList *mrle, *pmrle;
MemRsrcTypeList *mtyp, *pmtyp;
+ MemRefList *mrle, *pmrle;
mtyp = rm->type_list;
pmtyp = 0;
@@ -586,37 +881,102 @@ static int RemoveResourceHandle(Handle theResource) {
}
static SInt16 FindResourceHandleFile1(MemRsrcMap *rm, Handle theResource) {
- MemRefList *mrle;
MemRsrcTypeList *mtyp;
+ MemRefList *mrle;
+
+ for (mtyp = rm->type_list; mtyp; mtyp = mtyp->next) {
+ for (mrle = mtyp->ref_list; mrle; mrle = mrle->next) {
+ if (mrle->hand == theResource)
+ return rm->refnum;
+ }
+ }
+
+ return -1;
}
static SInt16 FindResourceHandleFile(Handle theResource) {
- MemRefList *mrle;
MemRsrcMap *rm;
+ MemRefList *mrle;
+
+ for (rm = FindResourceMap(cur_res_file); rm; rm = rm->prev) {
+ mrle = FindResourceHandle1(rm, theResource);
+ if (mrle)
+ return rm->refnum;
+ }
+
+ return -1;
}
void OS_AddMacResourceForkRef(int ref, const OSSpec *spec) {
ResRef *nw;
+
+ nw = malloc(sizeof(ResRef));
+ if (nw) {
+ nw->spec = *spec;
+ nw->ref = ref;
+ nw->next = 0;
+ if (resForkLast)
+ resForkLast->next = nw;
+ else
+ resForkList = nw;
+ resForkLast = nw;
+ }
}
void OS_RemoveMacResourceForkRef(int ref) {
- ResRef *prev;
ResRef *lst;
+ ResRef *prev;
+
+ lst = resForkList;
+ prev = 0;
+ while (lst && lst->ref != ref) {
+ prev = lst;
+ lst = lst->next;
+ }
+
+ if (lst) {
+ if (prev) {
+ prev->next = lst->next;
+ if (!prev->next)
+ resForkLast = prev;
+ } else {
+ resForkList = lst->next;
+ if (!resForkList)
+ resForkLast = 0;
+ }
+ free(lst);
+ }
}
OSSpec *OS_GetMacResourceForkFromRef(int ref) {
ResRef *lst;
+
+ for (lst = resForkList; lst; lst = lst->next) {
+ if (lst->ref == ref)
+ return &lst->spec;
+ }
+
+ return 0;
}
Boolean OS_SearchMacResourceForkList(const OSSpec *rspec, int *ref) {
ResRef *lst;
+
+ for (lst = resForkList; lst; lst = lst->next) {
+ if (OS_EqualSpec(&lst->spec, rspec)) {
+ *ref = lst->ref;
+ return 1;
+ }
+ }
+
+ return 0;
}
int OS_SetMacResourceForkCreatorAndType(int ref, OSType creator, OSType type) {
- MemRsrcMap *rm;
- UInt32 sz;
- UInt32 buf[2];
int err;
+ UInt32 buf[2];
+ UInt32 sz;
+ MemRsrcMap *rm;
if (!OS_GetMacResourceForkFromRef(ref)) {
sz = 8;
@@ -633,7 +993,7 @@ int OS_SetMacResourceForkCreatorAndType(int ref, OSType creator, OSType type) {
rm = FindResourceMap(OS_RefToMac(ref));
if (!rm) {
err = 2;
- } else if (rm->fork_attr & 0x80) {
+ } else if (rm->fork_attr & mapReadOnly) {
err = 13;
} else {
rm->sys_data.creator[0] = (creator & 0xFF000000) >> 24;
@@ -644,7 +1004,7 @@ int OS_SetMacResourceForkCreatorAndType(int ref, OSType creator, OSType type) {
rm->sys_data.type[1] = (type & 0x00FF0000) >> 16;
rm->sys_data.type[2] = (type & 0x0000FF00) >> 8;
rm->sys_data.type[3] = (type & 0x000000FF);
- rm->fork_attr |= 0x20;
+ rm->fork_attr |= mapChanged;
err = 0;
}
}
@@ -653,10 +1013,10 @@ int OS_SetMacResourceForkCreatorAndType(int ref, OSType creator, OSType type) {
}
int OS_GetMacResourceForkCreatorAndType(int ref, OSType *creator, OSType *type) {
- MemRsrcMap *rm;
- UInt32 sz;
- UInt32 buf[2];
int err;
+ UInt32 buf[2];
+ UInt32 sz;
+ MemRsrcMap *rm;
if (!OS_GetMacResourceForkFromRef(ref)) {
sz = 8;
@@ -688,28 +1048,109 @@ void OS_CleanupMacResourceForkDir(const OSPathSpec *dir) {
}
OSErr OS_MacDumpResourceFork(SInt16 ref, Boolean dumpContents) {
- int spaces;
- char safe[16];
- SInt32 size;
- SInt32 idx;
- StringPtr ptr;
- char name[256];
- MemRefList *rl;
- MemRsrcTypeList *tl;
MemRsrcMap *rm;
+ MemRsrcTypeList *tl;
+ MemRefList *rl;
+ char name[256];
+ unsigned char *ptr;
+ SInt32 idx;
+ SInt32 size;
+ char safe[16];
+ int spaces;
+
+ rm = FindResourceMap(ref);
+ if (!rm) {
+ fprintf(stderr, "Could not find resource fork for ref = %d\n", ref);
+ return fnfErr;
+ }
+
+ printf("Fork attributes = %04X\n", rm->fork_attr);
+ printf("Creator = '%4.4s'; Type = '%4.4s'\n", rm->sys_data.creator, rm->sys_data.type);
+ printf("Types:\n");
+
+ for (tl = rm->type_list; tl; tl = tl->next) {
+ printf("'%c%c%c%c':\n",
+ (tl->type & 0xFF000000) >> 24,
+ (tl->type & 0x00FF0000) >> 16,
+ (tl->type & 0x0000FF00) >> 8,
+ (tl->type & 0x000000FF)
+ );
+ for (rl = tl->ref_list; rl; rl = rl->next) {
+ if (rl->type != tl->type)
+ printf("!!! RefList type '%c%c%c%c' does not match TypeList type !!!\n",
+ (rl->type & 0xFF000000) >> 24,
+ (rl->type & 0x00FF0000) >> 16,
+ (rl->type & 0x0000FF00) >> 8,
+ (rl->type & 0x000000FF)
+ );
+
+ if (rl->name)
+ p2cstrcpy(name, rl->name);
+ else
+ strcpy(name, "<none>");
+
+ printf("\tID = %d '%s'\n", rl->id, name);
+ printf("\tAttributes: ");
+ if (rl->attr & resSysHeap)
+ printf("SysHeap ");
+ if (rl->attr & resPurgeable)
+ printf("Purgeable ");
+ if (rl->attr & resLocked)
+ printf("Locked ");
+ if (rl->attr & resProtected)
+ printf("Protected ");
+ if (rl->attr & resPreload)
+ printf("Preload ");
+ if (rl->attr & resChanged)
+ printf("Changed ");
+ printf("\n");
+
+ if (dumpContents) {
+ size = GetHandleSize(rl->hand);
+ HLock(rl->hand);
+ ptr = (unsigned char *) *rl->hand;
+ idx = 0;
+ printf("Contents:");
+
+ while (idx < size) {
+ if ((idx % 16) == 0) {
+ printf("\n%08X: ", idx);
+ memset(safe, ' ', 16);
+ }
+ printf("%02X ", ptr[idx]);
+ if (isprint(ptr[idx]))
+ safe[idx & 15] = ptr[idx];
+ else
+ safe[idx & 15] = '.';
+
+ if (((idx % 16) == 15) || (idx + 1) == size) {
+ spaces = (((idx & 15) + 15) & ~15) - (idx & 15);
+ while (spaces--)
+ printf(" ");
+ printf(" %16.16s", safe);
+ }
+
+ ++idx;
+ }
+
+ printf("\n");
+ }
+ }
+ }
- // Debug shit
+ printf("\n");
+ CloseResFile(ref);
+ return noErr;
}
OSErr FSpOpenRF(const FSSpec *fss, SInt8 permission, SInt16 *refNum) {
- Boolean create;
- OSSpec rspec;
- OSSpec spec;
- FSSpec rfss;
- int oserr;
OSErr err;
+ int oserr;
+ FSSpec rfss;
+ OSSpec spec, rspec;
+ Boolean create;
- create = (permission == 1) | (permission > 1);
+ create = (permission != fsRdPerm);
oserr = OS_FSSpec_To_OSSpec(fss, &spec);
if (oserr)
return OS_MacError(oserr);
@@ -733,8 +1174,8 @@ OSErr FSpOpenRF(const FSSpec *fss, SInt8 permission, SInt16 *refNum) {
}
OSErr HOpenRF(SInt16 vRefNum, SInt32 dirID, ConstStringPtr fileName, SInt8 permission, SInt16 *refNum) {
- OSErr __err;
FSSpec fss;
+ OSErr __err;
__err = FSMakeFSSpec(vRefNum, dirID, fileName, &fss);
if (__err != noErr && __err != fnfErr) {
@@ -764,9 +1205,9 @@ OSErr ResError() {
}
void FSpCreateResFile(const FSSpec *fss, OSType creator, OSType fileType, ScriptCode scriptTag) {
- SInt16 ref;
- OSSpec spec, rspec;
int oserr;
+ OSSpec spec, rspec;
+ SInt16 ref;
FSpCreate(fss, creator, fileType, scriptTag);
oserr = OS_FSSpec_To_OSSpec(fss, &spec);
@@ -800,8 +1241,8 @@ void FSpCreateResFile(const FSSpec *fss, OSType creator, OSType fileType, Script
}
void HCreateResFile(SInt16 vRefNum, SInt32 dirID, ConstStringPtr fileName) {
- OSErr __err;
FSSpec fss;
+ OSErr __err;
__err = FSMakeFSSpec(vRefNum, dirID, fileName, &fss);
if (__err != noErr && __err != fnfErr) {
@@ -812,16 +1253,16 @@ void HCreateResFile(SInt16 vRefNum, SInt32 dirID, ConstStringPtr fileName) {
}
OSErr FSpOpenResFile(const FSSpec *fss, SInt8 permission) {
- SInt32 size;
SInt16 ref;
+ SInt32 size;
- if (permission != 1)
+ if (permission != fsRdPerm)
FSpCreate(fss, 'CWIE', 'TEXT', -1);
- resError = FSpOpenRF(fss, (permission != 2) ? permission : 3, &ref);
+ resError = FSpOpenRF(fss, (permission == fsWrPerm) ? fsRdWrPerm : permission, &ref);
if (!resError) {
GetEOF(ref, &size);
- if (size == 0 && permission != 1)
+ if (size == 0 && permission != fsRdPerm)
WriteEmptyResourceFork(ref);
ReadResourceFork(ref, permission, 0, 0);
if (resError) {
@@ -838,8 +1279,8 @@ OSErr FSpOpenResFile(const FSSpec *fss, SInt8 permission) {
}
OSErr HOpenResFile(SInt16 vRefNum, SInt32 dirID, ConstStringPtr fileName, SInt8 permission) {
- OSErr __err;
FSSpec fss;
+ OSErr __err;
__err = FSMakeFSSpec(vRefNum, dirID, fileName, &fss);
if (__err != noErr && __err != fnfErr)
@@ -885,8 +1326,8 @@ Handle GetResource(OSType theType, SInt16 theID) {
}
Handle Get1Resource(OSType theType, SInt16 theID) {
- MemRefList *mref;
MemRsrcMap *rm;
+ MemRefList *mref;
rm = FindResourceMap(cur_res_file);
if (!rm) {
@@ -918,8 +1359,8 @@ Handle GetNamedResource(OSType theType, ConstStringPtr theName) {
}
Handle Get1NamedResource(OSType theType, ConstStringPtr theName) {
- MemRefList *mref;
MemRsrcMap *rm;
+ MemRefList *mref;
rm = FindResourceMap(cur_res_file);
if (!rm) {
@@ -971,7 +1412,7 @@ void SetResInfo(Handle theResource, SInt16 theID, ConstStringPtr name) {
if (mrle->name)
free(mrle->name);
mrle->name = malloc(name[0] + 1);
- mrle->attr |= 2;
+ mrle->attr |= resChanged;
if (mrle->name)
_pstrcpy(mrle->name, name);
else
@@ -1007,18 +1448,18 @@ void SetResAttrs(Handle theResource, SInt16 attrs) {
}
void ChangedResource(Handle theResource) {
- MemRefList *mrle;
MemRsrcMap *rm;
+ MemRefList *mrle;
rm = FindResourceMap(cur_res_file);
mrle = FindResourceHandle(theResource);
if (mrle) {
- if (rm && (rm->fork_attr & 0x80)) {
+ if (rm && (rm->fork_attr & mapReadOnly)) {
resError = resAttrErr;
} else {
resError = noErr;
- mrle->attr |= 2;
- rm->fork_attr |= 0x20;
+ mrle->attr |= resChanged;
+ rm->fork_attr |= mapChanged;
}
} else {
resError = resNotFound;
@@ -1033,7 +1474,7 @@ void AddResource(Handle theData, OSType theType, SInt16 theID, ConstStringPtr na
rm = FindResourceMap(cur_res_file);
if (rm) {
- if (rm->fork_attr & 0x80) {
+ if (rm->fork_attr & mapReadOnly) {
resError = resAttrErr;
return;
}
@@ -1046,7 +1487,7 @@ void AddResource(Handle theData, OSType theType, SInt16 theID, ConstStringPtr na
resError = memFullErr;
return;
}
- rm->fork_attr |= 0x20;
+ rm->fork_attr |= mapChanged;
}
if (!theData || FindResourceHandle(theData)) {
resError = addResFailed;
@@ -1066,7 +1507,7 @@ void AddResource(Handle theData, OSType theType, SInt16 theID, ConstStringPtr na
return;
}
- rm->fork_attr |= 0x20;
+ rm->fork_attr |= mapChanged;
} else {
resError = resFNotFound;
}
@@ -1109,8 +1550,8 @@ Handle GetIndResource(OSType theType, SInt16 index) {
}
Handle Get1IndResource(OSType theType, SInt16 index) {
- MemRefList *mrle;
MemRsrcMap *rm;
+ MemRefList *mrle;
rm = FindResourceMap(cur_res_file);
if (rm) {
@@ -1129,9 +1570,9 @@ Handle Get1IndResource(OSType theType, SInt16 index) {
}
SInt16 Count1Types() {
- SInt16 count;
- MemRsrcTypeList *rtl;
MemRsrcMap *rm;
+ MemRsrcTypeList *rtl;
+ SInt16 count;
count = 0;
rm = FindResourceMap(cur_res_file);
@@ -1149,9 +1590,9 @@ SInt16 Count1Types() {
}
void Get1IndType(OSType *theType, SInt16 index) {
- SInt16 count;
- MemRsrcTypeList *rtl;
MemRsrcMap *rm;
+ MemRsrcTypeList *rtl;
+ SInt16 count;
count = 1;
rm = FindResourceMap(cur_res_file);
@@ -1175,8 +1616,8 @@ void ReleaseResource(Handle theResource) {
}
void DetachResource(Handle theResource) {
- SInt32 ns;
MemRefList *mrle;
+ SInt32 ns;
mrle = FindResourceHandle(theResource);
if (mrle) {
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-22 02:21:45 +0000