ViewVC Help

View File | Revision Log | Show Annotations | Revision Graph | Root Listing

root/cebix/BasiliskII/src/extfs.cpp

Comparing BasiliskII/src/extfs.cpp (file contents):
Revision 1.9 by cebix, 1999-11-03T10:56:14Z vs.
Revision 1.33 by asvitkine, 2007-01-24T02:37:06Z

#	Line 1 | Line 1
1		/*
2	<	*  extfs.cpp - MacOS file system for access native file system access
2	>	*  extfs.cpp - MacOS file system for native file system access
3		*
4	<	*  Basilisk II (C) 1997-1999 Christian Bauer
4	>	*  Basilisk II (C) 1997-2005 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
#	Line 40 | Line 40
40		#include <string.h>
41		#include <stdio.h>
42		#include <stdlib.h>
43	–	#include <unistd.h>
43		#include <fcntl.h>
45	–	#include <dirent.h>
44		#include <errno.h>
45
46	+	#ifndef WIN32
47	+	#include <unistd.h>
48	+	#include <dirent.h>
49	+	#endif
50	+
51	+	#if defined __APPLE__ && defined __MACH__
52	+	#include <sys/attr.h>
53	+	#endif
54	+
55		#include "cpu_emulation.h"
49	–	#include "macos_util.h"
56		#include "emul_op.h"
57		#include "main.h"
58		#include "disk.h"
#	Line 55 | Line 61
61		#include "extfs.h"
62		#include "extfs_defs.h"
63
64	+	#ifdef WIN32
65	+	# include "posix_emu.h"
66	+	#endif
67	+
68		#define DEBUG 0
69		#include "debug.h"
70
#	Line 65 | Line 75 | enum {
75		fsHFSProcStub = 6,
76		fsDrvStatus = 12,                               // Drive Status record
77		fsFSD = 42,                                             // File system descriptor
78	<	fsPB = 238,                                             // IOParam (for mounting and renaming)
78	>	fsPB = 238,                                             // IOParam (for mounting and renaming), also used for temporary storage
79		fsVMI = 288,                                    // VoumeMountInfoHeader (for mounting)
80		fsParseRec = 296,                               // ParsePathRec struct
81		fsReturn = 306,                                 // Area for return data of 68k routines
#	Line 101 | Line 111 | static bool ready = false;
111		static struct stat root_stat;
112
113		// File system ID/media type
114	<	const int16 MY_FSID = 'ba';
115	<	const uint32 MY_MEDIA_TYPE = 'basi';
114	>	const int16 MY_FSID = EMULATOR_ID_2;
115	>	const uint32 MY_MEDIA_TYPE = EMULATOR_ID_4;
116
117		// CNID of root and root's parent
118		const uint32 ROOT_ID = 2;
#	Line 111 | Line 121 | const uint32 ROOT_PARENT_ID = 1;
121		// File system stack size
122		const int STACK_SIZE = 0x10000;
123
124	+	// Allocation block and clump size as reported to MacOS (these are of course
125	+	// not the real values and have no meaning on the host OS)
126	+	const int AL_BLK_SIZE = 0x4000;
127	+	const int CLUMP_SIZE = 0x4000;
128	+
129		// Drive number of our pseudo-drive
130		static int drive_number;
131
#	Line 143 | Line 158 | struct FSItem {
158		uint32 id;                              // CNID of this file/dir
159		uint32 parent_id;               // CNID of parent file/dir
160		FSItem *parent;                 // Pointer to parent
161	<	char name[32];                  // Object name (C string)
161	>	char name[32];                  // Object name (C string) - Host OS
162	>	char guest_name[32];                    // Object name (C string) - Guest OS
163		time_t mtime;                   // Modification time for get_cat_info caching
164		int cache_dircount;             // Cached number of files in directory
165		};
#	Line 154 | Line 170 | static uint32 next_cnid = fsUsrCNID;   //
170
171
172		/*
173	+	*  Get object creation time
174	+	*/
175	+
176	+	#if defined __APPLE__ && defined __MACH__
177	+	struct crtimebuf {
178	+	unsigned long length;
179	+	struct timespec crtime;
180	+	};
181	+
182	+	static uint32 do_get_creation_time(const char *path)
183	+	{
184	+	struct attrlist attr;
185	+	memset(&attr, 0, sizeof(attr));
186	+	attr.bitmapcount = ATTR_BIT_MAP_COUNT;
187	+	attr.commonattr = ATTR_CMN_CRTIME;
188	+
189	+	crtimebuf buf;
190	+	if (getattrlist(path, &attr, &buf, sizeof(buf), FSOPT_NOFOLLOW) < 0)
191	+	return 0;
192	+	return TimeToMacTime(buf.crtime.tv_sec);
193	+	}
194	+
195	+	static uint32 get_creation_time(const char *path)
196	+	{
197	+	if (path == NULL)
198	+	return 0;
199	+	if (path == RootPath) {
200	+	static uint32 root_crtime = UINT_MAX;
201	+	if (root_crtime == UINT_MAX)
202	+	root_crtime = do_get_creation_time(path);
203	+	return root_crtime;
204	+	}
205	+	return do_get_creation_time(path);
206	+	}
207	+	#endif
208	+
209	+
210	+	/*
211		*  Find FSItem for given CNID
212		*/
213
#	Line 168 | Line 222 | static FSItem *find_fsitem_by_id(uint32
222		return NULL;
223		}
224
225	+	/*
226	+	*  Create FSItem with the given parameters
227	+	*/
228	+
229	+	static FSItem *create_fsitem(const char *name, const char *guest_name, FSItem *parent)
230	+	{
231	+	FSItem *p = new FSItem;
232	+	last_fs_item->next = p;
233	+	p->next = NULL;
234	+	last_fs_item = p;
235	+	p->id = next_cnid++;
236	+	p->parent_id = parent->id;
237	+	p->parent = parent;
238	+	strncpy(p->name, name, 31);
239	+	p->name[31] = 0;
240	+	strncpy(p->guest_name, guest_name, 31);
241	+	p->guest_name[31] = 0;
242	+	p->mtime = 0;
243	+	return p;
244	+	}
245
246		/*
247		*  Find FSItem for given name and parent, construct new FSItem if not found
#	Line 183 | Line 257 | static FSItem *find_fsitem(const char *n
257		}
258
259		// Not found, construct new FSItem
260	<	p = new FSItem;
187	<	last_fs_item->next = p;
188	<	p->next = NULL;
189	<	last_fs_item = p;
190	<	p->id = next_cnid++;
191	<	p->parent_id = parent->id;
192	<	p->parent = parent;
193	<	strncpy(p->name, name, 31);
194	<	p->name[31] = 0;
195	<	p->mtime = 0;
196	<	return p;
260	>	return create_fsitem(name, host_encoding_to_macroman(name), parent);
261		}
262
263	+	/*
264	+	*  Find FSItem for given guest_name and parent, construct new FSItem if not found
265	+	*/
266	+
267	+	static FSItem *find_fsitem_guest(const char *guest_name, FSItem *parent)
268	+	{
269	+	FSItem *p = first_fs_item;
270	+	while (p) {
271	+	if (p->parent == parent && !strcmp(p->guest_name, guest_name))
272	+	return p;
273	+	p = p->next;
274	+	}
275	+
276	+	// Not found, construct new FSItem
277	+	return create_fsitem(macroman_to_host_encoding(guest_name), guest_name, parent);
278	+	}
279
280		/*
281		*  Get full path (->full_path) for given FSItem
#	Line 223 | Line 303 | static void get_path_for_fsitem(FSItem *
303
304
305		/*
306	+	*  Exchange parent CNIDs in all FSItems
307	+	*/
308	+
309	+	static void swap_parent_ids(uint32 parent1, uint32 parent2)
310	+	{
311	+	FSItem *p = first_fs_item;
312	+	while (p) {
313	+	if (p->parent_id == parent1)
314	+	p->parent_id = parent2;
315	+	else if (p->parent_id == parent2)
316	+	p->parent_id = parent1;
317	+	p = p->next;
318	+	}
319	+	}
320	+
321	+
322	+	/*
323		*  String handling functions
324		*/
325
#	Line 240 | Line 337 | static void cstr2pstr(char *dst, const c
337		*dst++ = strlen(src);
338		char c;
339		while ((c = *src++) != 0) {
340	+	// Note: we are converting host ':' characters to Mac '/' characters here
341	+	// '/' is not a path separator as this function is only used on object names
342		if (c == ':')
343		c = '/';
344		*dst++ = c;
345		}
346		}
347
249	–	// Convert pascal string to C string
250	–	static void pstr2cstr(char *dst, const char *src)
251	–	{
252	–	int size = *src++;
253	–	while (size--) {
254	–	char c = *src++;
255	–	if (c == '/')
256	–	c = ':';
257	–	*dst++ = c;
258	–	}
259	–	*dst = 0;
260	–	}
261	–
348		// Convert string (no length byte) to C string, length given separately
349		static void strn2cstr(char *dst, const char *src, int size)
350		{
351		while (size--) {
352		char c = *src++;
353	+	// Note: we are converting Mac '/' characters to host ':' characters here
354	+	// '/' is not a path separator as this function is only used on object names
355		if (c == '/')
356		c = ':';
357		*dst++ = c;
#	Line 329 | Line 417 | void ExtFSInit(void)
417		p->parent_id = 0;
418		p->parent = NULL;
419		p->name[0] = 0;
420	+	p->guest_name[0] = 0;
421
422		// Create root FSItem
423		p = new FSItem;
#	Line 339 | Line 428 | void ExtFSInit(void)
428		p->parent_id = ROOT_PARENT_ID;
429		p->parent = first_fs_item;
430		strncpy(p->name, GetString(STR_EXTFS_VOLUME_NAME), 32);
431	+	p->name[31] = 0;
432	+	strncpy(p->guest_name, host_encoding_to_macroman(p->name), 32);
433	+	p->guest_name[31] = 0;
434
435		// Find path for root
436		if ((RootPath = PrefsFindString("extfs")) != NULL) {
#	Line 387 | Line 479 | void InstallExtFS(void)
479		// FSM present?
480		r.d[0] = gestaltFSAttr;
481		Execute68kTrap(0xa1ad, &r);     // Gestalt()
482	<	D(bug("FSAttr %ld, %08lx\n", r.d[0], r.a[0]));
482	>	D(bug("FSAttr %d, %08x\n", r.d[0], r.a[0]));
483		if ((r.d[0] & 0xffff) || !(r.a[0] & (1 << gestaltHasFileSystemManager))) {
484		printf("WARNING: No FSM present, disabling ExtFS\n");
485		return;
#	Line 396 | Line 488 | void InstallExtFS(void)
488		// Yes, version >=1.2?
489		r.d[0] = gestaltFSMVersion;
490		Execute68kTrap(0xa1ad, &r);     // Gestalt()
491	<	D(bug("FSMVersion %ld, %08lx\n", r.d[0], r.a[0]));
491	>	D(bug("FSMVersion %d, %08x\n", r.d[0], r.a[0]));
492		if ((r.d[0] & 0xffff) || (r.a[0] < 0x0120)) {
493		printf("WARNING: FSM <1.2 found, disabling ExtFS\n");
494		return;
#	Line 666 | Line 758 | int16 ExtFSComm(uint16 message, uint32 p
758		}
759
760		case ffsIDDiskMessage: {                // Check if volume is handled by our FS
761	<	if (ReadMacInt16(paramBlock + ioVRefNum) == drive_number)
761	>	if ((int16)ReadMacInt16(paramBlock + ioVRefNum) == drive_number)
762		return noErr;
763		else
764		return extFSErr;
#	Line 710 | Line 802 | static int16 get_current_dir(uint32 pb,
802		if (no_vol_name)
803		WriteMacInt32(pb + ioNamePtr, name_ptr);
804		int16 status = ReadMacInt16(fs_data + fsReturn);
713	–	int16 more_matches = ReadMacInt16(fs_data + fsReturn + 2);
714	–	int16 vRefNum = ReadMacInt16(fs_data + fsReturn + 4);
715	–	uint32 vcb = ReadMacInt32(fs_data + fsReturn + 6);
805		D(bug("  UTDetermineVol() returned %d, status %d\n", r.d[0], status));
806	<	result = r.d[0] & 0xffff;
806	>	result = (int16)(r.d[0] & 0xffff);
807
808		if (result == noErr) {
809		switch (status) {
#	Line 739 | Line 828 | static int16 get_current_dir(uint32 pb,
828		Execute68k(fs_data + fsResolveWDCB, &r);
829		uint32 wdcb = ReadMacInt32(fs_data + fsReturn);
830		D(bug("  UTResolveWDCB() returned %d, dirID %d\n", r.d[0], ReadMacInt32(wdcb + wdDirID)));
831	<	result = r.d[0] & 0xffff;
831	>	result = (int16)(r.d[0] & 0xffff);
832		if (result == noErr)
833		current_dir = ReadMacInt32(wdcb + wdDirID);
834		}
#	Line 755 | Line 844 | static int16 get_current_dir(uint32 pb,
844		r.a[0] = wdpb;
845		Execute68k(fs_data + fsGetDefaultVol, &r);
846		D(bug("  UTGetDefaultVol() returned %d, dirID %d\n", r.d[0], ReadMacInt32(wdpb + ioWDDirID)));
847	<	result = r.d[0] & 0xffff;
847	>	result = (int16)(r.d[0] & 0xffff);
848		if (result == noErr)
849		current_dir = ReadMacInt32(wdpb + ioWDDirID);
850		}
#	Line 781 | Line 870 | static int16 get_path_component_name(uin
870		r.a[0] = rec;
871		Execute68k(fs_data + fsGetPathComponentName, &r);
872		//      D(bug("  UTGetPathComponentName returned %d\n", r.d[0]));
873	<	return r.d[0] & 0xffff;
873	>	return (int16)(r.d[0] & 0xffff);
874		}
875
876
#	Line 817 | Line 906 | static int16 get_item_and_path(uint32 pb
906		r.a[1] = ReadMacInt32(parseRec + ppNamePtr);
907		Execute68k(fs_data + fsParsePathname, &r);
908		D(bug("  UTParsePathname() returned %d, startOffset %d\n", r.d[0], ReadMacInt16(parseRec + ppStartOffset)));
909	<	result = r.d[0] & 0xffff;
909	>	result = (int16)(r.d[0] & 0xffff);
910		if (result == noErr) {
911
912		// Check for leading delimiter of the partial pathname
#	Line 852 | Line 941 | static int16 get_item_and_path(uint32 pb
941		char name[32];
942		strn2cstr(name, (char *)Mac2HostAddr(ReadMacInt32(parseRec + ppNamePtr)) + ReadMacInt16(parseRec + ppStartOffset) + 1, ReadMacInt16(parseRec + ppComponentLength));
943		D(bug("  entering %s\n", name));
944	<	p = find_fsitem(name, p);
944	>	p = find_fsitem_guest(name, p);
945		current_dir = p->id;
946
947		// startOffset = start of next component
#	Line 875 | Line 964 | static int16 get_item_and_path(uint32 pb
964		char name[32];
965		strn2cstr(name, (char *)Mac2HostAddr(ReadMacInt32(parseRec + ppNamePtr)) + ReadMacInt16(parseRec + ppStartOffset) + 1, ReadMacInt16(parseRec + ppComponentLength));
966		D(bug("  object is %s\n", name));
967	<	item = find_fsitem(name, p);
967	>	item = find_fsitem_guest(name, p);
968		}
969		}
970		}
#	Line 930 | Line 1019 | static uint32 find_fcb(int16 refNum)
1019		static int16 fs_mount_vol(uint32 pb)
1020		{
1021		D(bug(" fs_mount_vol(%08lx), vRefNum %d\n", pb, ReadMacInt16(pb + ioVRefNum)));
1022	<	if (ReadMacInt16(pb + ioVRefNum) == drive_number)
1022	>	if ((int16)ReadMacInt16(pb + ioVRefNum) == drive_number)
1023		return noErr;
1024		else
1025		return extFSErr;
#	Line 947 | Line 1036 | static int16 fs_volume_mount(uint32 pb)
1036		r.a[0] = fs_data + fsReturn;
1037		r.a[1] = fs_data + fsReturn + 2;
1038		Execute68k(fs_data + fsAllocateVCB, &r);
1039	+	#if DEBUG
1040		uint16 sysVCBLength = ReadMacInt16(fs_data + fsReturn);
1041	+	#endif
1042		uint32 vcb = ReadMacInt32(fs_data + fsReturn + 2);
1043		D(bug("  UTAllocateVCB() returned %d, vcb %08lx, size %d\n", r.d[0], vcb, sysVCBLength));
1044		if (r.d[0] & 0xffff)
1045	<	return r.d[0];
1045	>	return (int16)r.d[0];
1046
1047		// Init VCB
1048		WriteMacInt16(vcb + vcbSigWord, 0x4244);
1049	<	#ifdef __BEOS__
1050	<	WriteMacInt32(vcb + vcbCrDate, root_stat.st_crtime + TIME_OFFSET);
1049	>	#if defined(__BEOS__) || defined(WIN32)
1050	>	WriteMacInt32(vcb + vcbCrDate, TimeToMacTime(root_stat.st_crtime));
1051	>	#elif defined __APPLE__ && defined __MACH__
1052	>	WriteMacInt32(vcb + vcbCrDate, get_creation_time(RootPath));
1053		#else
1054		WriteMacInt32(vcb + vcbCrDate, 0);
1055		#endif
1056	<	WriteMacInt32(vcb + vcbLsMod, root_stat.st_mtime + TIME_OFFSET);
1056	>	WriteMacInt32(vcb + vcbLsMod, TimeToMacTime(root_stat.st_mtime));
1057		WriteMacInt32(vcb + vcbVolBkUp, 0);
1058		WriteMacInt16(vcb + vcbNmFls, 1);                       //!!
1059		WriteMacInt16(vcb + vcbNmRtDirs, 1);            //!!
1060		WriteMacInt16(vcb + vcbNmAlBlks, 0xffff);       //!!
1061	<	WriteMacInt32(vcb + vcbAlBlkSiz, 1024);
1062	<	WriteMacInt32(vcb + vcbClpSiz, 1024);
1061	>	WriteMacInt32(vcb + vcbAlBlkSiz, AL_BLK_SIZE);
1062	>	WriteMacInt32(vcb + vcbClpSiz, CLUMP_SIZE);
1063		WriteMacInt32(vcb + vcbNxtCNID, next_cnid);
1064		WriteMacInt16(vcb + vcbFreeBks, 0xffff);        //!!
1065		Host2Mac_memcpy(vcb + vcbVN, VOLUME_NAME, 28);
#	Line 980 | Line 1073 | static int16 fs_volume_mount(uint32 pb)
1073		r.a[0] = fs_data + fsReturn;
1074		r.a[1] = vcb;
1075		Execute68k(fs_data + fsAddNewVCB, &r);
1076	<	int16 vRefNum = ReadMacInt32(fs_data + fsReturn);
1076	>	int16 vRefNum = (int16)ReadMacInt32(fs_data + fsReturn);
1077		D(bug("  UTAddNewVCB() returned %d, vRefNum %d\n", r.d[0], vRefNum));
1078		if (r.d[0] & 0xffff)
1079	<	return r.d[0];
1079	>	return (int16)r.d[0];
1080
1081		// Post diskInsertEvent
1082		D(bug("  posting diskInsertEvent\n"));
#	Line 1007 | Line 1100 | static int16 fs_unmount_vol(uint32 vcb)
1100		r.a[0] = vcb;
1101		Execute68k(fs_data + fsDisposeVCB, &r);
1102		D(bug("  UTDisposeVCB() returned %d\n", r.d[0]));
1103	<	return r.d[0];
1103	>	return (int16)r.d[0];
1104		}
1105
1106		// Get information about a volume (HVolumeParam)
#	Line 1018 | Line 1111 | static int16 fs_get_vol_info(uint32 pb,
1111		// Fill in struct
1112		if (ReadMacInt32(pb + ioNamePtr))
1113		pstrcpy((char *)Mac2HostAddr(ReadMacInt32(pb + ioNamePtr)), VOLUME_NAME);
1114	<	#ifdef __BEOS__
1115	<	WriteMacInt32(pb + ioVCrDate, root_stat.st_crtime + TIME_OFFSET);
1114	>	#if defined(__BEOS__) || defined(WIN32)
1115	>	WriteMacInt32(pb + ioVCrDate, TimeToMacTime(root_stat.st_crtime));
1116	>	#elif defined __APPLE__ && defined __MACH__
1117	>	WriteMacInt32(pb + ioVCrDate, get_creation_time(RootPath));
1118		#else
1119		WriteMacInt32(pb + ioVCrDate, 0);
1120		#endif
1121	<	WriteMacInt32(pb + ioVLsMod, root_stat.st_mtime + TIME_OFFSET);
1121	>	WriteMacInt32(pb + ioVLsMod, TimeToMacTime(root_stat.st_mtime));
1122		WriteMacInt16(pb + ioVAtrb, 0);
1123		WriteMacInt16(pb + ioVNmFls, 1);                        //!!
1124		WriteMacInt16(pb + ioVBitMap, 0);
1125		WriteMacInt16(pb + ioAllocPtr, 0);
1126		WriteMacInt16(pb + ioVNmAlBlks, 0xffff);        //!!
1127	<	WriteMacInt32(pb + ioVAlBlkSiz, 1024);
1128	<	WriteMacInt32(pb + ioVClpSiz, 1024);
1127	>	WriteMacInt32(pb + ioVAlBlkSiz, AL_BLK_SIZE);
1128	>	WriteMacInt32(pb + ioVClpSiz, CLUMP_SIZE);
1129		WriteMacInt16(pb + ioAlBlSt, 0);
1130		WriteMacInt32(pb + ioVNxtCNID, next_cnid);
1131		WriteMacInt16(pb + ioVFrBlk, 0xffff);           //!!
#	Line 1063 | Line 1158 | static int16 fs_get_vol_parms(uint32 pb)
1158		//      D(bug(" fs_get_vol_parms(%08lx)\n", pb));
1159
1160		// Return parameter block
1066	–	uint8 vol[SIZEOF_GetVolParmsInfoBuffer];
1067	–	WriteMacInt16((uint32)vol + vMVersion, 2);
1068	–	WriteMacInt32((uint32)vol + vMAttrib, kNoMiniFndr | kNoVNEdit | kNoLclSync | kTrshOffLine | kNoSwitchTo | kNoBootBlks | kNoSysDir | kHasExtFSVol);
1069	–	WriteMacInt32((uint32)vol + vMLocalHand, 0);
1070	–	WriteMacInt32((uint32)vol + vMServerAdr, 0);
1071	–	WriteMacInt32((uint32)vol + vMVolumeGrade, 0);
1072	–	WriteMacInt16((uint32)vol + vMForeignPrivID, 0);
1161		uint32 actual = ReadMacInt32(pb + ioReqCount);
1162	<	if (actual > sizeof(vol))
1163	<	actual = sizeof(vol);
1076	<	Host2Mac_memcpy(ReadMacInt32(pb + ioBuffer), vol, actual);
1162	>	if (actual > SIZEOF_GetVolParmsInfoBuffer)
1163	>	actual = SIZEOF_GetVolParmsInfoBuffer;
1164		WriteMacInt32(pb + ioActCount, actual);
1165	+	uint32 p = ReadMacInt32(pb + ioBuffer);
1166	+	if (actual > vMVersion) WriteMacInt16(p + vMVersion, 2);
1167	+	if (actual > vMAttrib) WriteMacInt32(p + vMAttrib, kNoMiniFndr | kNoVNEdit | kNoLclSync | kTrshOffLine | kNoSwitchTo | kNoBootBlks | kNoSysDir | kHasExtFSVol);
1168	+	if (actual > vMLocalHand) WriteMacInt32(p + vMLocalHand, 0);
1169	+	if (actual > vMServerAdr) WriteMacInt32(p + vMServerAdr, 0);
1170	+	if (actual > vMVolumeGrade) WriteMacInt32(p + vMVolumeGrade, 0);
1171	+	if (actual > vMForeignPrivID) WriteMacInt16(p + vMForeignPrivID, 0);
1172		return noErr;
1173		}
1174
#	Line 1089 | Line 1183 | static int16 fs_get_vol(uint32 pb)
1183		r.a[0] = pb;
1184		Execute68k(fs_data + fsGetDefaultVol, &r);
1185		D(bug("  UTGetDefaultVol() returned %d\n", r.d[0]));
1186	<	return r.d[0];
1186	>	return (int16)r.d[0];
1187		}
1188
1189		// Set default volume (WDParam)
#	Line 1145 | Line 1239 | static int16 fs_set_vol(uint32 pb, bool
1239		r.d[2] = refNum;
1240		Execute68k(fs_data + fsSetDefaultVol, &r);
1241		D(bug("  UTSetDefaultVol() returned %d\n", r.d[0]));
1242	<	return r.d[0];
1242	>	return (int16)r.d[0];
1243		}
1244
1245		// Query file attributes (HFileParam)
#	Line 1187 | Line 1281 | read_next_de:
1281		return fnfErr;
1282		}
1283		if (de->d_name[0] == '.')
1284	<	goto read_next_de;      // Suppress name beginning with '.' (MacOS could interpret these as driver names)
1284	>	goto read_next_de;      // Suppress names beginning with '.' (MacOS could interpret these as driver names)
1285		//!! suppress directories
1286		}
1287		add_path_comp(de->d_name);
#	Line 1206 | Line 1300 | read_next_de:
1300
1301		// Fill in struct from fs_item and stats
1302		if (ReadMacInt32(pb + ioNamePtr))
1303	<	cstr2pstr((char *)Mac2HostAddr(ReadMacInt32(pb + ioNamePtr)), fs_item->name);
1303	>	cstr2pstr((char *)Mac2HostAddr(ReadMacInt32(pb + ioNamePtr)), fs_item->guest_name);
1304		WriteMacInt16(pb + ioFRefNum, 0);
1305		WriteMacInt8(pb + ioFlAttrib, access(full_path, W_OK) == 0 ? 0 : faLocked);
1306		WriteMacInt32(pb + ioDirID, fs_item->id);
1307
1308	<	#ifdef __BEOS__
1309	<	WriteMacInt32(pb + ioFlCrDat, st.st_crtime + TIME_OFFSET);
1308	>	#if defined(__BEOS__) || defined(WIN32)
1309	>	WriteMacInt32(pb + ioFlCrDat, TimeToMacTime(st.st_crtime));
1310	>	#elif defined __APPLE__ && defined __MACH__
1311	>	WriteMacInt32(pb + ioFlCrDat, get_creation_time(full_path));
1312		#else
1313		WriteMacInt32(pb + ioFlCrDat, 0);
1314		#endif
1315	<	WriteMacInt32(pb + ioFlMdDat, st.st_mtime + TIME_OFFSET);
1315	>	WriteMacInt32(pb + ioFlMdDat, TimeToMacTime(st.st_mtime));
1316
1317	<	Mac_memset(pb + ioFlFndrInfo, 0, SIZEOF_FInfo);
1222	<	uint32 type, creator;   // pb may point to kernel space, but stack is switched
1223	<	get_finder_type(full_path, type, creator);
1224	<	WriteMacInt32(pb + ioFlFndrInfo + fdType, type);
1225	<	WriteMacInt32(pb + ioFlFndrInfo + fdCreator, creator);
1226	<	uint16 fflags;
1227	<	get_finder_flags(full_path, fflags);
1228	<	WriteMacInt16(pb + ioFlFndrInfo + fdFlags, fflags);
1317	>	get_finfo(full_path, pb + ioFlFndrInfo, hfs ? pb + ioFlXFndrInfo : 0, false);
1318
1319		WriteMacInt16(pb + ioFlStBlk, 0);
1320		WriteMacInt32(pb + ioFlLgLen, st.st_size);
1321	<	WriteMacInt32(pb + ioFlPyLen, (st.st_size + 1023) & ~1023);
1321	>	WriteMacInt32(pb + ioFlPyLen, (st.st_size | (AL_BLK_SIZE - 1)) + 1);
1322		WriteMacInt16(pb + ioFlRStBlk, 0);
1323		uint32 rf_size = get_rfork_size(full_path);
1324		WriteMacInt32(pb + ioFlRLgLen, rf_size);
1325	<	WriteMacInt32(pb + ioFlRPyLen, (rf_size + 1023) & ~1023);
1325	>	WriteMacInt32(pb + ioFlRPyLen, (rf_size | (AL_BLK_SIZE - 1)) + 1);
1326
1327		if (hfs) {
1328		WriteMacInt32(pb + ioFlBkDat, 0);
1240	–	Mac_memset(pb + ioFlXFndrInfo, 0, SIZEOF_FXInfo);
1329		WriteMacInt32(pb + ioFlParID, fs_item->parent_id);
1330		WriteMacInt32(pb + ioFlClpSiz, 0);
1331		}
#	Line 1262 | Line 1350 | static int16 fs_set_file_info(uint32 pb,
1350		if (S_ISDIR(st.st_mode))
1351		return fnfErr;
1352
1353	<	// Set attributes
1354	<	set_finder_type(full_path, ReadMacInt32(pb + ioFlFndrInfo + fdType), ReadMacInt32(pb + ioFlFndrInfo + fdCreator));
1355	<	set_finder_flags(full_path, ReadMacInt16(pb + ioFlFndrInfo + fdFlags));
1353	>	// Set Finder info
1354	>	set_finfo(full_path, pb + ioFlFndrInfo, hfs ? pb + ioFlXFndrInfo : 0, false);
1355	>
1356		//!! times
1357		return noErr;
1358		}
#	Line 1316 | Line 1404 | read_next_de:
1404		return fnfErr;
1405		}
1406		if (de->d_name[0] == '.')
1407	<	goto read_next_de;      // Suppress name beginning with '.' (MacOS could interpret these as driver names)
1407	>	goto read_next_de;      // Suppress names beginning with '.' (MacOS could interpret these as driver names)
1408		}
1409		add_path_comp(de->d_name);
1410
#	Line 1335 | Line 1423 | read_next_de:
1423
1424		// Fill in struct from fs_item and stats
1425		if (ReadMacInt32(pb + ioNamePtr))
1426	<	cstr2pstr((char *)Mac2HostAddr(ReadMacInt32(pb + ioNamePtr)), fs_item->name);
1426	>	cstr2pstr((char *)Mac2HostAddr(ReadMacInt32(pb + ioNamePtr)), fs_item->guest_name);
1427		WriteMacInt16(pb + ioFRefNum, 0);
1428		WriteMacInt8(pb + ioFlAttrib, (S_ISDIR(st.st_mode) ? faIsDir : 0) | (access(full_path, W_OK) == 0 ? 0 : faLocked));
1429		WriteMacInt8(pb + ioACUser, 0);
1430		WriteMacInt32(pb + ioDirID, fs_item->id);
1431		WriteMacInt32(pb + ioFlParID, fs_item->parent_id);
1432	<	#ifdef __BEOS__
1433	<	WriteMacInt32(pb + ioFlCrDat, st.st_crtime + TIME_OFFSET);
1432	>	#if defined(__BEOS__) || defined(WIN32)
1433	>	WriteMacInt32(pb + ioFlCrDat, TimeToMacTime(st.st_crtime));
1434	>	#elif defined __APPLE__ && defined __MACH__
1435	>	WriteMacInt32(pb + ioFlCrDat, get_creation_time(full_path));
1436		#else
1437		WriteMacInt32(pb + ioFlCrDat, 0);
1438		#endif
#	Line 1352 | Line 1442 | read_next_de:
1442		fs_item->mtime = mtime;
1443		cached = false;
1444		}
1445	<	WriteMacInt32(pb + ioFlMdDat, mtime);
1445	>	WriteMacInt32(pb + ioFlMdDat, TimeToMacTime(mtime));
1446		WriteMacInt32(pb + ioFlBkDat, 0);
1447	+
1448	+	get_finfo(full_path, pb + ioFlFndrInfo, pb + ioFlXFndrInfo, S_ISDIR(st.st_mode));
1449	+
1450		if (S_ISDIR(st.st_mode)) {
1358	–	Mac_memset(pb + ioDrUsrWds, 0, SIZEOF_DInfo);
1359	–	Mac_memset(pb + ioDrFndrInfo, 0, SIZEOF_DXInfo);
1360	–	uint16 fflags;  // pb may point to kernel space, but stack is switched
1361	–	get_finder_flags(full_path, fflags);
1362	–	WriteMacInt16(pb + ioDrUsrWds + frFlags, fflags);
1451
1452		// Determine number of files in directory (cached)
1453		int count;
#	Line 1374 | Line 1462 | read_next_de:
1462		de = readdir(d);
1463		if (de == NULL)
1464		break;
1465	+	if (de->d_name[0] == '.')
1466	+	continue;       // Suppress names beginning with '.'
1467		count++;
1468		}
1469		closedir(d);
#	Line 1382 | Line 1472 | read_next_de:
1472		}
1473		WriteMacInt16(pb + ioDrNmFls, count);
1474		} else {
1385	–	Mac_memset(pb + ioFlFndrInfo, 0, SIZEOF_FInfo);
1386	–	Mac_memset(pb + ioFlXFndrInfo, 0, SIZEOF_FXInfo);
1387	–	uint32 type, creator;   // pb may point to kernel space, but stack is switched
1388	–	get_finder_type(full_path, type, creator);
1389	–	WriteMacInt32(pb + ioFlFndrInfo + fdType, type);
1390	–	WriteMacInt32(pb + ioFlFndrInfo + fdCreator, creator);
1391	–	uint16 fflags;
1392	–	get_finder_flags(full_path, fflags);
1393	–	WriteMacInt16(pb + ioFlFndrInfo + fdFlags, fflags);
1475		WriteMacInt16(pb + ioFlStBlk, 0);
1476		WriteMacInt32(pb + ioFlLgLen, st.st_size);
1477	<	WriteMacInt32(pb + ioFlPyLen, (st.st_size + 1023) & ~1023);
1477	>	WriteMacInt32(pb + ioFlPyLen, (st.st_size | (AL_BLK_SIZE - 1)) + 1);
1478		WriteMacInt16(pb + ioFlRStBlk, 0);
1479		uint32 rf_size = get_rfork_size(full_path);
1480		WriteMacInt32(pb + ioFlRLgLen, rf_size);
1481	<	WriteMacInt32(pb + ioFlRPyLen, (rf_size + 1023) & ~1023);
1481	>	WriteMacInt32(pb + ioFlRPyLen, (rf_size | (AL_BLK_SIZE - 1)) + 1);
1482		WriteMacInt32(pb + ioFlClpSiz, 0);
1483		}
1484		return noErr;
#	Line 1419 | Line 1500 | static int16 fs_set_cat_info(uint32 pb)
1500		if (stat(full_path, &st) < 0)
1501		return errno2oserr();
1502
1503	<	// Set attributes
1504	<	if (S_ISDIR(st.st_mode))
1505	<	set_finder_flags(full_path, ReadMacInt16(pb + ioDrUsrWds + frFlags));
1425	<	else {
1426	<	set_finder_type(full_path, ReadMacInt32(pb + ioFlFndrInfo + fdType), ReadMacInt32(pb + ioFlFndrInfo + fdCreator));
1427	<	set_finder_flags(full_path, ReadMacInt16(pb + ioFlFndrInfo + fdFlags));
1428	<	}
1503	>	// Set Finder info
1504	>	set_finfo(full_path, pb + ioFlFndrInfo, pb + ioFlXFndrInfo, S_ISDIR(st.st_mode));
1505	>
1506		//!! times
1507		return noErr;
1508		}
#	Line 1472 | Line 1549 | static int16 fs_open(uint32 pb, uint32 d
1549		if (access(full_path, F_OK))
1550		return fnfErr;
1551		fd = open_rfork(full_path, flag);
1552	<	if (fd > 0) {
1553	<	if (fstat(fd, &st) < 0)
1552	>	if (fd >= 0) {
1553	>	if (fstat(fd, &st) < 0) {
1554	>	close(fd);
1555		return errno2oserr();
1556	+	}
1557		} else {        // Resource fork not supported, silently ignore it ("pseudo" resource fork)
1558		st.st_size = 0;
1559		st.st_mode = 0;
#	Line 1483 | Line 1562 | static int16 fs_open(uint32 pb, uint32 d
1562		fd = open(full_path, flag);
1563		if (fd < 0)
1564		return errno2oserr();
1565	<	if (fstat(fd, &st) < 0)
1565	>	if (fstat(fd, &st) < 0) {
1566	>	close(fd);
1567		return errno2oserr();
1568	+	}
1569		}
1570
1571		// File open, allocate FCB
#	Line 1496 | Line 1577 | static int16 fs_open(uint32 pb, uint32 d
1577		D(bug("  UTAllocateFCB() returned %d, fRefNum %d, fcb %08lx\n", r.d[0], ReadMacInt16(pb + ioRefNum), fcb));
1578		if (r.d[0] & 0xffff) {
1579		close(fd);
1580	<	return r.d[0];
1580	>	return (int16)r.d[0];
1581		}
1582
1583		// Initialize FCB, fd is stored in fcbCatPos
1584		WriteMacInt32(fcb + fcbFlNm, fs_item->id);
1585		WriteMacInt8(fcb + fcbFlags, ((flag == O_WRONLY || flag == O_RDWR) ? fcbWriteMask : 0) | (resource_fork ? fcbResourceMask : 0) | (write_ok ? 0 : fcbFileLockedMask));
1586		WriteMacInt32(fcb + fcbEOF, st.st_size);
1587	<	WriteMacInt32(fcb + fcbPLen, (st.st_size + 1023) & ~1023);
1587	>	WriteMacInt32(fcb + fcbPLen, (st.st_size | (AL_BLK_SIZE - 1)) + 1);
1588		WriteMacInt32(fcb + fcbCrPs, 0);
1589		WriteMacInt32(fcb + fcbVPtr, vcb);
1590	<	WriteMacInt32(fcb + fcbClmpSize, 1024);
1591	<	uint32 type, creator;   // fcb may point to kernel space, but stack is switched
1592	<	get_finder_type(full_path, type, creator);
1593	<	WriteMacInt32(fcb + fcbFType, type);
1590	>	WriteMacInt32(fcb + fcbClmpSize, CLUMP_SIZE);
1591	>
1592	>	get_finfo(full_path, fs_data + fsPB, 0, false);
1593	>	WriteMacInt32(fcb + fcbFType, ReadMacInt32(fs_data + fsPB + fdType));
1594	>
1595		WriteMacInt32(fcb + fcbCatPos, fd);
1596		WriteMacInt32(fcb + fcbDirID, fs_item->parent_id);
1597	<	cstr2pstr((char *)Mac2HostAddr(fcb + fcbCName), fs_item->name);
1597	>	cstr2pstr((char *)Mac2HostAddr(fcb + fcbCName), fs_item->guest_name);
1598		return noErr;
1599		}
1600
#	Line 1546 | Line 1628 | static int16 fs_close(uint32 pb)
1628		r.d[0] = ReadMacInt16(pb + ioRefNum);
1629		Execute68k(fs_data + fsReleaseFCB, &r);
1630		D(bug("  UTReleaseFCB() returned %d\n", r.d[0]));
1631	<	return r.d[0];
1631	>	return (int16)r.d[0];
1632		}
1633
1634		// Query information about FCB (FCBPBRec)
#	Line 1565 | Line 1647 | static int16 fs_get_fcb_info(uint32 pb,
1647
1648		// Find FCB by index
1649		WriteMacInt16(pb + ioRefNum, 0);
1650	<	for (int i=0; i<ReadMacInt16(pb + ioFCBIndx); i++) {
1650	>	for (int i=0; i<(int)ReadMacInt16(pb + ioFCBIndx); i++) {
1651		D(bug("  indexing FCBs\n"));
1652		r.a[0] = vcb;
1653		r.a[1] = pb + ioRefNum;
#	Line 1574 | Line 1656 | static int16 fs_get_fcb_info(uint32 pb,
1656		fcb = ReadMacInt32(fs_data + fsReturn);
1657		D(bug("  UTIndexFCB() returned %d, fcb %p\n", r.d[0], fcb));
1658		if (r.d[0] & 0xffff)
1659	<	return r.d[0];
1659	>	return (int16)r.d[0];
1660		}
1661		}
1662		if (fcb == 0)
#	Line 1622 | Line 1704 | static int16 fs_get_eof(uint32 pb)
1704
1705		// Adjust FCBs
1706		WriteMacInt32(fcb + fcbEOF, st.st_size);
1707	<	WriteMacInt32(fcb + fcbPLen, (st.st_size + 1023) & ~1023);
1707	>	WriteMacInt32(fcb + fcbPLen, (st.st_size | (AL_BLK_SIZE - 1)) + 1);
1708		WriteMacInt32(pb + ioMisc, st.st_size);
1709		D(bug("  adjusting FCBs\n"));
1710		r.d[0] = ReadMacInt16(pb + ioRefNum);
#	Line 1657 | Line 1739 | static int16 fs_set_eof(uint32 pb)
1739
1740		// Adjust FCBs
1741		WriteMacInt32(fcb + fcbEOF, size);
1742	<	WriteMacInt32(fcb + fcbPLen, (size + 1023) & ~1023);
1742	>	WriteMacInt32(fcb + fcbPLen, (size | (AL_BLK_SIZE - 1)) + 1);
1743		D(bug("  adjusting FCBs\n"));
1744		r.d[0] = ReadMacInt16(pb + ioRefNum);
1745		Execute68k(fs_data + fsAdjustEOF, &r);
#	Line 1742 | Line 1824 | static int16 fs_read(uint32 pb)
1824		{
1825		D(bug(" fs_read(%08lx), refNum %d, buffer %p, count %d, posMode %d, posOffset %d\n", pb, ReadMacInt16(pb + ioRefNum), ReadMacInt32(pb + ioBuffer), ReadMacInt32(pb + ioReqCount), ReadMacInt16(pb + ioPosMode), ReadMacInt32(pb + ioPosOffset)));
1826
1827	+	// Check parameters
1828	+	if ((int32)ReadMacInt32(pb + ioReqCount) < 0)
1829	+	return paramErr;
1830	+
1831		// Find FCB and fd for file
1832		uint32 fcb = find_fcb(ReadMacInt16(pb + ioRefNum));
1833		if (fcb == 0)
#	Line 1773 | Line 1859 | static int16 fs_read(uint32 pb)
1859		}
1860
1861		// Read
1862	<	size_t actual = extfs_read(fd, Mac2HostAddr(ReadMacInt32(pb + ioBuffer)), ReadMacInt32(pb + ioReqCount));
1862	>	ssize_t actual = extfs_read(fd, Mac2HostAddr(ReadMacInt32(pb + ioBuffer)), ReadMacInt32(pb + ioReqCount));
1863	>	int16 read_err = errno2oserr();
1864		D(bug("  actual %d\n", actual));
1865	<	WriteMacInt32(pb + ioActCount, actual);
1865	>	WriteMacInt32(pb + ioActCount, actual >= 0 ? actual : 0);
1866		uint32 pos = lseek(fd, 0, SEEK_CUR);
1867		WriteMacInt32(fcb + fcbCrPs, pos);
1868		WriteMacInt32(pb + ioPosOffset, pos);
1869	<	if (actual != ReadMacInt32(pb + ioReqCount))
1870	<	if (errno)
1784	<	return errno2oserr();
1785	<	else
1786	<	return eofErr;
1869	>	if (actual != (ssize_t)ReadMacInt32(pb + ioReqCount))
1870	>	return actual < 0 ? read_err : eofErr;
1871		else
1872		return noErr;
1873		}
#	Line 1793 | Line 1877 | static int16 fs_write(uint32 pb)
1877		{
1878		D(bug(" fs_write(%08lx), refNum %d, buffer %p, count %d, posMode %d, posOffset %d\n", pb, ReadMacInt16(pb + ioRefNum), ReadMacInt32(pb + ioBuffer), ReadMacInt32(pb + ioReqCount), ReadMacInt16(pb + ioPosMode), ReadMacInt32(pb + ioPosOffset)));
1879
1880	+	// Check parameters
1881	+	if ((int32)ReadMacInt32(pb + ioReqCount) < 0)
1882	+	return paramErr;
1883	+
1884		// Find FCB and fd for file
1885		uint32 fcb = find_fcb(ReadMacInt16(pb + ioRefNum));
1886		if (fcb == 0)
#	Line 1824 | Line 1912 | static int16 fs_write(uint32 pb)
1912		}
1913
1914		// Write
1915	<	size_t actual = extfs_write(fd, Mac2HostAddr(ReadMacInt32(pb + ioBuffer)), ReadMacInt32(pb + ioReqCount));
1915	>	ssize_t actual = extfs_write(fd, Mac2HostAddr(ReadMacInt32(pb + ioBuffer)), ReadMacInt32(pb + ioReqCount));
1916	>	int16 write_err = errno2oserr();
1917		D(bug("  actual %d\n", actual));
1918	<	WriteMacInt32(pb + ioActCount, actual);
1918	>	WriteMacInt32(pb + ioActCount, actual >= 0 ? actual : 0);
1919		uint32 pos = lseek(fd, 0, SEEK_CUR);
1920		WriteMacInt32(fcb + fcbCrPs, pos);
1921		WriteMacInt32(pb + ioPosOffset, pos);
1922	<	if (actual != ReadMacInt32(pb + ioReqCount))
1923	<	return errno2oserr();
1922	>	if (actual != (ssize_t)ReadMacInt32(pb + ioReqCount))
1923	>	return write_err;
1924		else
1925		return noErr;
1926		}
#	Line 1897 | Line 1986 | static int16 fs_delete(uint32 pb, uint32
1986		return result;
1987
1988		// Delete file
1989	<	if (remove(full_path) < 0) {
1990	<	int16 err = errno2oserr();
1991	<	if (errno == EISDIR) {  // Workaround for BeOS bug
1903	<	if (rmdir(full_path) < 0)
1904	<	return errno2oserr();
1905	<	else
1906	<	return noErr;
1907	<	} else
1908	<	return err;
1909	<	} else
1989	>	if (!extfs_remove(full_path))
1990	>	return errno2oserr();
1991	>	else
1992		return noErr;
1993		}
1994
#	Line 1939 | Line 2021 | static int16 fs_rename(uint32 pb, uint32
2021
2022		// Rename item
2023		D(bug("  renaming %s -> %s\n", old_path, full_path));
2024	<	if (rename(old_path, full_path) < 0)
2024	>	if (!extfs_rename(old_path, full_path))
2025		return errno2oserr();
2026		else {
2027		// The ID of the old file/dir has to stay the same, so we swap the IDs of the FSItems
2028	+	swap_parent_ids(fs_item->id, new_item->id);
2029		uint32 t = fs_item->id;
2030		fs_item->id = new_item->id;
2031		new_item->id = t;
#	Line 1966 | Line 2049 | static int16 fs_cat_move(uint32 pb)
2049		strcpy(old_path, full_path);
2050
2051		// Find path for new directory
2052	<	Mac2Host_memcpy(fs_data + fsPB, pb, SIZEOF_IOParam);
2052	>	Mac2Mac_memcpy(fs_data + fsPB, pb, SIZEOF_IOParam);
2053		WriteMacInt32(fs_data + fsPB + ioNamePtr, ReadMacInt32(pb + ioNewName));
2054		FSItem *new_dir_item;
2055		result = get_item_and_path(fs_data + fsPB, ReadMacInt32(pb + ioNewDirID), new_dir_item);
#	Line 1982 | Line 2065 | static int16 fs_cat_move(uint32 pb)
2065
2066		// Move item
2067		D(bug("  moving %s -> %s\n", old_path, full_path));
2068	<	if (rename(old_path, full_path) < 0)
2068	>	if (!extfs_rename(old_path, full_path))
2069		return errno2oserr();
2070		else {
2071		// The ID of the old file/dir has to stay the same, so we swap the IDs of the FSItems
2072		FSItem *new_item = find_fsitem(fs_item->name, new_dir_item);
2073		if (new_item) {
2074	+	swap_parent_ids(fs_item->id, new_item->id);
2075		uint32 t = fs_item->id;
2076		fs_item->id = new_item->id;
2077		new_item->id = t;
#	Line 2007 | Line 2091 | static int16 fs_open_wd(uint32 pb)
2091		r.a[0] = pb;
2092		Execute68k(fs_data + fsAllocateWDCB, &r);
2093		D(bug("  UTAllocateWDCB returned %d, refNum is %d\n", r.d[0], ReadMacInt16(pb + ioVRefNum)));
2094	<	return r.d[0];
2094	>	return (int16)r.d[0];
2095		}
2096
2097		// Close working directory (WDParam)
#	Line 2021 | Line 2105 | static int16 fs_close_wd(uint32 pb)
2105		r.d[0] = ReadMacInt16(pb + ioVRefNum);
2106		Execute68k(fs_data + fsReleaseWDCB, &r);
2107		D(bug("  UTReleaseWDCB returned %d\n", r.d[0]));
2108	<	return r.d[0];
2108	>	return (int16)r.d[0];
2109		}
2110
2111		// Query information about working directory (WDParam)
#	Line 2050 | Line 2134 | static int16 fs_get_wd_info(uint32 pb, u
2134		uint32 wdcb = ReadMacInt32(fs_data + fsReturn);
2135		D(bug("  UTResolveWDCB() returned %d, dirID %d\n", r.d[0], ReadMacInt32(wdcb + wdDirID)));
2136		if (r.d[0] & 0xffff)
2137	<	return r.d[0];
2137	>	return (int16)r.d[0];
2138
2139		// Return information
2140	<	WriteMacInt16(pb + ioWDProcID, ReadMacInt32(wdcb + wdProcID));
2140	>	WriteMacInt32(pb + ioWDProcID, ReadMacInt32(wdcb + wdProcID));
2141		WriteMacInt16(pb + ioWDVRefNum, ReadMacInt16(ReadMacInt32(wdcb + wdVCBPtr) + vcbVRefNum));
2142		if (ReadMacInt32(pb + ioNamePtr))
2143		Mac2Mac_memcpy(ReadMacInt32(pb + ioNamePtr), ReadMacInt32(wdcb + wdVCBPtr) + vcbVN, 28);

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines