Reimplement the Vectorize tool

Tools/ToolSource/MPWObjFuncs.c

@@ -0,0 +1,696 @@
+#define C_PAD 0
+#define C_FIRST 1
+#define C_LAST 2
+#define C_COMMENT 3
+#define C_DICT 4
+#define C_MODULE 5
+#define C_ENTRYPT 6
+#define C_SIZE 7
+#define C_CONTENTS 8
+#define C_REF 9
+#define C_COMPREF 10
+
+
+/* DATA STRUCTURES */
+
+typedef unsigned char uchar;
+typedef unsigned short ushort;
+typedef unsigned long ulong;
+typedef unsigned short id;
+
+
+/* Ugh! */
+#ifndef __GNUC__
+#define ntohs
+#define ntohl
+#define htons
+#define htonl
+#endif
+#define NULL 0
+
+
+ushort shortfrom(char *b)
+{
+	return ntohs(*(ushort *)b);
+}
+
+void setshort(char *b, ushort to)
+{
+	*(ushort *)b = htons(to);
+}
+
+ulong longfrom(char *b)
+{
+	return ntohl(*(ulong *)b);
+}
+
+void setlong(char *b, ulong to)
+{
+	*(ulong *)b = htonl(to);
+}
+
+
+
+/* Wraps an MPW Object buffer */
+struct obj
+{
+	char *buf, *at;
+	id next_id;
+};
+
+
+/* PASCAL STRING COMPARISON, CASE-INSENSITIVE */
+
+int cisc(uchar *a, uchar *b)
+{
+	int i;
+
+	if(*a != *b) return 0;
+
+	for(i=1; i<=*a; i++)
+	{
+		uchar c, d;
+		c = a[i];
+		d = b[i];
+		// if(c >= 'a' && c <= 'z') c &= 223;
+		// if(d >= 'a' && d <= 'z') d &= 223;
+		if(c == d) continue;
+		return 0;
+	}
+	return 1;
+}
+
+void upperpas(uchar *a)
+{
+	int i;
+
+	for(i=1; i<=*a; i++)
+	{
+		if(a[i] >= 'a' && a[i] <= 'z') a[i] &= 223;
+	}
+}
+
+
+/* ACCESSOR FUNCTIONS */
+
+/* Valid for all types */
+char obj_type(struct obj *o)
+{
+	return o->at[0];
+}
+
+/* Valid for First, Dict, Module, EntryPt, Size, Contents, Ref, CompRef */
+char obj_flags(struct obj *o)
+{
+	return o->at[1];
+}
+
+/* Valid for Module, EntryPt */
+id obj_id(struct obj *o)
+{
+	return ntohs(*(id *)(o->at + 2));
+}
+
+/* Valid for Dict */
+id obj_dictfirst(struct obj *o)
+{
+	return ntohs(*(id *)(o->at + 4));
+}
+
+/* Valid for Comment, Dict, Contents, Ref, CompRef */
+unsigned short obj_recsize(struct obj *o)
+{
+	return ntohs(*(unsigned short *)(o->at + 2));
+}
+
+/* Valid for Size */
+unsigned short obj_contsize(struct obj *o)
+{
+	return ntohs(*(unsigned long *)(o->at + 2));
+}
+
+/* Valid for all types */
+unsigned long obj_size(struct obj *o)
+{
+	char t;
+
+	t = obj_type(o);
+
+	if(t == C_COMMENT || t == C_DICT || t == C_CONTENTS || t == C_REF || t == C_COMPREF)
+	{
+		return obj_recsize(o);
+	}
+	else if(t == C_PAD)
+	{
+		return 1;
+	}
+	else if(t == C_FIRST)
+	{
+		return 4;
+	}
+	else if(t == C_MODULE)
+	{
+		return 6;
+	}
+	else if(t == C_ENTRYPT)
+	{
+		return 8;
+	}
+	else if(t == C_SIZE)
+	{
+		return 6;
+	}
+	else if(t == C_LAST)
+	{
+		return 2;
+	}
+	else
+	{
+		printf("Illegal object type at offset 0x%x: %d\n", (ulong)o->at - (ulong)o->buf, t);
+		return 1;
+	}
+}
+
+
+/* CURSOR MANIPULATOR FUNCTIONS */
+
+void obj_init(struct obj *o, char *buf)
+{
+	o->at = o->buf = buf;
+}
+
+void _obj_next_general(struct obj *o, int can_loop)
+{
+	if((long)o->at & 1) o->at ++;
+
+	if(obj_type(o) == C_LAST)
+	{
+		//printf("Got a lastie\n");
+		if(can_loop) o->at = o->buf;
+	}
+	else
+	{
+		//printf("Got a %d %d\n", obj_type(o), obj_size(o));
+		o->at += obj_size(o);
+	}
+
+	if((long)o->at & 1) o->at ++;
+}
+
+/* Gets the next object without looping */
+void obj_next(struct obj *o)
+{
+	_obj_next_general(o, 0);
+}
+
+/* Gets the specified module with looping */
+void obj_findmod(struct obj *o, id mod_id)
+{
+	char *first;
+
+	first = o->at;
+
+	while(obj_type(o) != C_MODULE || obj_id(o) != mod_id)
+	{
+		_obj_next_general(o, 1);
+
+		if(o->at == first)
+		{
+			o->at = o->buf;
+		}
+	}
+}
+
+/* Gets the next dict with looping */
+void dict_next(struct obj *o)
+{
+	do
+	{
+		printf("xx %d\n", obj_type(o));
+		_obj_next_general(o, 1);
+	}
+	while(obj_type(o) != C_DICT);
+}
+
+void obj_pad(struct obj *o)
+{
+	if((long)o->at & 1) *o->at++ = 0;
+}
+
+int obj_nextinmod(struct obj *o)
+{
+	char *at = o->at;
+
+	if(obj_type(o) == C_LAST) return 0;
+
+	_obj_next_general(o, 0);
+
+	if(obj_type(o) == C_LAST || obj_type(o) == C_MODULE)
+	{
+		return 0;
+		o->at = at;
+	}
+
+	return 1;
+}
+
+int obj_nextmod(struct obj *o)
+{
+	char *at = o->at;
+
+	if(obj_type(o) == C_LAST) return 0;
+
+	do
+	{
+		_obj_next_general(o, 0);
+		if(obj_type(o) == C_LAST) return 0;
+	} while(obj_type(o) != C_MODULE);
+
+	return 1;
+}
+
+
+
+/* DICT APPEND FUNCTION */
+
+void dict_append_v(struct obj *o, uchar *s, id hint_id)
+{
+	ushort oldlen;
+
+	if(obj_type(o) != C_DICT || shortfrom(o->at + 2) > 10000)
+	{
+		obj_next(o);
+		o->at[0] = C_DICT;
+		o->at[1] = 0;						/* flags */
+		setshort(o->at+2, 6);				/* size */
+		setshort(o->at+4, hint_id);			/* first id */
+	}
+
+	oldlen = shortfrom(o->at + 2);
+
+	o->at[oldlen+0] = *s + 5;
+	o->at[oldlen+1] = '_';
+	o->at[oldlen+2] = '_';
+	o->at[oldlen+3] = 'v';
+	o->at[oldlen+4] = '_';
+	o->at[oldlen+5] = '_';
+
+	memcpy(o->at + oldlen + 6, s + 1, *s);
+
+	setshort(o->at + 2, oldlen + *s + 6);
+}
+
+
+
+/* DICT SEARCH FUNCTIONS, WHICH HAVE SIDE EFFECTS */
+
+id dict_id_from_str(struct obj *o, unsigned char *str)
+{
+	char *first_searched = NULL;
+
+	//printf("DICT %x: %.*s = \n", o, *str, str+1);
+
+	for(;;)
+	{
+		if(obj_type(o) == C_DICT)
+		{
+			unsigned int ctr, tlen;
+			unsigned char *ptr;
+
+			tlen = ntohs(*(unsigned short *)(o->at + 2));
+			ctr = ntohs(*(unsigned short *)(o->at + 4));
+			ptr = (uchar *)((long)o->at + 6);
+
+			do
+			{
+				//if(ptr[0] == str[0] && !memcmp(ptr+1, str+1, str[0]))
+				if(cisc(ptr, str))
+				{
+					//printf("%d\n", ctr);
+					return ctr;
+				}
+
+				ptr += ptr[0] + 1;
+				ctr++;
+			} while((ulong)ptr < (ulong)o->at + tlen);
+		}
+
+		_obj_next_general(o, 1);
+
+		if(o->at == first_searched) return 0;
+		if(!first_searched) first_searched = o->at;
+	}
+
+	//printf("(not found)\n");
+
+	return 0;
+}
+
+uchar *dict_str_from_id(struct obj *o, id id)
+{
+	char *first_searched = NULL;
+
+	//printf("DICT %x: %d = ", o, id);
+
+	for(;;)
+	{
+		if(obj_type(o) == C_DICT)
+		{
+			unsigned int ctr, tlen;
+			unsigned char *ptr;
+
+			tlen = ntohs(*(unsigned short *)(o->at + 2));
+			ctr = ntohs(*(unsigned short *)(o->at + 4));
+			ptr = (uchar *)((long)o->at + 6);
+
+			if(ctr <= id)
+			{
+				do
+				{
+					if(ctr == id) 
+					{
+						//printf("%.*s\n", *ptr, ptr+1);
+						return ptr;
+					}
+
+					ptr += ptr[0] + 1;
+					ctr++;
+				} while((ulong)ptr < (ulong)o->at + tlen);
+			}
+		}
+
+		_obj_next_general(o, 1);
+
+		if(o->at == first_searched) return 0;
+		if(!first_searched) first_searched = o->at;
+	}
+
+	//printf("(not found)\n");
+
+	return NULL;
+}
+
+id dict_highestid(struct obj *o)
+{
+	id ctr;
+	unsigned int tlen;
+	unsigned char *ptr;
+
+	tlen = ntohs(*(unsigned short *)(o->at + 2));
+	ctr = (id)ntohs(*(unsigned short *)(o->at + 4));
+	ptr = (uchar *)((long)o->at + 6);
+
+	do
+	{
+		ptr += ptr[0] + 1;
+		ctr++;
+	} while((ulong)ptr < (ulong)o->at + tlen);
+
+	return ctr - 1;
+}
+
+
+
+/* NEWDICT FUNCTIONS */
+
+struct newdict
+{
+	struct newdict *prev, *next;			/* linked list */
+
+	id new_id;								/* increments from 256 */
+	id old_id;
+	id patch_id;							/* if this ID is just vector glue and self.next is the implementation */
+	uchar name[256];						/* duh */
+
+	int defining_file;
+	int malloc_size;						/* only for the main dict object */
+	int fcnt;
+	struct newdict ***cache;
+	//id id_in_file[99];						/* malloc makes this array *just right* */
+};
+
+void newdict_init(struct newdict *d, int file_count)
+{
+	d->prev = d->next = d;
+	d->new_id = 255;
+	d->fcnt = file_count;
+	d->malloc_size = sizeof *d; //sizeof(*d) + (file_count - 99) * sizeof(d->id_in_file[0]);
+}
+
+void newdict_cache(struct newdict *d)
+{
+	int i;
+	struct newdict *s;
+
+	d->cache = (struct newdict ***)calloc(d->fcnt, sizeof d->cache[0]);
+
+	for(i=0; i<d->fcnt; i++)
+	{
+		d->cache[i] = (struct newdict **)calloc(65536, sizeof d->cache[0][0]);
+	}
+
+	for(s = d->next; s != d; s = s->next)
+	{
+		d->cache[s->defining_file][s->old_id] = s;
+	}
+}
+
+id newdict_append(struct newdict *d, int file_idx, id orig_id, uchar *name)
+{
+	struct newdict *s;
+
+	s = (struct newdict *)calloc(d->malloc_size, 1);
+	if(!s)
+	{
+		return 0;
+	}
+
+	s->next = d;
+	s->prev = d->prev;
+	s->prev->next = s;
+	d->prev = s;
+
+	s->new_id = s->prev->new_id + 1;
+	memcpy(s->name, name, name[0]+1);
+
+	s->defining_file = file_idx;
+	//s->id_in_file[file_idx] = orig_id;
+	s->old_id = orig_id;
+
+	return s->new_id;
+}
+
+struct newdict *newdict_find(struct newdict *d, int file_idx, id mid)
+{
+	// struct newdict *s;
+
+	// for(s = d->next; s != d; s = s->next)
+	// {
+	// 	if(s->id_in_file[file_idx] == mid) return s;
+	// }
+
+	// return (struct newdict *)0;
+
+	return d->cache[file_idx][mid];
+}
+
+// void newdict_debug_dump(struct newdict *d, char **file_names)
+// {
+// 	struct newdict *s;
+// 	int i;
+
+// 	printf("NEWDICT_DEBUG_DUMP\n");
+
+// 	for(s = d->next; s != d; s = s->next)
+// 	{
+// 		printf("    %d %.*s", s->new_id, *s->name, s->name+1);
+
+// 		if(s->defining_file != -1)
+// 		{
+// 			if(file_names)
+// 			{
+// 				printf(" (%s:%d)", file_names[s->defining_file], s->id_in_file[s->defining_file]);
+// 			}
+// 			else
+// 			{
+// 				printf(" (file_%d:%d)", s->defining_file, s->id_in_file[s->defining_file]);
+// 			}
+// 		}
+
+// 		if(s->patch_id)
+// 		{
+// 			printf(" (patch ID %d, next line is implementation:)", s->patch_id);
+// 		}
+
+// 		printf("\n        %d:%d", s->defining_file, s->id_in_file[s->defining_file]);
+
+// 		for(i=0; i<d->fcnt; i++)
+// 		{
+// 			if(i == s->defining_file) continue;
+// 			if(!s->id_in_file[i]) continue;
+// 			printf(" %d:%d", i, s->id_in_file[i]);
+// 		}
+
+// 		printf("\n");
+// 	}
+// }
+
+unsigned long newdict_dump(struct newdict *d, char *o)
+{
+	unsigned long l = 0;
+	struct newdict *s = d->next;
+
+	while(s != d)
+	{
+		long tl = 0;
+
+		o[l] = C_DICT;
+		o[l+1] = 0;   /* 0 => names needed for code/data relocation.
+		               1 => names needed for symbolic debugging only
+		               (in which case they are ignored when doing a
+		               non-symbolic link) */
+
+		*(ushort *)(o + l + 4) = htons(s->new_id);
+
+		tl = 6;
+
+		while(s != d && tl < 10000)
+		{
+			memcpy(o + l + tl, s->name, s->name[0]+1);
+			tl += s->name[0]+1;
+			s = s->next;
+		}
+
+		/* doing the record! */
+		*(id *)(o + l + 2) = htons(tl);
+
+		if(tl & 1) o[l + tl++] = 0;
+
+		l += tl;
+	}
+
+	return l;
+}
+
+
+
+
+
+// id newdict_lookup_backend(struct newdict *d, uchar *str, long major, long minor)
+// {
+// 	struct newdict *s;
+
+// 	for(s = d->prev; s != d; s = s->prev)
+// 	{
+// 		if(major == -1 || minor == -1 || (s->major == major && s->minor == minor))
+// 		{
+// 			if(cisc(str, s->str))
+// 			{
+// 				return s->n;
+// 			}
+// 		}
+// 	}
+
+// 	return 0;
+// }
+
+// id newdict_id_from_str_with_hint(struct newdict *d, uchar *str, long major, long minor)
+// {
+// 	id id;
+
+// 	id = newdict_lookup_backend(d, str, major, minor);
+// 	if(id) return id;
+
+// 	id = newdict_lookup_backend(d, str, -1, -1);
+// 	if(id) return id;
+
+// 	id = newdict_append(d, str, major, minor);
+// 	return id;
+// }
+
+
+
+/* COMPLETE ODDBALL */
+
+// void reref(char **dest, long major, struct newdict *destdict, struct obj *src, struct obj *srcdict, id specialfrom, id specialto)
+// {
+// 	const char OFFSETS[11][3] = {
+// 		/* 0*/ {0},
+// 		/* 1*/ {0},
+// 		/* 2*/ {0},
+// 		/* 3*/ {0},
+// 		/* 4*/ {0},
+// 		/* 5*/ {2,4,0},
+// 		/* 6*/ {2,0},
+// 		/* 7*/ {0},
+// 		/* 8*/ {0},
+// 		/* 9*/ {4,0},
+// 		/*10*/ {4,6,0},
+// 	};
+
+// 	unsigned long len;
+// 	char t;
+// 	int i;
+
+// 	len = obj_size(src);
+// 	t = obj_type(src);
+
+// 	memcpy(*dest, src->at, len);
+
+// 	for(i=0; OFFSETS[t][i]; i++)
+// 	{
+// 		id is;
+
+// 		is = ntohs(*(id *)(*dest + OFFSETS[t][i]));
+
+// 		//printf("Converting: type %d offset %d original %d special %d->%d\n", t, OFFSETS[t][i], is, specialfrom, specialto);
+
+// 		if(is == specialfrom)
+// 		{
+// 			is = specialto;
+// 		}
+// 		else
+// 		{
+// 			uchar *str = dict_str_from_id(srcdict, is);
+// 			if(!str) printf("Bullshit string\n");
+// 			//printf("... intermediate string %x %.*s\n", str, *str, str+1);
+// 			is = newdict_id_from_str_with_hint(destdict, str, major, is);
+// 		}
+
+// 		//printf("... to %d\n", is);
+
+// 		*(id *)(*dest + OFFSETS[t][i]) = htons(is);
+// 	}
+
+// 	*dest += len;
+
+// 	if((long)(*dest) & 1) *(*dest)++ = 0;
+// }
+
+
+void obj_copy(struct obj *dest, struct obj *src)
+{
+	char *destthing;
+
+	obj_next(dest);
+	destthing = dest->at;
+
+	memcpy(destthing, src->at, obj_size(src));
+
+	obj_next(dest);
+	obj_pad(dest);
+	dest->at = destthing;
+}
+
+int obj_islastinmod(struct obj *o)
+{
+	struct obj j;
+	char t;
+
+	memcpy(&j, o, sizeof (struct obj));
+
+	obj_next(&j);
+	t = obj_type(&j);
+
+	return t == C_MODULE || t == C_LAST;
+}

Tools/ToolSource/Tools.make

@@ -0,0 +1,12 @@
+LibFiles-68K    =	¶
+					"{Libraries}Stubs.o"				¶
+					"{CLibraries}StdCLib.o"				¶
+					"{Libraries}MacRuntime.o"			¶
+					"{Libraries}IntEnv.o"				¶
+					"{Libraries}Interface.o"			¶
+
+"{ToolSrcDir}Vectorize.c.o"			Ä	"{ToolSrcDir}Vectorize.c" "{ToolSrcDir}MPWObjFuncs.c"
+	SC -o {Targ} "{ToolSrcDir}Vectorize.c"
+
+"{ToolDir}Vectorize"				Ä	"{ToolSrcDir}Vectorize.c.o"
+	ILink -d -t 'MPST' -c 'MPS ' -o {Targ} {LibFiles-68k} "{ToolSrcDir}Vectorize.c.o"

Tools/ToolSource/Vectorize.c

@@ -0,0 +1,787 @@
+// This tool will be implemented using only standard C, the better 
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stddef.h>
+#include <string.h>
+#include "MPWObjFuncs.c"
+
+#ifndef __GNUC__
+#include <Finder.h>
+#include <Files.h>
+#endif
+
+#define ERRSTR "# Vectorize Error: "
+#define WARNSTR "# Vectorize Warning: "
+
+// Default options
+
+const char PASSIVE_OFFSETS[11][3] = {
+	/* 0*/ {0},
+	/* 1*/ {0},
+	/* 2*/ {0},
+	/* 3*/ {0},
+	/* 4*/ {0},
+	/* 5*/ {2,0},
+	/* 6*/ {2,0},
+	/* 7*/ {0},
+	/* 8*/ {0},
+	/* 9*/ {4,0},
+	/*10*/ {4,6,0},
+};
+
+const char OFFSETS[11][3] = {
+	/* 0*/ {0},
+	/* 1*/ {0},
+	/* 2*/ {0},
+	/* 3*/ {0},
+	/* 4*/ {4,0},
+	/* 5*/ {2,4,0},
+	/* 6*/ {2,0},
+	/* 7*/ {0},
+	/* 8*/ {0},
+	/* 9*/ {4,0},
+	/*10*/ {4,6,0},
+};
+
+
+int warnings = 1;
+char *patchObjPath = NULL;
+char *symFilePath = NULL;
+int do_patch = 1;
+char *outputObjPath = NULL;
+char **inputPaths = NULL;
+int inputCount = 0;
+
+void to_pas(uchar *p, char *c)
+{
+	int sl = strlen(c);	
+	p[0] = sl;
+	memcpy(p+1, c, sl);
+}
+
+char *fname(char *x)
+{
+	char *y = x;
+
+	while(*y) y++;
+
+	while(y != x && y[-1] != ':') y--;
+
+	return y;
+}
+
+char *slurp(char *path)
+{
+	FILE *f;
+	long pos;
+	char *bytes;
+
+	f = fopen(path, "rb");
+	if(f == NULL) return NULL;
+
+	fseek(f, 0, SEEK_END);
+	pos = ftell(f);
+	fseek(f, 0, SEEK_SET);
+
+	bytes = (char *)malloc(pos);
+	if(bytes == NULL) return NULL;
+
+	fread(bytes, pos, 1, f);
+
+	fclose(f);
+
+	return bytes;
+}
+
+int blat(char *path, char *buf, ulong len)
+{
+	FILE *f;
+
+	f = fopen(path, "wb");
+	if(f == NULL) return 1;
+
+	fwrite(buf, len, 1, f);
+
+	fclose(f);
+
+	return 0;
+}
+
+void printUsage(char *cmdName)
+{
+	printf("USAGE: %s [-w] [-v PATCHES.o | -nopatch] [-log ROM.sym] -o ROM.lib INPUT1.o ...\n", cmdName);
+}
+
+int parseOpts(int argc, char **argv)
+{
+	int i;
+	int err = 0;
+
+	for(i=1; i<argc; i++)
+	{
+		if(!strcmp(argv[i], "-w"))
+		{
+			warnings = 0;
+		}
+		else if(!strcmp(argv[i], "-nopatch"))
+		{
+			do_patch = 0;
+		}
+		else if(!strcmp(argv[i], "-v"))
+		{
+			if(i == argc-1)
+			{
+				err = 1;
+				break;
+			}
+
+			patchObjPath = argv[i+1];
+			i++;
+		}
+		else if(!strcmp(argv[i], "-log"))
+		{
+			if(i == argc-1)
+			{
+				err = 1;
+				break;
+			}
+
+			symFilePath = argv[i+1];
+			i++;
+		}
+		else if(!strcmp(argv[i], "-o"))
+		{
+			if(i == argc-1)
+			{
+				err = 1;
+				break;
+			}
+
+			outputObjPath = argv[i+1];
+			i++;
+		}
+		else if(argv[i][0] == '-')
+		{
+			err = 2;
+			break;
+		}
+		else
+		{
+			inputPaths = argv + i;
+			inputCount = argc - i;
+			break;
+		}
+
+	}
+
+	// Report lexical errors (from the loop)
+	if(err == 2)
+	{
+		fprintf(stderr, ERRSTR "%s is an unknown argument.", argv[i]);
+	}
+	else if(err == 1)
+	{
+		fprintf(stderr, ERRSTR "%s cannot be the last argument.", argv[i]);
+	}
+	
+	// Check for semantic errors (basic sanity checks)
+	if(!err)
+	{
+		if(do_patch && patchObjPath == NULL)
+		{
+			fprintf(stderr, ERRSTR "An MPW object containing patches must be specified with -v, unless -nopatch is used.\n");
+			err = 3;
+		}
+
+		if(outputObjPath == NULL)
+		{
+			fprintf(stderr, ERRSTR "An output file must be specified with -o.\n");
+			err = 3;
+		}
+
+		if(inputCount == 0)
+		{
+			fprintf(stderr, ERRSTR "At least one input file must be specified.\n");
+			err = 3;
+		}
+	}
+
+	if(err)
+	{
+		printUsage(argv[0]);
+	}
+
+	return err;
+}
+
+
+struct tblent
+{
+	uchar *name; /* without __v__ */
+	char *data;
+	long len;
+	id __v__id;
+	id clean_id;
+	long offset_of_parent_in_module; /* bit of a hack, for sorting the patchstack */
+};
+
+
+int pstrcmp(const void *aa, const void *bb)
+{
+	const unsigned char *a = (const unsigned char *)aa;
+	const unsigned char *b = (const unsigned char *)bb;
+
+
+	int cl = *a;
+	int r;
+	if(*b < cl) cl = *b;
+
+	//printf("Comparing %.*s to %.*s\n", *a, a+1, *b, b+1);
+
+	r = memcmp(a+1, b+1, cl);
+
+	if(r) return r;
+
+	if(*b > *a) return -1;
+
+	if(*b < *a) return 1;
+
+	return 0;
+}
+
+int tblcmp(const void *a, const void *b)
+{
+	return pstrcmp(((struct tblent *)a)->name, ((struct tblent *)b)->name);
+}
+
+int ptch_order_cmp(const void *aa, const void *bb)
+{
+	long a = (**(struct tblent **)aa).offset_of_parent_in_module;
+	long b = (**(struct tblent **)bb).offset_of_parent_in_module;
+
+	if(a > b) return -1;
+	if(a < b) return 1;
+	return 0;
+}
+
+// int tblcmp2(const void *a, const void *b)
+// {
+// 	int res;
+// 	printf("Comparing %.*s to %.*s", *((struct tblent *)a)->name, ((struct tblent *)a)->name+1, *((struct tblent *)b)->name, ((struct tblent *)b)->name+1);
+// 	res = pstrcmp(((struct tblent *)a)->name, ((struct tblent *)b)->name);
+// 	if(!res) printf(" ...match!");
+// 	printf("\n");
+// 	return res;
+// }
+
+
+// void print_tbl(struct tblent *tbl, long cnt)
+// {
+// 	long i;
+
+// 	for(i=0; i<cnt; i++)
+// 	{
+// 		printf("%05d = %.*s\n", tbl[i].id, *(tbl[i].name), (tbl[i].name)+1);
+// 	}
+// }
+
+
+void debug_print_about_patch(FILE *l, char *data, long len)
+{
+	int reg;
+	unsigned short vtbl, voff;
+
+	if(!data)
+	{
+		reg = -1;
+	}
+	else if(len != 10)
+	{
+		reg = -2;
+	}
+	else if(data[0] == 0x2f && data[1] == 0x30 && (uchar)data[2] == 0x81 && (uchar)data[3] == 0xe2 && data[8] == 0x4e && data[9] == 0x75)
+	{
+		reg = 7;
+		vtbl = shortfrom(data + 4);
+		voff = shortfrom(data + 6);
+	}
+	else if(data[0] == 0x22 && data[4] == 0x22 && data[8] == 0x4e) /* dirty shortcut */
+	{
+		reg = data[9] & 7;
+		vtbl = shortfrom(data + 2);
+		voff = shortfrom(data + 6);
+	}
+	else
+	{
+		reg = -2;
+	}
+
+	if(reg == -2)
+	{
+		fprintf(l, "UNKNOWN %db PATCH", len);
+	}
+	else if(reg == -1)
+	{
+		fprintf(l, "no patch");
+	}
+	else
+	{
+		fprintf(l, "patch $%04x,$%04x,A%d", vtbl, voff, reg);
+	}
+}
+
+
+int main(int argc, char **argv)
+{
+	struct obj dest;
+	struct tblent *tbl;
+	long tblcnt = 0;
+	int delta;
+	int file_i;
+	FILE *l = NULL; /* log file */
+	int isfirst = 1;
+
+
+
+	/* GET OUR COMMAND LINE */
+	if(parseOpts(argc, argv)) return 1;
+
+	if(NULL != symFilePath)
+	{
+		l = fopen(symFilePath, "w");
+		if(!l)
+		{
+			fprintf(stderr, ERRSTR "Failed to open sym file %s\n", symFilePath);
+			return 1;
+		}
+	}
+
+	if(l)
+	{
+		fprintf(l, "      #     # #######  #####  ####### ####### ######  ### ####### ####### \n");
+		fprintf(l, "      #     # #       #     #    #    #     # #     #  #       #  #       \n");
+		fprintf(l, "      #     # #       #          #    #     # #     #  #      #   #       \n");
+		fprintf(l, "      #     # #####   #          #    #     # ######   #     #    #####   \n");
+		fprintf(l, "       #   #  #       #          #    #     # #   #    #    #     #       \n");
+		fprintf(l, "        # #   #       #     #    #    #     # #    #   #   #      #       \n");
+		fprintf(l, "         #    #######  #####     #    ####### #     # ### ####### ####### \n");
+		fprintf(l, "\n");
+		fprintf(l, "# This log file is formatted as an MPW worksheet, to help you troubleshoot\n");
+		fprintf(l, "# your build.\n");
+		fprintf(l, "\n");
+		fprintf(l, "# (Fake)Vectorize attempts to replace a lost Apple build tool. It is mostly\n");
+		fprintf(l, "# based on patent US5546586, \"Method and apparatus for vectorizing the contents\n");
+		fprintf(l, "# of a read only memory device without modifying underlying source code\".\n");
+
+		fprintf(l, "\n");
+
+		if(do_patch)
+		{
+			fprintf(l, "# Dump the input file containing \"vector patches\":\n");
+			fprintf(l, "  Set PatchDump \"{TempFolder}VectorPatchDump\"; DumpObj \"%s\" > \"{PatchDump}\"\n\n", patchObjPath);
+			fprintf(l, "  # and navigate its contents:\n");
+			fprintf(l, "    Find /NAVIGATE PATCHES/ \"{Active}\"\n");
+
+			fprintf(l, "\n");
+		}
+
+		fprintf(l, "# Dump the \"vectorized\" output file: (takes a while)\n");
+		fprintf(l, "  Set RomDump \"{TempFolder}VectorRomDump\"; DumpObj \"%s\" > \"{RomDump}\"\n", outputObjPath);
+		fprintf(l, "\n");
+		fprintf(l, "  # and look at it:\n");
+		fprintf(l, "    File \"{RomDump}\"\n");
+		fprintf(l, "\n");
+		fprintf(l, "  # or navigate it input-file-wise:\n");
+		fprintf(l, "    Find /NAVIGATE OUTPUT/ \"{Active}\"\n");
+		for(file_i=0; file_i<inputCount; file_i++)
+		{
+			fprintf(l, "      Find /¶\"%s¶\"/ \"{Active}\"\n", inputPaths[file_i]);
+		}
+
+		fprintf(l, "\n");
+	}
+
+	dest.buf = dest.at = calloc(0x400000, 1);
+	if(!dest.buf)
+	{
+		fprintf(stderr, ERRSTR "Failed to calloc 4MB dest buffer\n");
+		return 1;
+	}
+
+	/* Create a First record (remember that MPW objects are fully ascending) */
+	dest.at[0] = 1;
+	dest.at[1] = 1;
+	dest.at[2] = 0;
+	dest.at[3] = 2;
+
+	if(do_patch)			/* PROCESS THE PATCH FILE (and keep it around because we use it for strings) */
+	{
+		char *patch_bin;
+		struct obj patch_obj, patch_dict;
+
+		patch_bin = slurp(patchObjPath);
+		if(!patch_bin)
+		{
+			fprintf(stderr, ERRSTR "Failed to slurp patch file\n");
+			return 2;
+		}
+
+		tbl = (struct tblent *)calloc(5000, sizeof (struct tblent));
+		if(!tbl)
+		{
+			fprintf(stderr, ERRSTR "Failed to malloc tbl\n");
+			return 3;
+		}
+
+		if(l) fprintf(l, "#############################  NAVIGATE PATCHES  #############################\n");
+		if(l) fprintf(l, "# (These command lines are a bit clumsy. Oh well...)\n\n");
+
+		obj_init(&patch_obj, patch_bin);
+		obj_init(&patch_dict, patch_bin);
+
+		while(obj_nextmod(&patch_obj))
+		{
+			struct obj scratch;
+
+			uchar *name;
+			char *data = NULL;
+			long len = 0;
+			id __v__id;
+
+
+			memcpy(&scratch, &patch_obj, sizeof (struct obj));		/* find the module's Size record */
+
+			while(obj_nextinmod(&scratch))
+			{
+				if(obj_type(&scratch) == C_SIZE)
+				{
+					len = obj_contsize(&scratch);
+					break;
+				}
+			}
+
+
+			if(len)
+			{
+				memcpy(&scratch, &patch_obj, sizeof (struct obj));	/* find the module's Contents record (hopefully only one) */
+
+				while(obj_nextinmod(&scratch))
+				{
+					if(obj_type(&scratch) == C_CONTENTS)
+					{
+						data = scratch.at + 4;						/* actual data starts 4 bytes into Contents record */
+						if(obj_flags(&scratch) & 8) data += 4;		/* unless the offset or repeat fields are flagged as present */
+						if(obj_flags(&scratch) & 16) data += 2;
+
+						if(scratch.at + obj_recsize(&scratch) != data + len)
+						{
+							fprintf(stderr, ERRSTR "Patch file contains module with size/contents mismatch\n");
+							return 1;
+						}
+
+						break;
+					}
+				}
+
+				if(!data)
+				{
+					fprintf(stderr, ERRSTR "Patch file contains module with nonzero Size but no Contents\n");
+					return 1;
+				}
+			}
+
+
+			name = dict_str_from_id(&patch_dict, obj_id(&patch_obj));
+			if(!name)
+			{
+				fprintf(stderr, ERRSTR "Patch module with unlisted ID\n");
+				return 1;
+			}
+
+
+			__v__id = tblcnt + 1;
+
+			dict_append_v(&dest, name, __v__id);					/* create a "__v__" dict id for the code that this patch will hide */
+																	/* 1 dict append to 1 tbl append (dict ID = tbl index + 1) */
+
+			tbl[tblcnt].name = name;
+			tbl[tblcnt].data = data;
+			tbl[tblcnt].len = len;
+			tbl[tblcnt].clean_id = 0;
+			tbl[tblcnt].__v__id = __v__id;							/* equals ID assigned just above */
+
+
+			if(l) fprintf(l, "File \"{PatchDump}\"; Line 0; File \"{PatchDump}\"; Find /Module=¶\"%.*s¶\"/ # ", *name, name+1);
+			if(l) debug_print_about_patch(l, data, len);			/* log some MPW code that can show the user this routine's disasm */
+			if(l) fprintf(l, "\n");
+
+			tblcnt ++;
+		}
+
+		obj_pad(&dest);
+
+		/* The most important part: create a name-searchable table of vector glue code */
+		qsort((void *)tbl, tblcnt, sizeof (struct tblent), tblcmp);
+
+		if(l) fprintf(l, "\n");
+	}
+
+	delta = tblcnt + 1;
+
+
+	if(l) fprintf(l, "##############################  NAVIGATE OUTPUT  #############################\n\n");
+
+	for(file_i=0; file_i<inputCount; file_i++)
+	{
+		char *cur_bin;
+		struct obj cur_obj, cur_dict;
+
+		char *mod_copy_start = NULL;				/* dest's copy of this module record */
+		char *mod_copy_last = NULL;					/* dest's copy of the last record in this module (not including new patches) */
+		char *mod_sizeobj = NULL;					/* dest's copy of this module's size record, for offsetting any patches */
+
+		struct tblent *patchstack[512];
+		int patchcnt = 0;
+
+		id nextdelta = delta + 1;
+
+
+
+		cur_bin = slurp(inputPaths[file_i]);
+		if(!cur_bin)
+		{
+			fprintf(stderr, ERRSTR "Failed to slurp input file %s\n", inputPaths[file_i]);
+			return 4;
+		}
+
+		if(l) fprintf(l, "# \"%s\"\n", inputPaths[file_i]);
+		if(l) fprintf(l, "   Find /Åjump to next fileÅ/ \"{Active}\"\n\n");
+
+		obj_init(&cur_obj, cur_bin);
+		obj_init(&cur_dict, cur_bin);
+
+		//fprintf(stderr, "Delta is %d for %s\n", delta, inputPaths[file_i]);
+
+
+		/* done slurping */
+
+
+		for(obj_next(&cur_obj); obj_type(&cur_obj) != C_LAST; obj_next(&cur_obj))			/* for each RECORD in the file (excluding First + Last) */
+		{
+			char t = obj_type(&cur_obj);
+			int i;
+
+			obj_copy(&dest, &cur_obj);							/* COPY THE RECORD STRAIGHT IN (BRAVE!) */
+
+			mod_copy_last = dest.at;
+
+			/* do (some of) the renumbering here, i guess */
+			for(i=0; OFFSETS[t][i]; i++)
+			{
+				id is;
+				is = shortfrom(dest.at + OFFSETS[t][i]);
+				setshort(dest.at + OFFSETS[t][i], is + delta);
+			}
+
+
+			if(t == C_MODULE)
+			{
+				mod_copy_start = dest.at;
+				mod_sizeobj = NULL;
+
+				dest.at[1] |= 1<<7; // force active
+			}
+
+			if(t == C_DICT)
+			{
+				id hid = dict_highestid(&dest);
+				if(hid > nextdelta) nextdelta = hid;
+			}
+
+			if(t == C_SIZE)
+			{
+				mod_sizeobj = dest.at;
+			}
+
+			if(t == C_MODULE || t == C_ENTRYPT)
+			{
+				struct tblent fodder_for_bsearch, *ent;
+				uchar *my_name;
+				char *patch_mod = NULL;
+				int is_vectorized = 0;
+
+				my_name = dict_str_from_id(&cur_dict, obj_id(&cur_obj));
+
+				if(!my_name)
+				{
+					fprintf(stderr, ERRSTR "Module with unlisted ID\n");
+					return 1;
+				}
+
+				fodder_for_bsearch.name = my_name;
+				ent = (struct tblent *)bsearch(&fodder_for_bsearch, tbl, tblcnt, sizeof (struct tblent), tblcmp);
+
+				if(ent)											/* there is a patch module, but it may be zero-size! */
+				{
+					if(ent->data && ent->len)
+					{
+						ent->clean_id = obj_id(&dest);
+						patchstack[patchcnt++] = ent;
+						is_vectorized = 1;
+
+						if(t == C_MODULE)
+						{
+							ent->offset_of_parent_in_module = 0;
+						}
+						else
+						{
+							ent->offset_of_parent_in_module = longfrom(dest.at+4);
+						}
+					}
+				}
+				else
+				{
+					if(warnings)
+					{
+						fprintf(stderr, WARNSTR "Missing vector patch: %.*s\n", *my_name, my_name+1);
+					}
+				}
+
+				if(l)
+				{
+					if(t == C_MODULE)
+					{
+						fprintf(l, "File \"{RomDump}\"; Line 0; File \"{RomDump}\"; Find /Module=¶\"");
+					}
+					else
+					{
+						fprintf(l, "  File \"{RomDump}\"; Line 0; File \"{RomDump}\"; Find /Entry=¶\"");
+					}
+
+					if(is_vectorized) fprintf(l, "__v__");
+
+					fprintf(l, "%.*s¶\"/ # ID %d", *my_name, my_name+1, is_vectorized ? ent->__v__id : obj_id(&dest));
+
+					if(t == C_ENTRYPT)
+					{
+						fprintf(l, ", offset $%x", longfrom(dest.at+4));
+					}
+
+					fprintf(l, "\n");
+				}
+			}
+
+			if(mod_copy_start && obj_islastinmod(&cur_obj))		/* empty the patchstack */
+			{
+				int pi;
+
+				// qsort((void *)patchstack, patchcnt, sizeof (struct tblent *), ptch_order_cmp);
+
+				for(pi=0; pi<patchcnt; pi++)
+				{
+					struct obj scratch;
+					long original_size;
+					uchar *my_name;
+
+					my_name = patchstack[pi]->name;
+
+					original_size = longfrom(mod_sizeobj + 2);
+
+					if(l) fprintf(l, "    File \"{RomDump}\"; Line 0; File \"{RomDump}\"; Find /Entry=¶\"%.*s¶\"/ # patch ID %d, ", *my_name, my_name+1, patchstack[pi]->clean_id);
+					if(l) debug_print_about_patch(l, patchstack[pi]->data, patchstack[pi]->len);
+					if(l) fprintf(l, ", offset $%x\n", original_size);
+
+					obj_next(&dest);															/* EXTRA RECORD: CONTENTS */
+					dest.at[0] = C_CONTENTS;														/* type */
+					dest.at[1] = 8;																	/* offset field present */
+					setshort(dest.at + 2, 8 + patchstack[pi]->len);									/* size = 8b header, plus data */
+					setlong(dest.at + 4, original_size);											/* offset = end of module data so far */
+					memcpy(dest.at + 8, patchstack[pi]->data, patchstack[pi]->len);					/* actual, you know, *contents* */
+
+					obj_next(&dest);															/* EXTRA RECORD: ENTRY POINT (of patch) */
+					dest.at[0] = C_ENTRYPT;															/* type */
+					dest.at[1] = 8;																	/* external entry point */
+					setshort(dest.at + 2, patchstack[pi]->clean_id);								/* ID */
+					setlong(dest.at + 4, original_size);											/* offset = end of module data so far */
+
+					/* Increment the size of this module */
+					setlong(mod_sizeobj + 2, original_size + patchstack[pi]->len);
+
+
+					/* Now do the dirty work of changing self-references to use __v__... */
+
+					for(scratch.at=mod_copy_start; scratch.at<=mod_copy_last; obj_next(&scratch))
+					{
+						char tt = obj_type(&scratch);
+
+						for(i=0; PASSIVE_OFFSETS[tt][i]; i++)
+						{
+							id is = shortfrom(scratch.at + PASSIVE_OFFSETS[tt][i]);
+							if(is == patchstack[pi]->clean_id)
+							{
+								setshort(scratch.at + PASSIVE_OFFSETS[tt][i], patchstack[pi]->__v__id);
+							}
+						}
+					}
+				} /* patchstack loop */
+
+				if(l) fprintf(l, "\n");			/* newline before each module... nice touch */
+
+				patchcnt = 0;
+			} /* do patchstack or not? */
+		} /* for each record */
+
+		free(cur_bin);
+		//fprintf(stderr, "Culminating in %d\n", nextdelta);
+		delta = nextdelta + 1;
+
+		// delta += 5000;
+		// delta -= (delta % 5000);
+	}
+
+	obj_next(&dest);
+	dest.at[0] = C_LAST;
+	dest.at[1] = 0;
+
+	if(blat(outputObjPath, dest.buf, (long)(dest.at) - (long)(dest.buf) + 2))
+	{
+		fprintf(stderr, ERRSTR "Failed to write output file\n");
+		return 5;
+	}
+	
+	if(l) fclose(l);
+	
+	#ifndef __GNUC__
+	{
+		FInfo fi;
+		Str255 pas;
+		int e;
+		
+		to_pas(pas, outputObjPath);
+		
+		e = GetFInfo(pas, 0, &fi);
+		if (e == 0)
+		{
+			fi.fdType = 0x4F424A20;		/* TEXT */
+			fi.fdCreator = 0x4D505320;	/* MPS  */
+			e = SetFInfo(pas, 0, &fi);
+		}
+		
+		if(symFilePath)
+		{
+			to_pas(pas, symFilePath);
+			
+			e = GetFInfo(pas, 0, &fi);
+			if (e == 0)
+			{
+				fi.fdType = 0x54455854;		/* TEXT */
+				fi.fdCreator = 0x4D505320;	/* MPS  */
+				e = SetFInfo(pas, 0, &fi);
+			}
+		}
+	}
+	#endif
+
+	return 0;
+}