Turn pack200 into an actual library

1 files changed, 188 insertions, 482 deletions

diff --git a/depends/pack200/src/unpack.cpp b/depends/pack200/src/unpack.cpp
index a562d442..8a66d42a 100644
--- a/depends/pack200/src/unpack.cpp
+++ b/depends/pack200/src/unpack.cpp
@@ -51,6 +51,7 @@
 #include <assert.h>
 #include <limits.h>
 #include <time.h>
+#include <stdint.h>
 
 #include "defines.h"
 #include "bytes.h"
@@ -79,23 +80,15 @@ enum
 	REQUESTED_LDC = -1
 };
 
-#define NO_INORD ((uint) - 1)
+#define NO_INORD ((uint32_t) - 1)
 
 struct entry
 {
 	byte tag;
-
-#if 0
-  byte bits;
-  enum {
-    //EB_EXTRA = 1,
-    EB_SUPER = 2
-  };
-#endif
 	unsigned short nrefs; // pack w/ tag
 
 	int outputIndex;
-	uint inord; // &cp.entries[cp.tag_base[this->tag]+this->inord] == this
+	uint32_t inord; // &cp.entries[cp.tag_base[this->tag]+this->inord] == this
 
 	entry **refs;
 
@@ -104,10 +97,10 @@ struct entry
 	{
 		bytes b;
 		int i;
-		jlong l;
+		int64_t l;
 	} value;
 
-	void requestOutputIndex(cpool &cp, int req = REQUESTED);
+	void requestOutputIndex(constant_pool &cp, int req = REQUESTED);
 	int getOutputIndex()
 	{
 		assert(outputIndex > NOT_REQUESTED);
@@ -116,7 +109,7 @@ struct entry
 
 	entry *ref(int refnum)
 	{
-		assert((uint)refnum < nrefs);
+		assert((uint32_t)refnum < nrefs);
 		return refs[refnum];
 	}
 
@@ -178,11 +171,15 @@ struct entry
 
 	bool tagMatches(byte tag2)
 	{
-		return (tag2 == tag) || (tag2 == CONSTANT_Utf8 && tag == CONSTANT_Signature);
+		return (tag2 == tag) || (tag2 == CONSTANT_Utf8 && tag == CONSTANT_Signature) ||
+			   (tag2 == CONSTANT_Literal && tag >= CONSTANT_Integer && tag <= CONSTANT_String &&
+				tag != CONSTANT_Class) ||
+			   (tag2 == CONSTANT_Member && tag >= CONSTANT_Fieldref &&
+				tag <= CONSTANT_InterfaceMethodref);
 	}
 };
 
-entry *cpindex::get(uint i)
+entry *cpindex::get(uint32_t i)
 {
 	if (i >= len)
 		return nullptr;
@@ -250,16 +247,16 @@ int entry::typeSize()
 	}
 }
 
-inline cpindex *cpool::getFieldIndex(entry *classRef)
+inline cpindex *constant_pool::getFieldIndex(entry *classRef)
 {
 	assert(classRef->tagMatches(CONSTANT_Class));
-	assert((uint)classRef->inord < (uint)tag_count[CONSTANT_Class]);
+	assert((uint32_t)classRef->inord < (uint32_t)tag_count[CONSTANT_Class]);
 	return &member_indexes[classRef->inord * 2 + 0];
 }
-inline cpindex *cpool::getMethodIndex(entry *classRef)
+inline cpindex *constant_pool::getMethodIndex(entry *classRef)
 {
 	assert(classRef->tagMatches(CONSTANT_Class));
-	assert((uint)classRef->inord < (uint)tag_count[CONSTANT_Class]);
+	assert((uint32_t)classRef->inord < (uint32_t)tag_count[CONSTANT_Class]);
 	return &member_indexes[classRef->inord * 2 + 1];
 }
 
@@ -277,7 +274,6 @@ struct inner_class
 void unpacker::free()
 {
 	int i;
-	assert(infileptr == nullptr); // caller resp.
 	if (jarout != nullptr)
 		jarout->reset();
 	if (gzin != nullptr)
@@ -287,7 +283,9 @@ void unpacker::free()
 	}
 	if (free_input)
 		input.free();
-	// free everybody ever allocated with U_NEW or (recently) with T_NEW
+	/*
+	 * free everybody ever allocated with U_NEW or (recently) with T_NEW
+	 */
 	assert(smallbuf.base() == nullptr || mallocs.contains(smallbuf.base()));
 	assert(tsmallbuf.base() == nullptr || tmallocs.contains(tsmallbuf.base()));
 	mallocs.freeAll();
@@ -318,10 +316,10 @@ void unpacker::free()
 // Will eagerly read ahead by larger chunks, if possible.
 // Returns false if (rplimit-rp) is not at least 'more',
 // unless rplimit hits input.limit().
-bool unpacker::ensure_input(jlong more)
+bool unpacker::ensure_input(int64_t more)
 {
-	julong want = more - input_remaining();
-	if ((jlong)want <= 0)
+	uint64_t want = more - input_remaining();
+	if ((int64_t)want <= 0)
 		return true; // it's already in the buffer
 	if (rplimit == input.limit())
 		return true; // not expecting any more
@@ -333,23 +331,22 @@ bool unpacker::ensure_input(jlong more)
 		rplimit = input.limit();
 		return true;
 	}
-	CHECK_0;
 
-	julong remaining = (input.limit() - rplimit); // how much left to read?
+	uint64_t remaining = (input.limit() - rplimit); // how much left to read?
 	byte *rpgoal = (want >= remaining) ? input.limit() : rplimit + (size_t)want;
 	enum
 	{
 		CHUNK_SIZE = (1 << 14)
 	};
-	julong fetch = want;
+	uint64_t fetch = want;
 	if (fetch < CHUNK_SIZE)
 		fetch = CHUNK_SIZE;
 	if (fetch > remaining * 3 / 4)
 		fetch = remaining;
 	// Try to fetch at least "more" bytes.
-	while ((jlong)fetch > 0)
+	while ((int64_t)fetch > 0)
 	{
-		jlong nr = (*read_input_fn)(this, rplimit, fetch, remaining);
+		int64_t nr = (*read_input_fn)(this, rplimit, fetch, remaining);
 		if (nr <= 0)
 		{
 			return (rplimit >= rpgoal);
@@ -358,7 +355,7 @@ bool unpacker::ensure_input(jlong more)
 		rplimit += nr;
 		fetch -= nr;
 		bytes_read += nr;
-		assert(remaining == (julong)(input.limit() - rplimit));
+		assert(remaining == (uint64_t)(input.limit() - rplimit));
 	}
 	return true;
 }
@@ -434,10 +431,10 @@ void unpacker::putu4_at(byte *wp, int n)
 	wp[3] = (n) >> 0;
 }
 
-void unpacker::putu8_at(byte *wp, jlong n)
+void unpacker::putu8_at(byte *wp, int64_t n)
 {
-	putu4_at(wp + 0, (int)((julong)n >> 32));
-	putu4_at(wp + 4, (int)((julong)n >> 0));
+	putu4_at(wp + 0, (int)((uint64_t)n >> 32));
+	putu4_at(wp + 4, (int)((uint64_t)n >> 0));
 }
 
 void unpacker::putu2(int n)
@@ -450,7 +447,7 @@ void unpacker::putu4(int n)
 	putu4_at(put_space(4), n);
 }
 
-void unpacker::putu8(jlong n)
+void unpacker::putu8(int64_t n)
 {
 	putu8_at(put_space(8), n);
 }
@@ -521,11 +518,6 @@ void *unpacker::alloc_heap(size_t size, bool smallOK, bool temp)
 void unpacker::saveTo(bytes &b, byte *ptr, size_t len)
 {
 	b.ptr = U_NEW(byte, add_size(len, 1));
-	if (aborting())
-	{
-		b.len = 0;
-		return;
-	}
 	b.len = len;
 	b.copyFrom(ptr, len);
 }
@@ -591,8 +583,7 @@ void unpacker::read_file_header()
 		// Therefore, the caller must use only a bare minimum of read-ahead.
 		if (inbytes.len > FIRST_READ)
 		{
-			abort("too much read-ahead");
-			return;
+			unpack_abort("too much read-ahead");
 		}
 		input.set(initbuf, sizeof(initbuf));
 		input.b.clear();
@@ -605,7 +596,7 @@ void unpacker::read_file_header()
 	// but is certain not to overflow past the archive_header.
 	input.b.len = FIRST_READ;
 	if (!ensure_input(FIRST_READ))
-		abort("EOF reading archive magic number");
+		unpack_abort("EOF reading archive magic number");
 
 	if (rp[0] == 'P' && rp[1] == 'K')
 	{
@@ -621,7 +612,6 @@ void unpacker::read_file_header()
 			{
 				// Get some breathing room.
 				input.set(U_NEW(byte, (size_t)CHUNK + C_SLOP), (size_t)CHUNK);
-				CHECK;
 			}
 			rp = rplimit = input.base();
 			if (!ensure_input(1))
@@ -658,9 +648,8 @@ void unpacker::read_file_header()
 				magic, majver, minver, JAVA_PACKAGE_MAGIC, JAVA5_PACKAGE_MAJOR_VERSION,
 				JAVA5_PACKAGE_MINOR_VERSION, JAVA_PACKAGE_MAGIC, JAVA6_PACKAGE_MAJOR_VERSION,
 				JAVA6_PACKAGE_MINOR_VERSION);
-		abort(message);
+		unpack_abort(message);
 	}
-	CHECK;
 
 	archive_options = hdr.getInt();
 	hdrVals += 1;
@@ -672,15 +661,15 @@ void unpacker::read_file_header()
 	if ((archive_options & ~OPTION_LIMIT) != 0)
 	{
 		fprintf(stderr, "Warning: Illegal archive options 0x%x\n", archive_options);
-		abort("illegal archive options");
+		unpack_abort("illegal archive options");
 		return;
 	}
 
 	if ((archive_options & AO_HAVE_FILE_HEADERS) != 0)
 	{
-		uint hi = hdr.getInt();
-		uint lo = hdr.getInt();
-		julong x = band::makeLong(hi, lo);
+		uint32_t hi = hdr.getInt();
+		uint32_t lo = hdr.getInt();
+		uint64_t x = band::makeLong(hi, lo);
 		archive_size = (size_t)x;
 		if (archive_size != x)
 		{
@@ -701,12 +690,11 @@ void unpacker::read_file_header()
 	int header_size_1 = (int)(rplimit - rp);	  // buffered unused initial fragment
 	int header_size = header_size_0 + header_size_1;
 	unsized_bytes_read = header_size_0;
-	CHECK;
 	if (foreign_buf)
 	{
 		if (archive_size > (size_t)header_size_1)
 		{
-			abort("EOF reading fixed input buffer");
+			unpack_abort("EOF reading fixed input buffer");
 			return;
 		}
 	}
@@ -714,17 +702,16 @@ void unpacker::read_file_header()
 	{
 		if (archive_size < ARCHIVE_SIZE_MIN)
 		{
-			abort("impossible archive size"); // bad input data
+			unpack_abort("impossible archive size"); // bad input data
 			return;
 		}
 		if (archive_size < header_size_1)
 		{
-			abort("too much read-ahead"); // somehow we pre-fetched too much?
+			unpack_abort("too much read-ahead"); // somehow we pre-fetched too much?
 			return;
 		}
 		input.set(U_NEW(byte, add_size(header_size_0, archive_size, C_SLOP)),
 				  (size_t)header_size_0 + archive_size);
-		CHECK;
 		assert(input.limit()[0] == 0);
 		// Move all the bytes we read initially into the real buffer.
 		input.b.copyFrom(initbuf, header_size);
@@ -736,19 +723,16 @@ void unpacker::read_file_header()
 		// It's more complicated and painful.
 		// A zero archive_size means that we must read until EOF.
 		input.init(CHUNK * 2);
-		CHECK;
 		input.b.len = input.allocated;
 		rp = rplimit = input.base();
 		// Set up input buffer as if we already read the header:
 		input.b.copyFrom(initbuf, header_size);
-		CHECK;
 		rplimit += header_size;
 		while (ensure_input(input.limit() - rp))
 		{
 			size_t dataSoFar = input_remaining();
 			size_t nextSize = add_size(dataSoFar, CHUNK);
 			input.ensureSize(nextSize);
-			CHECK;
 			input.b.len = input.allocated;
 			rp = rplimit = input.base();
 			rplimit += dataSoFar;
@@ -756,7 +740,6 @@ void unpacker::read_file_header()
 		size_t dataSize = (rplimit - input.base());
 		input.b.len = dataSize;
 		input.grow(C_SLOP);
-		CHECK;
 		free_input = true; // free it later
 		input.b.len = dataSize;
 		assert(input.limit()[0] == 0);
@@ -765,25 +748,21 @@ void unpacker::read_file_header()
 		rp += header_size_0; // already scanned these bytes...
 	}
 	live_input = true; // mark as "do not reuse"
-	if (aborting())
-	{
-		abort("cannot allocate large input buffer for package file");
-		return;
-	}
 
 	// read the rest of the header fields
 	ensure_input((AH_LENGTH - AH_LENGTH_0) * B_MAX);
-	CHECK;
 	hdr.rp = rp;
 	hdr.rplimit = rplimit;
 
 	if ((archive_options & AO_HAVE_FILE_HEADERS) != 0)
 	{
 		archive_next_count = hdr.getInt();
-		CHECK_COUNT(archive_next_count);
+		if (archive_next_count < 0)
+			unpack_abort("bad archive_next_count");
 		archive_modtime = hdr.getInt();
 		file_count = hdr.getInt();
-		CHECK_COUNT(file_count);
+		if (file_count < 0)
+			unpack_abort("bad file_count");
 		hdrVals += 3;
 	}
 	else
@@ -794,9 +773,11 @@ void unpacker::read_file_header()
 	if ((archive_options & AO_HAVE_SPECIAL_FORMATS) != 0)
 	{
 		band_headers_size = hdr.getInt();
-		CHECK_COUNT(band_headers_size);
+		if (band_headers_size < 0)
+			unpack_abort("bad band_headers_size");
 		attr_definition_count = hdr.getInt();
-		CHECK_COUNT(attr_definition_count);
+		if (attr_definition_count < 0)
+			unpack_abort("bad attr_definition_count");
 		hdrVals += 2;
 	}
 	else
@@ -821,16 +802,22 @@ void unpacker::read_file_header()
 			}
 		}
 		cp_counts[k] = hdr.getInt();
-		CHECK_COUNT(cp_counts[k]);
+		if (cp_counts[k] < 0)
+			unpack_abort("bad cp_counts");
 		hdrVals += 1;
 	}
 
 	ic_count = hdr.getInt();
-	CHECK_COUNT(ic_count);
+	if (ic_count < 0)
+		unpack_abort("bad ic_count");
+
 	default_class_minver = hdr.getInt();
 	default_class_majver = hdr.getInt();
+
 	class_count = hdr.getInt();
-	CHECK_COUNT(class_count);
+	if (class_count < 0)
+		unpack_abort("bad class_count");
+
 	hdrVals += 4;
 
 	// done with archive_header
@@ -839,11 +826,10 @@ void unpacker::read_file_header()
 
 	rp = hdr.rp;
 	if (rp > rplimit)
-		abort("EOF reading archive header");
+		unpack_abort("EOF reading archive header");
 
 	// Now size the CP.
 	cp.init(this, cp_counts);
-	CHECK;
 
 	default_file_modtime = archive_modtime;
 	if (default_file_modtime == 0 && !(archive_options & AO_HAVE_FILE_MODTIME))
@@ -856,13 +842,13 @@ void unpacker::read_file_header()
 	ensure_input(band_headers_size);
 	if (input_remaining() < (size_t)band_headers_size)
 	{
-		abort("EOF reading band headers");
+		unpack_abort("EOF reading band headers");
 		return;
 	}
 	bytes band_headers;
 	// The "1+" allows an initial byte to be pushed on the front.
 	band_headers.set(1 + U_NEW(byte, 1 + band_headers_size + C_SLOP), band_headers_size);
-	CHECK;
+
 	// Start scanning band headers here:
 	band_headers.copyFrom(rp, band_headers.len);
 	rp += band_headers.len;
@@ -891,7 +877,7 @@ void unpacker::finish()
 }
 
 // Cf. PackageReader.readConstantPoolCounts
-void cpool::init(unpacker *u_, int counts[NUM_COUNTS])
+void constant_pool::init(unpacker *u_, int counts[NUM_COUNTS])
 {
 	this->u = u_;
 
@@ -915,8 +901,7 @@ void cpool::init(unpacker *u_, int counts[NUM_COUNTS])
 		};
 		if (len >= (1 << 29) || len < 0 || next_entry >= CP_SIZE_LIMIT + IMPLICIT_ENTRY_COUNT)
 		{
-			abort("archive too large:  constant pool limit exceeded");
-			return;
+			unpack_abort("archive too large:  constant pool limit exceeded");
 		}
 	}
 
@@ -937,7 +922,6 @@ void cpool::init(unpacker *u_, int counts[NUM_COUNTS])
 	// the entries are renumbered for classfile output.
 
 	entries = U_NEW(entry, maxentries);
-	CHECK;
 
 	first_extra_entry = &entries[nentries];
 
@@ -951,8 +935,8 @@ void cpool::init(unpacker *u_, int counts[NUM_COUNTS])
 	}
 
 	// Initialize hashTab to a generous power-of-two size.
-	uint pow2 = 1;
-	uint target = maxentries + maxentries / 2; // 60% full
+	uint32_t pow2 = 1;
+	uint32_t target = maxentries + maxentries / 2; // 60% full
 	while (pow2 < target)
 		pow2 <<= 1;
 	hashTab = U_NEW(entry *, hashTabLength = pow2);
@@ -1056,7 +1040,6 @@ void unpacker::read_Utf8_values(entry *cpMap, int len)
 		cp_Utf8_suffix.readData(len - SUFFIX_SKIP_1);
 
 	bytes *allsuffixes = T_NEW(bytes, len);
-	CHECK;
 
 	int nbigsuf = 0;
 	fillbytes charbuf; // buffer to allocate small strings
@@ -1069,8 +1052,7 @@ void unpacker::read_Utf8_values(entry *cpMap, int len)
 		int suffix = (i < SUFFIX_SKIP_1) ? 0 : cp_Utf8_suffix.getInt();
 		if (suffix < 0)
 		{
-			abort("bad utf8 suffix");
-			return;
+			unpack_abort("bad utf8 suffix");
 		}
 		if (suffix == 0 && i >= SUFFIX_SKIP_1)
 		{
@@ -1079,7 +1061,7 @@ void unpacker::read_Utf8_values(entry *cpMap, int len)
 			continue;
 		}
 		bytes &chars = allsuffixes[i];
-		uint size3 = suffix * 3; // max Utf8 length
+		uint32_t size3 = suffix * 3; // max Utf8 length
 		bool isMalloc = (suffix > SMALL);
 		if (isMalloc)
 		{
@@ -1095,7 +1077,7 @@ void unpacker::read_Utf8_values(entry *cpMap, int len)
 			}
 			chars.set(charbuf.grow(size3 + 1), size3);
 		}
-		CHECK;
+
 		byte *chp = chars.ptr;
 		for (int j = 0; j < suffix; j++)
 		{
@@ -1106,7 +1088,6 @@ void unpacker::read_Utf8_values(entry *cpMap, int len)
 		if (isMalloc)
 		{
 			chars.realloc(chp - chars.ptr);
-			CHECK;
 			tmallocs.add(chars.ptr); // free it later
 		}
 		else
@@ -1131,8 +1112,7 @@ void unpacker::read_Utf8_values(entry *cpMap, int len)
 		int prefix = (i < PREFIX_SKIP_2) ? 0 : cp_Utf8_prefix.getInt();
 		if (prefix < 0 || prefix + suffix < 0)
 		{
-			abort("bad utf8 prefix");
-			return;
+			unpack_abort("bad utf8 prefix");
 		}
 		bytes &chars = allsuffixes[i];
 		if (suffix == 0 && i >= SUFFIX_SKIP_1)
@@ -1161,7 +1141,7 @@ void unpacker::read_Utf8_values(entry *cpMap, int len)
 		if (chars.ptr != nullptr)
 			continue;				// already input
 		int suffix = (int)chars.len; // pick up the hack
-		uint size3 = suffix * 3;
+		uint32_t size3 = suffix * 3;
 		if (suffix == 0)
 			continue; // done with empty string
 		chars.malloc(size3);
@@ -1174,7 +1154,6 @@ void unpacker::read_Utf8_values(entry *cpMap, int len)
 			chp = store_Utf8_char(chp, ch);
 		}
 		chars.realloc(chp - chars.ptr);
-		CHECK;
 		tmallocs.add(chars.ptr); // free it later
 		// cp_Utf8_big_chars.done();
 		cp_Utf8_big_chars = saved_band; // reset the band for the next string
@@ -1185,9 +1164,8 @@ void unpacker::read_Utf8_values(entry *cpMap, int len)
 	// Finally, sew together all the prefixes and suffixes.
 	bytes bigbuf;
 	bigbuf.malloc(maxlen * 3 + 1); // max Utf8 length, plus slop for nullptr
-	CHECK;
-	int prevlen = 0;		  // previous string length (in chars)
-	tmallocs.add(bigbuf.ptr); // free after this block
+	int prevlen = 0;			   // previous string length (in chars)
+	tmallocs.add(bigbuf.ptr);	  // free after this block
 	cp_Utf8_prefix.rewind();
 	for (i = 0; i < len; i++)
 	{
@@ -1199,7 +1177,7 @@ void unpacker::read_Utf8_values(entry *cpMap, int len)
 		// make sure the prefix value is not corrupted, though:
 		if (prefix > prevlen)
 		{
-			abort("utf8 prefix overflow");
+			unpack_abort("utf8 prefix overflow");
 			return;
 		}
 		fillp = skip_Utf8_chars(bigbuf.ptr, prefix);
@@ -1211,7 +1189,6 @@ void unpacker::read_Utf8_values(entry *cpMap, int len)
 		bytes &value = cpMap[i].value.b;
 		value.set(U_NEW(byte, add_size(length, 1)), length);
 		value.copyFrom(bigbuf.ptr, length);
-		CHECK;
 		// Index all Utf8 strings
 		entry *&htref = cp.hashTabRef(CONSTANT_Utf8, value);
 		if (htref == nullptr)
@@ -1256,14 +1233,12 @@ void unpacker::read_single_refs(band &cp_band, byte refTag, entry *cpMap, int le
 	assert(refTag == CONSTANT_Utf8);
 	cp_band.setIndexByTag(refTag);
 	cp_band.readData(len);
-	CHECK;
 	int indexTag = (cp_band.bn == e_cp_Class) ? CONSTANT_Class : 0;
 	for (int i = 0; i < len; i++)
 	{
 		entry &e = cpMap[i];
 		e.refs = U_NEW(entry *, e.nrefs = 1);
 		entry *utf = cp_band.getRef();
-		CHECK;
 		e.refs[0] = utf;
 		e.value.b = utf->value.b; // copy value of Utf8 string to self
 		if (indexTag != 0)
@@ -1290,14 +1265,12 @@ void unpacker::read_double_refs(band &cp_band, byte ref1Tag, byte ref2Tag, entry
 	cp_band2.setIndexByTag(ref2Tag);
 	cp_band1.readData(len);
 	cp_band2.readData(len);
-	CHECK;
 	for (int i = 0; i < len; i++)
 	{
 		entry &e = cpMap[i];
 		e.refs = U_NEW(entry *, e.nrefs = 2);
 		e.refs[0] = cp_band1.getRef();
 		e.refs[1] = cp_band2.getRef();
-		CHECK;
 	}
 	// cp_band1.done();
 	// cp_band2.done();
@@ -1308,14 +1281,12 @@ void unpacker::read_signature_values(entry *cpMap, int len)
 {
 	cp_Signature_form.setIndexByTag(CONSTANT_Utf8);
 	cp_Signature_form.readData(len);
-	CHECK;
 	int ncTotal = 0;
 	int i;
 	for (i = 0; i < len; i++)
 	{
 		entry &e = cpMap[i];
 		entry &form = *cp_Signature_form.getRef();
-		CHECK;
 		int nc = 0;
 
 		for (const char *ncp = form.utf8String(); *ncp; ncp++)
@@ -1326,7 +1297,6 @@ void unpacker::read_signature_values(entry *cpMap, int len)
 
 		ncTotal += nc;
 		e.refs = U_NEW(entry *, cpMap[i].nrefs = 1 + nc);
-		CHECK;
 		e.refs[0] = &form;
 	}
 	// cp_Signature_form.done();
@@ -1338,7 +1308,6 @@ void unpacker::read_signature_values(entry *cpMap, int len)
 		for (int j = 1; j < e.nrefs; j++)
 		{
 			e.refs[j] = cp_Signature_classes.getRef();
-			CHECK;
 		}
 	}
 	// cp_Signature_classes.done();
@@ -1410,19 +1379,16 @@ void unpacker::read_cp()
 			assert(false);
 			break;
 		}
-		CHECK;
 	}
 
 	cp.expandSignatures();
-	CHECK;
 	cp.initMemberIndexes();
-	CHECK;
 
 #define SNAME(n, s) #s "\0"
 	const char *symNames = (ALL_ATTR_DO(SNAME) "<init>");
 #undef SNAME
 
-	for (int sn = 0; sn < cpool::s_LIMIT; sn++)
+	for (int sn = 0; sn < constant_pool::s_LIMIT; sn++)
 	{
 		assert(symNames[0] >= '0' && symNames[0] <= 'Z'); // sanity
 		bytes name;
@@ -1469,7 +1435,6 @@ unpacker::attr_definitions::defineLayout(int idx, entry *nameEntry, const char *
 {
 	const char *name = nameEntry->value.b.strval();
 	layout_definition *lo = defineLayout(idx, name, layout);
-	CHECK_0;
 	lo->nameEntry = nameEntry;
 	return lo;
 }
@@ -1482,10 +1447,10 @@ unpacker::layout_definition *unpacker::attr_definitions::defineLayout(int idx, c
 	{
 		// Fixed attr.
 		if (idx >= (int)flag_limit)
-			abort("attribute index too large");
+			unpack_abort("attribute index too large");
 		if (isRedefined(idx))
-			abort("redefined attribute index");
-		redef |= ((julong)1 << idx);
+			unpack_abort("redefined attribute index");
+		redef |= ((uint64_t)1 << idx);
 	}
 	else
 	{
@@ -1493,7 +1458,6 @@ unpacker::layout_definition *unpacker::attr_definitions::defineLayout(int idx, c
 		overflow_count.add(0); // make a new counter
 	}
 	layout_definition *lo = U_NEW(layout_definition, 1);
-	CHECK_0;
 	lo->idx = idx;
 	lo->name = name;
 	lo->layout = layout;
@@ -1501,7 +1465,6 @@ unpacker::layout_definition *unpacker::attr_definitions::defineLayout(int idx, c
 	{
 		layouts.add(nullptr);
 	}
-	CHECK_0;
 	layouts.get(idx) = lo;
 	return lo;
 }
@@ -1522,13 +1485,11 @@ band **unpacker::attr_definitions::buildBands(unpacker::layout_definition *lo)
 		bands_made = 0x10000; // base number for bands made
 		const char *lp = lo->layout;
 		lp = parseLayout(lp, lo->elems, -1);
-		CHECK_0;
 		if (lp[0] != '\0' || band_stack.length() > 0)
 		{
-			abort("garbage at end of layout");
+			unpack_abort("garbage at end of layout");
 		}
 		band_stack.popTo(0);
-		CHECK_0;
 
 		// Fix up callables to point at their callees.
 		band **bands = lo->elems;
@@ -1540,7 +1501,7 @@ band **unpacker::attr_definitions::buildBands(unpacker::layout_definition *lo)
 			{
 				if (bands[num_callables]->le_kind != EK_CBLE)
 				{
-					abort("garbage mixed with callables");
+					unpack_abort("garbage mixed with callables");
 					break;
 				}
 				num_callables += 1;
@@ -1554,7 +1515,7 @@ band **unpacker::attr_definitions::buildBands(unpacker::layout_definition *lo)
 			int call_num = call.le_len;
 			if (call_num < 0 || call_num >= num_callables)
 			{
-				abort("bad call in layout");
+				unpack_abort("bad call in layout");
 				break;
 			}
 			band &cble = *bands[call_num];
@@ -1636,7 +1597,6 @@ const char *unpacker::attr_definitions::parseIntLayout(const char *lp, band *&re
 {
 	const char *lp0 = lp;
 	band *b = U_NEW(band, 1);
-	CHECK_(lp);
 	char le = *lp++;
 	int spec = UNSIGNED5_spec;
 	if (le == 'S' && can_be_signed)
@@ -1667,7 +1627,7 @@ const char *unpacker::attr_definitions::parseIntLayout(const char *lp, band *&re
 		le_len = 0;
 		break;
 	default:
-		abort("bad layout element");
+		unpack_abort("bad layout element");
 	}
 	b->le_len = le_len;
 	band_stack.add(b);
@@ -1704,15 +1664,13 @@ const char *unpacker::attr_definitions::parseNumeral(const char *lp, int &res)
 	}
 	if (lp == dp)
 	{
-		abort("missing numeral in layout");
-		return "";
+		unpack_abort("missing numeral in layout");
 	}
 	lp = dp;
 	if (con < 0 && !(sgn && con == -con))
 	{
 		// (Portability note:  Misses the error if int is not 32 bits.)
-		abort("numeral overflow");
-		return "";
+		unpack_abort("numeral overflow");
 	}
 	if (sgn)
 		con = -con;
@@ -1732,7 +1690,6 @@ band **unpacker::attr_definitions::popBody(int bs_base)
 	{
 		int nb = bs_limit - bs_base;
 		band **res = U_NEW(band *, add_size(nb, 1));
-		CHECK_(no_bands);
 		for (int i = 0; i < nb; i++)
 		{
 			band *b = (band *)band_stack.get(bs_base + i);
@@ -1789,12 +1746,11 @@ const char *unpacker::attr_definitions::parseLayout(const char *lp, band **&res,
 			b->le_bci = EK_BCO;
 			b->defc = coding::findBySpec(BRANCH5_spec);
 			break;
-		case 'N': // replication: 'N' uint '[' elem ... ']'
+		case 'N': // replication: 'N' uint32_t '[' elem ... ']'
 			lp = parseIntLayout(lp, b, EK_REPL);
 			assert(*lp == '[');
 			++lp;
 			lp = parseLayout(lp, b->le_body, curCble);
-			CHECK_(lp);
 			break;
 		case 'T': // union: 'T' any_int union_case* '(' ')' '[' body ']'
 			lp = parseIntLayout(lp, b, EK_UN, can_be_signed);
@@ -1803,13 +1759,12 @@ const char *unpacker::attr_definitions::parseLayout(const char *lp, band **&res,
 				for (;;)
 				{ // for each case
 					band &k_case = *U_NEW(band, 1);
-					CHECK_(lp);
 					band_stack.add(&k_case);
 					k_case.le_kind = EK_CASE;
 					k_case.bn = bands_made++;
 					if (*lp++ != '(')
 					{
-						abort("bad union case");
+						unpack_abort("bad union case");
 						return "";
 					}
 					if (*lp++ != ')')
@@ -1827,19 +1782,19 @@ const char *unpacker::attr_definitions::parseLayout(const char *lp, band **&res,
 								// new in version 160, allow (1-5) for (1,2,3,4,5)
 								if (u->majver < JAVA6_PACKAGE_MAJOR_VERSION)
 								{
-									abort("bad range in union case label (old archive format)");
+									unpack_abort(
+										"bad range in union case label (old archive format)");
 									return "";
 								}
 								int caselimit = caseval;
 								lp++;
 								lp = parseNumeral(lp, caselimit);
 								if (caseval >= caselimit ||
-									(uint)(caselimit - caseval) > 0x10000)
+									(uint32_t)(caselimit - caseval) > 0x10000)
 								{
 									// Note:  0x10000 is arbitrary implementation restriction.
 									// We can remove it later if it's important to.
-									abort("bad range in union case label");
-									return "";
+									unpack_abort("bad range in union case label");
 								}
 								for (;;)
 								{
@@ -1855,13 +1810,11 @@ const char *unpacker::attr_definitions::parseLayout(const char *lp, band **&res,
 						}
 						if (*lp++ != ')')
 						{
-							abort("bad case label");
-							return "";
+							unpack_abort("bad case label");
 						}
 						// save away the case labels
 						int ntags = band_stack.length() - case_base;
 						int *tags = U_NEW(int, add_size(ntags, 1));
-						CHECK_(lp);
 						k_case.le_casetags = tags;
 						*tags++ = ntags;
 						for (int i = 0; i < ntags; i++)
@@ -1869,13 +1822,11 @@ const char *unpacker::attr_definitions::parseLayout(const char *lp, band **&res,
 							*tags++ = ptrlowbits(band_stack.get(case_base + i));
 						}
 						band_stack.popTo(case_base);
-						CHECK_(lp);
 					}
 					// Got le_casetags.  Now grab the body.
 					assert(*lp == '[');
 					++lp;
 					lp = parseLayout(lp, k_case.le_body, curCble);
-					CHECK_(lp);
 					if (k_case.le_casetags == nullptr)
 						break; // done
 				}
@@ -1885,7 +1836,6 @@ const char *unpacker::attr_definitions::parseLayout(const char *lp, band **&res,
 		case '(': // call: '(' -?NN* ')'
 		{
 			band &call = *U_NEW(band, 1);
-			CHECK_(lp);
 			band_stack.add(&call);
 			call.le_kind = EK_CALL;
 			call.bn = bands_made++;
@@ -1896,11 +1846,9 @@ const char *unpacker::attr_definitions::parseLayout(const char *lp, band **&res,
 			call_num += curCble;	// numeral is self-relative offset
 			call.le_len = call_num; // use le_len as scratch
 			calls_to_link.add(&call);
-			CHECK_(lp);
 			if (*lp++ != ')')
 			{
-				abort("bad call label");
-				return "";
+				unpack_abort("bad call label");
 			}
 		}
 		break;
@@ -1964,7 +1912,7 @@ const char *unpacker::attr_definitions::parseLayout(const char *lp, band **&res,
 			}
 			if (ixTag == CONSTANT_None)
 			{
-				abort("bad reference layout");
+				unpack_abort("bad reference layout");
 				break;
 			}
 			bool nullOK = false;
@@ -1983,12 +1931,11 @@ const char *unpacker::attr_definitions::parseLayout(const char *lp, band **&res,
 			// [callable1][callable2]...
 			if (!top_level)
 			{
-				abort("bad nested callable");
+				unpack_abort("bad nested callable");
 				break;
 			}
 			curCble += 1;
 			band &cble = *U_NEW(band, 1);
-			CHECK_(lp);
 			band_stack.add(&cble);
 			cble.le_kind = EK_CBLE;
 			cble.bn = bands_made++;
@@ -2005,10 +1952,8 @@ const char *unpacker::attr_definitions::parseLayout(const char *lp, band **&res,
 			done = true;
 			break;
 		default:
-			abort("bad layout");
-			break;
+			unpack_abort("bad layout");
 		}
-		CHECK_(lp);
 	}
 
 	// Return the accumulated bands:
@@ -2095,10 +2040,8 @@ void unpacker::read_attr_defs()
 	attr_definition_name.readData(attr_definition_count);
 	attr_definition_layout.readData(attr_definition_count);
 
-	CHECK;
-
 // Initialize correct predef bits, to distinguish predefs from new defs.
-#define ORBIT(n, s) | ((julong)1 << n)
+#define ORBIT(n, s) | ((uint64_t)1 << n)
 	attr_defs[ATTR_CONTEXT_CLASS].predef = (0 X_ATTR_DO(ORBIT) CLASS_ATTR_DO(ORBIT));
 	attr_defs[ATTR_CONTEXT_FIELD].predef = (0 X_ATTR_DO(ORBIT) FIELD_ATTR_DO(ORBIT));
 	attr_defs[ATTR_CONTEXT_METHOD].predef = (0 X_ATTR_DO(ORBIT) METHOD_ATTR_DO(ORBIT));
@@ -2120,7 +2063,6 @@ void unpacker::read_attr_defs()
 		int idx = ADH_BYTE_INDEX(header);
 		entry *name = attr_definition_name.getRef();
 		entry *layout = attr_definition_layout.getRef();
-		CHECK;
 		attr_defs[attrc].defineLayout(idx, name, layout->value.b.strval());
 	}
 }
@@ -2160,7 +2102,7 @@ static int lastIndexOf(int chmin, int chmax, bytes &x, int pos)
 	return -1;
 }
 
-inner_class *cpool::getIC(entry *inner)
+inner_class *constant_pool::getIC(entry *inner)
 {
 	if (inner == nullptr)
 		return nullptr;
@@ -2172,7 +2114,7 @@ inner_class *cpool::getIC(entry *inner)
 	return ic;
 }
 
-inner_class *cpool::getFirstChildIC(entry *outer)
+inner_class *constant_pool::getFirstChildIC(entry *outer)
 {
 	if (outer == nullptr)
 		return nullptr;
@@ -2184,7 +2126,7 @@ inner_class *cpool::getFirstChildIC(entry *outer)
 	return ic;
 }
 
-inner_class *cpool::getNextChildIC(inner_class *child)
+inner_class *constant_pool::getNextChildIC(inner_class *child)
 {
 	inner_class *ic = child->next_sibling;
 	assert(ic == nullptr || ic->outer == child->outer);
@@ -2202,7 +2144,6 @@ void unpacker::read_ics()
 	ics = U_NEW(inner_class, ic_count);
 	ic_this_class.readData(ic_count);
 	ic_flags.readData(ic_count);
-	CHECK;
 	// Scan flags to get count of long-form bands.
 	int long_forms = 0;
 	for (i = 0; i < ic_count; i++)
@@ -2215,12 +2156,11 @@ void unpacker::read_ics()
 		}
 		flags &= ~ACC_IC_LONG_FORM;
 		entry *inner = ic_this_class.getRef();
-		CHECK;
-		uint inord = inner->inord;
-		assert(inord < (uint)cp.tag_count[CONSTANT_Class]);
+		uint32_t inord = inner->inord;
+		assert(inord < (uint32_t)cp.tag_count[CONSTANT_Class]);
 		if (ic_index[inord] != nullptr)
 		{
-			abort("identical inner class");
+			unpack_abort("identical inner class");
 			break;
 		}
 		ic_index[inord] = &ics[i];
@@ -2228,7 +2168,6 @@ void unpacker::read_ics()
 		ics[i].flags = flags;
 		assert(cp.getIC(inner) == &ics[i]);
 	}
-	CHECK;
 	// ic_this_class.done();
 	// ic_flags.done();
 	ic_outer_class.readData(long_forms);
@@ -2256,8 +2195,7 @@ void unpacker::read_ics()
 			dollar2 = lastIndexOf(DOLLAR_MIN, DOLLAR_MAX, n, nlen);
 			if (dollar2 < 0)
 			{
-				abort();
-				return;
+				unpack_abort();
 			}
 			assert(dollar2 >= pkglen);
 			if (isDigitString(n, dollar2 + 1, nlen))
@@ -2296,10 +2234,10 @@ void unpacker::read_ics()
 		// update child/sibling list
 		if (ics[i].outer != nullptr)
 		{
-			uint outord = ics[i].outer->inord;
+			uint32_t outord = ics[i].outer->inord;
 			if (outord != NO_INORD)
 			{
-				assert(outord < (uint)cp.tag_count[CONSTANT_Class]);
+				assert(outord < (uint32_t)cp.tag_count[CONSTANT_Class]);
 				ics[i].next_sibling = ic_child_index[outord];
 				ic_child_index[outord] = &ics[i];
 			}
@@ -2316,8 +2254,6 @@ void unpacker::read_classes()
 	class_interface_count.readData(class_count);
 	class_interface.readData(class_interface_count.getIntTotal());
 
-	CHECK;
-
 #if 0
   int i;
   // Make a little mark on super-classes.
@@ -2332,27 +2268,18 @@ void unpacker::read_classes()
 	class_field_count.readData(class_count);
 	class_method_count.readData(class_count);
 
-	CHECK;
-
 	int field_count = class_field_count.getIntTotal();
 	int method_count = class_method_count.getIntTotal();
 
 	field_descr.readData(field_count);
 	read_attrs(ATTR_CONTEXT_FIELD, field_count);
-	CHECK;
-
 	method_descr.readData(method_count);
 	read_attrs(ATTR_CONTEXT_METHOD, method_count);
-
-	CHECK;
-
 	read_attrs(ATTR_CONTEXT_CLASS, class_count);
-	CHECK;
-
 	read_code_headers();
 }
 
-int unpacker::attr_definitions::predefCount(uint idx)
+int unpacker::attr_definitions::predefCount(uint32_t idx)
 {
 	return isPredefined(idx) ? flag_count[idx] : 0;
 }
@@ -2364,27 +2291,23 @@ void unpacker::read_attrs(int attrc, int obj_count)
 
 	int i, idx, count;
 
-	CHECK;
-
 	bool haveLongFlags = ad.haveLongFlags();
 
 	band &xxx_flags_hi = ad.xxx_flags_hi();
 	if (haveLongFlags)
 		xxx_flags_hi.readData(obj_count);
-	CHECK;
 
 	band &xxx_flags_lo = ad.xxx_flags_lo();
 	xxx_flags_lo.readData(obj_count);
-	CHECK;
 
 	// pre-scan flags, counting occurrences of each index bit
-	julong indexMask = ad.flagIndexMask(); // which flag bits are index bits?
+	uint64_t indexMask = ad.flagIndexMask(); // which flag bits are index bits?
 	for (i = 0; i < obj_count; i++)
 	{
-		julong indexBits = xxx_flags_hi.getLong(xxx_flags_lo, haveLongFlags);
+		uint64_t indexBits = xxx_flags_hi.getLong(xxx_flags_lo, haveLongFlags);
 		if ((indexBits & ~indexMask) > (ushort) - 1)
 		{
-			abort("undefined attribute flag bit");
+			unpack_abort("undefined attribute flag bit");
 			return;
 		}
 		indexBits &= indexMask; // ignore classfile flag bits
@@ -2400,19 +2323,17 @@ void unpacker::read_attrs(int attrc, int obj_count)
 	band &xxx_attr_count = ad.xxx_attr_count();
 	// There is one count element for each 1<<16 bit set in flags:
 	xxx_attr_count.readData(ad.predefCount(X_ATTR_OVERFLOW));
-	CHECK;
 
 	band &xxx_attr_indexes = ad.xxx_attr_indexes();
 	int overflowIndexCount = xxx_attr_count.getIntTotal();
 	xxx_attr_indexes.readData(overflowIndexCount);
-	CHECK;
 	// pre-scan attr indexes, counting occurrences of each value
 	for (i = 0; i < overflowIndexCount; i++)
 	{
 		idx = xxx_attr_indexes.getInt();
 		if (!ad.isIndex(idx))
 		{
-			abort("attribute index out of bounds");
+			unpack_abort("attribute index out of bounds");
 			return;
 		}
 		ad.getCount(idx) += 1;
@@ -2428,7 +2349,6 @@ void unpacker::read_attrs(int attrc, int obj_count)
 		{
 			// Build the bands lazily, only when they are used.
 			band **bands = ad.buildBands(lo);
-			CHECK;
 			if (lo->hasCallables())
 			{
 				for (i = 0; bands[i] != nullptr; i++)
@@ -2443,7 +2363,6 @@ void unpacker::read_attrs(int attrc, int obj_count)
 		}
 	}
 	ad.xxx_attr_calls().readData(backwardCounts);
-	CHECK;
 
 	// Read built-in bands.
 	// Mostly, these are hand-coded equivalents to readBandData().
@@ -2453,53 +2372,44 @@ void unpacker::read_attrs(int attrc, int obj_count)
 
 		count = ad.predefCount(CLASS_ATTR_SourceFile);
 		class_SourceFile_RUN.readData(count);
-		CHECK;
 
 		count = ad.predefCount(CLASS_ATTR_EnclosingMethod);
 		class_EnclosingMethod_RC.readData(count);
 		class_EnclosingMethod_RDN.readData(count);
-		CHECK;
 
 		count = ad.predefCount(X_ATTR_Signature);
 		class_Signature_RS.readData(count);
-		CHECK;
 
 		ad.readBandData(X_ATTR_RuntimeVisibleAnnotations);
 		ad.readBandData(X_ATTR_RuntimeInvisibleAnnotations);
 
 		count = ad.predefCount(CLASS_ATTR_InnerClasses);
 		class_InnerClasses_N.readData(count);
-		CHECK;
 
 		count = class_InnerClasses_N.getIntTotal();
 		class_InnerClasses_RC.readData(count);
 		class_InnerClasses_F.readData(count);
-		CHECK;
+
 		// Drop remaining columns wherever flags are zero:
 		count -= class_InnerClasses_F.getIntCount(0);
 		class_InnerClasses_outer_RCN.readData(count);
 		class_InnerClasses_name_RUN.readData(count);
-		CHECK;
 
 		count = ad.predefCount(CLASS_ATTR_ClassFile_version);
 		class_ClassFile_version_minor_H.readData(count);
 		class_ClassFile_version_major_H.readData(count);
-		CHECK;
 		break;
 
 	case ATTR_CONTEXT_FIELD:
 
 		count = ad.predefCount(FIELD_ATTR_ConstantValue);
 		field_ConstantValue_KQ.readData(count);
-		CHECK;
 
 		count = ad.predefCount(X_ATTR_Signature);
 		field_Signature_RS.readData(count);
-		CHECK;
 
 		ad.readBandData(X_ATTR_RuntimeVisibleAnnotations);
 		ad.readBandData(X_ATTR_RuntimeInvisibleAnnotations);
-		CHECK;
 		break;
 
 	case ATTR_CONTEXT_METHOD:
@@ -2511,18 +2421,15 @@ void unpacker::read_attrs(int attrc, int obj_count)
 		method_Exceptions_N.readData(count);
 		count = method_Exceptions_N.getIntTotal();
 		method_Exceptions_RC.readData(count);
-		CHECK;
 
 		count = ad.predefCount(X_ATTR_Signature);
 		method_Signature_RS.readData(count);
-		CHECK;
 
 		ad.readBandData(X_ATTR_RuntimeVisibleAnnotations);
 		ad.readBandData(X_ATTR_RuntimeInvisibleAnnotations);
 		ad.readBandData(METHOD_ATTR_RuntimeVisibleParameterAnnotations);
 		ad.readBandData(METHOD_ATTR_RuntimeInvisibleParameterAnnotations);
 		ad.readBandData(METHOD_ATTR_AnnotationDefault);
-		CHECK;
 		break;
 
 	case ATTR_CONTEXT_CODE:
@@ -2531,14 +2438,12 @@ void unpacker::read_attrs(int attrc, int obj_count)
 		// disable this feature in old archives!
 		if (count != 0 && majver < JAVA6_PACKAGE_MAJOR_VERSION)
 		{
-			abort("undefined StackMapTable attribute (old archive format)");
+			unpack_abort("undefined StackMapTable attribute (old archive format)");
 			return;
 		}
 		code_StackMapTable_N.readData(count);
-		CHECK;
 		count = code_StackMapTable_N.getIntTotal();
 		code_StackMapTable_frame_T.readData(count);
-		CHECK;
 		// the rest of it depends in a complicated way on frame tags
 		{
 			int fat_frame_count = 0;
@@ -2583,23 +2488,18 @@ void unpacker::read_attrs(int attrc, int obj_count)
 			// deal completely with fat frames:
 			offset_count += fat_frame_count;
 			code_StackMapTable_local_N.readData(fat_frame_count);
-			CHECK;
 			type_count += code_StackMapTable_local_N.getIntTotal();
 			code_StackMapTable_stack_N.readData(fat_frame_count);
 			type_count += code_StackMapTable_stack_N.getIntTotal();
-			CHECK;
 			// read the rest:
 			code_StackMapTable_offset.readData(offset_count);
 			code_StackMapTable_T.readData(type_count);
-			CHECK;
 			// (7) [RCH]
 			count = code_StackMapTable_T.getIntCount(7);
 			code_StackMapTable_RC.readData(count);
-			CHECK;
 			// (8) [PH]
 			count = code_StackMapTable_T.getIntCount(8);
 			code_StackMapTable_P.readData(count);
-			CHECK;
 		}
 
 		count = ad.predefCount(CODE_ATTR_LineNumberTable);
@@ -2644,7 +2544,7 @@ void unpacker::read_attrs(int attrc, int obj_count)
 void unpacker::attr_definitions::readBandData(int idx)
 {
 	int j;
-	uint count = getCount(idx);
+	uint32_t count = getCount(idx);
 	if (count == 0)
 		return;
 	layout_definition *lo = getLayout(idx);
@@ -2674,12 +2574,12 @@ void unpacker::attr_definitions::readBandData(int idx)
 			}
 		}
 		// Now consult whichever callables have non-zero entry counts.
-		readBandData(bands, (uint) - 1);
+		readBandData(bands, (uint32_t) - 1);
 	}
 }
 
 // Recursive helper to the previous function:
-void unpacker::attr_definitions::readBandData(band **body, uint count)
+void unpacker::attr_definitions::readBandData(band **body, uint32_t count)
 {
 	int j, k;
 	for (j = 0; body[j] != nullptr; j++)
@@ -2778,7 +2678,7 @@ void unpacker::putlayout(band **body)
 	int prevBCI = -1;
 	if (body == NULL)
 	{
-		abort("putlayout: unexpected NULL for body");
+		unpack_abort("putlayout: unexpected NULL for body");
 		return;
 	}
 	for (i = 0; body[i] != nullptr; i++)
@@ -2959,7 +2859,6 @@ void unpacker::get_code_header(int &max_stack, int &max_na_locals, int &handler_
 void unpacker::read_code_headers()
 {
 	code_headers.readData(code_count);
-	CHECK;
 	int totalHandlerCount = 0;
 	int totalFlagsCount = 0;
 	for (int i = 0; i < code_count; i++)
@@ -2983,7 +2882,6 @@ void unpacker::read_code_headers()
 	code_max_na_locals.readData();
 	code_handler_count.readData();
 	totalHandlerCount += code_handler_count.getIntTotal();
-	CHECK;
 
 	// Read handler specifications.
 	// Cf. PackageReader.readCodeHandlers.
@@ -2991,13 +2889,11 @@ void unpacker::read_code_headers()
 	code_handler_end_PO.readData(totalHandlerCount);
 	code_handler_catch_PO.readData(totalHandlerCount);
 	code_handler_class_RCN.readData(totalHandlerCount);
-	CHECK;
 
 	read_attrs(ATTR_CONTEXT_CODE, totalFlagsCount);
-	CHECK;
 }
 
-static inline bool is_in_range(uint n, uint min, uint max)
+static inline bool is_in_range(uint32_t n, uint32_t min, uint32_t max)
 {
 	return n - min <= max - min; // unsigned arithmetic!
 }
@@ -3095,7 +2991,6 @@ unpacker::read_bcs()
 	// read from bc_codes and bc_case_count
 	fillbytes all_switch_ops;
 	all_switch_ops.init();
-	CHECK;
 
 	// Read directly from rp/rplimit.
 	// Do this later:  bc_codes.readData(...)
@@ -3121,8 +3016,7 @@ unpacker::read_bcs()
 			}
 			if (opptr == oplimit)
 			{
-				abort();
-				break;
+				unpack_abort();
 			}
 			int bc = *opptr++ & 0xFF;
 			bool isWide = false;
@@ -3130,8 +3024,7 @@ unpacker::read_bcs()
 			{
 				if (opptr == oplimit)
 				{
-					abort();
-					break;
+					unpack_abort();
 				}
 				bc = *opptr++ & 0xFF;
 				isWide = true;
@@ -3208,8 +3101,6 @@ unpacker::read_bcs()
 	doneScanningMethod:
 	{
 	}
-		if (aborting())
-			break;
 	}
 
 	// Go through the formality, so we can use it in a regular fashion later:
@@ -3245,7 +3136,6 @@ void unpacker::read_bands()
 	byte *rp0 = rp;
 
 	read_file_header();
-	CHECK;
 
 	if (cp.nentries == 0)
 	{
@@ -3257,32 +3147,27 @@ void unpacker::read_bands()
 	check_options();
 
 	read_cp();
-	CHECK;
 	read_attr_defs();
-	CHECK;
 	read_ics();
-	CHECK;
 	read_classes();
-	CHECK;
 	read_bcs();
-	CHECK;
 	read_files();
 }
 
 /// CP routines
 
-entry *&cpool::hashTabRef(byte tag, bytes &b)
+entry *&constant_pool::hashTabRef(byte tag, bytes &b)
 {
-	uint hash = tag + (int)b.len;
+	uint32_t hash = tag + (int)b.len;
 	for (int i = 0; i < (int)b.len; i++)
 	{
 		hash = hash * 31 + (0xFF & b.ptr[i]);
 	}
 	entry **ht = hashTab;
 	int hlen = hashTabLength;
-	assert((hlen & (hlen - 1)) == 0); // must be power of 2
-	uint hash1 = hash & (hlen - 1);   // == hash % hlen
-	uint hash2 = 0;				   // lazily computed (requires mod op.)
+	assert((hlen & (hlen - 1)) == 0);   // must be power of 2
+	uint32_t hash1 = hash & (hlen - 1); // == hash % hlen
+	uint32_t hash2 = 0;				 // lazily computed (requires mod op.)
 	int probes = 0;
 	while (ht[hash1] != nullptr)
 	{
@@ -3293,9 +3178,9 @@ entry *&cpool::hashTabRef(byte tag, bytes &b)
 			// Note:  hash2 must be relatively prime to hlen, hence the "|1".
 			hash2 = (((hash % 499) & (hlen - 1)) | 1);
 		hash1 += hash2;
-		if (hash1 >= (uint)hlen)
+		if (hash1 >= (uint32_t)hlen)
 			hash1 -= hlen;
-		assert(hash1 < (uint)hlen);
+		assert(hash1 < (uint32_t)hlen);
 		assert(++probes < hlen);
 	}
 	return ht[hash1];
@@ -3310,7 +3195,7 @@ static void insert_extra(entry *e, ptrlist &extras)
 	// Note:  We will sort the list (by string-name) later.
 }
 
-entry *cpool::ensureUtf8(bytes &b)
+entry *constant_pool::ensureUtf8(bytes &b)
 {
 	entry *&ix = hashTabRef(CONSTANT_Utf8, b);
 	if (ix != nullptr)
@@ -3318,7 +3203,7 @@ entry *cpool::ensureUtf8(bytes &b)
 	// Make one.
 	if (nentries == maxentries)
 	{
-		abort("cp utf8 overflow");
+		unpack_abort("cp utf8 overflow");
 		return &entries[tag_base[CONSTANT_Utf8]]; // return something
 	}
 	entry &e = entries[nentries++];
@@ -3329,7 +3214,7 @@ entry *cpool::ensureUtf8(bytes &b)
 	return ix = &e;
 }
 
-entry *cpool::ensureClass(bytes &b)
+entry *constant_pool::ensureClass(bytes &b)
 {
 	entry *&ix = hashTabRef(CONSTANT_Class, b);
 	if (ix != nullptr)
@@ -3337,7 +3222,7 @@ entry *cpool::ensureClass(bytes &b)
 	// Make one.
 	if (nentries == maxentries)
 	{
-		abort("cp class overflow");
+		unpack_abort("cp class overflow");
 		return &entries[tag_base[CONSTANT_Class]]; // return something
 	}
 	entry &e = entries[nentries++];
@@ -3353,7 +3238,7 @@ entry *cpool::ensureClass(bytes &b)
 	return &e;
 }
 
-void cpool::expandSignatures()
+void constant_pool::expandSignatures()
 {
 	int i;
 	int nsigs = 0;
@@ -3362,7 +3247,6 @@ void cpool::expandSignatures()
 	int sig_limit = tag_count[CONSTANT_Signature] + first_sig;
 	fillbytes buf;
 	buf.init(1 << 10);
-	CHECK;
 	for (i = first_sig; i < sig_limit; i++)
 	{
 		entry &e = entries[i];
@@ -3418,7 +3302,7 @@ void cpool::expandSignatures()
 	}
 }
 
-void cpool::initMemberIndexes()
+void constant_pool::initMemberIndexes()
 {
 	// This function does NOT refer to any class schema.
 	// It is totally internal to the cpool.
@@ -3489,7 +3373,7 @@ void cpool::initMemberIndexes()
 	u->free_temps();
 }
 
-void entry::requestOutputIndex(cpool &cp, int req)
+void entry::requestOutputIndex(constant_pool &cp, int req)
 {
 	assert(outputIndex <= NOT_REQUESTED); // must not have assigned indexes yet
 	if (tag == CONSTANT_Signature)
@@ -3514,7 +3398,7 @@ void entry::requestOutputIndex(cpool &cp, int req)
 	}
 }
 
-void cpool::resetOutputIndexes()
+void constant_pool::resetOutputIndexes()
 {
 	int i;
 	int noes = outputEntries.length();
@@ -3571,7 +3455,7 @@ extern "C" int outputEntry_cmp(const void *e1p, const void *e2p)
 	return compare_Utf8_chars(e1.value.b, e2.value.b);
 }
 
-void cpool::computeOutputIndexes()
+void constant_pool::computeOutputIndexes()
 {
 	int i;
 
@@ -3596,114 +3480,9 @@ void cpool::computeOutputIndexes()
 }
 
 // Unpacker Start
-
-const char str_tf[] = "true\0false";
-#undef STR_TRUE
-#undef STR_FALSE
-#define STR_TRUE (&str_tf[0])
-#define STR_FALSE (&str_tf[5])
-
-const char *unpacker::get_option(const char *prop)
-{
-	if (prop == nullptr)
-		return nullptr;
-	if (strcmp(prop, UNPACK_DEFLATE_HINT) == 0)
-	{
-		return deflate_hint_or_zero == 0 ? nullptr : STR_TF(deflate_hint_or_zero > 0);
-#ifdef HAVE_STRIP
-	}
-	else if (strcmp(prop, UNPACK_STRIP_COMPILE) == 0)
-	{
-		return STR_TF(strip_compile);
-	}
-	else if (strcmp(prop, UNPACK_STRIP_DEBUG) == 0)
-	{
-		return STR_TF(strip_debug);
-	}
-	else if (strcmp(prop, UNPACK_STRIP_JCOV) == 0)
-	{
-		return STR_TF(strip_jcov);
-#endif /*HAVE_STRIP*/
-	}
-	else if (strcmp(prop, UNPACK_REMOVE_PACKFILE) == 0)
-	{
-		return STR_TF(remove_packfile);
-	}
-	else if (strcmp(prop, DEBUG_VERBOSE) == 0)
-	{
-		return saveIntStr(verbose);
-	}
-	else if (strcmp(prop, UNPACK_MODIFICATION_TIME) == 0)
-	{
-		return (modification_time_or_zero == 0) ? nullptr
-												: saveIntStr(modification_time_or_zero);
-	}
-	else
-	{
-		return NULL; // unknown option ignore
-	}
-}
-
-bool unpacker::set_option(const char *prop, const char *value)
-{
-	if (prop == NULL)
-		return false;
-	if (strcmp(prop, UNPACK_DEFLATE_HINT) == 0)
-	{
-		deflate_hint_or_zero =
-			((value == nullptr || strcmp(value, "keep") == 0) ? 0 : BOOL_TF(value) ? +1 : -1);
-#ifdef HAVE_STRIP
-	}
-	else if (strcmp(prop, UNPACK_STRIP_COMPILE) == 0)
-	{
-		strip_compile = STR_TF(value);
-	}
-	else if (strcmp(prop, UNPACK_STRIP_DEBUG) == 0)
-	{
-		strip_debug = STR_TF(value);
-	}
-	else if (strcmp(prop, UNPACK_STRIP_JCOV) == 0)
-	{
-		strip_jcov = STR_TF(value);
-#endif /*HAVE_STRIP*/
-	}
-	else if (strcmp(prop, UNPACK_REMOVE_PACKFILE) == 0)
-	{
-		remove_packfile = STR_TF(value);
-	}
-	else if (strcmp(prop, DEBUG_VERBOSE) == 0)
-	{
-		verbose = (value == nullptr) ? 0 : atoi(value);
-	}
-	else if (strcmp(prop, UNPACK_MODIFICATION_TIME) == 0)
-	{
-		if (value == nullptr || (strcmp(value, "keep") == 0))
-		{
-			modification_time_or_zero = 0;
-		}
-		else if (strcmp(value, "now") == 0)
-		{
-			time_t now;
-			time(&now);
-			modification_time_or_zero = (int)now;
-		}
-		else
-		{
-			modification_time_or_zero = atoi(value);
-			if (modification_time_or_zero == 0)
-				modification_time_or_zero = 1; // make non-zero
-		}
-	}
-	else
-	{
-		return false; // unknown option ignore
-	}
-	return true;
-}
-
 // Deallocate all internal storage and reset to a clean state.
 // Do not disturb any input or output connections, including
-// infileptr, infileno, inbytes, read_input_fn, jarout, or errstrm.
+// infileptr, inbytes, read_input_fn, jarout, or errstrm.
 // Do not reset any unpack options.
 void unpacker::reset()
 {
@@ -3737,26 +3516,19 @@ void unpacker::reset()
 	this->free();
 	this->init(read_input_fn);
 
-// restore selected interface state:
-#define SAVE(x) this->x = save_u.x
-	SAVE(infileptr); // buffered
-	SAVE(infileno);  // unbuffered
-	SAVE(inbytes);   // direct
-	SAVE(jarout);
-	SAVE(gzin);
-	SAVE(verbose); // verbose level, 0 means no output
-	SAVE(strip_compile);
-	SAVE(strip_debug);
-	SAVE(strip_jcov);
-	SAVE(remove_packfile);
-	SAVE(deflate_hint_or_zero); // ==0 means not set, otherwise -1 or 1
-	SAVE(modification_time_or_zero);
-	SAVE(bytes_read_before_reset);
-	SAVE(bytes_written_before_reset);
-	SAVE(files_written_before_reset);
-	SAVE(classes_written_before_reset);
-	SAVE(segments_read_before_reset);
-#undef SAVE
+	// restore selected interface state:
+	infileptr = save_u.infileptr;
+	inbytes = save_u.inbytes;
+	jarout = save_u.jarout;
+	gzin = save_u.gzin;
+	verbose = save_u.verbose;
+	deflate_hint_or_zero = save_u.deflate_hint_or_zero;
+	modification_time_or_zero = save_u.modification_time_or_zero;
+	bytes_read_before_reset = save_u.bytes_read_before_reset;
+	bytes_written_before_reset = save_u.bytes_written_before_reset;
+	files_written_before_reset = save_u.files_written_before_reset;
+	classes_written_before_reset = save_u.classes_written_before_reset;
+	segments_read_before_reset = save_u.segments_read_before_reset;
 	// Note:  If we use strip_names, watch out:  They get nuked here.
 }
 
@@ -3774,32 +3546,6 @@ void unpacker::init(read_input_fn_t input_fn)
 		attr_defs[i].u = u; // set up outer ptr
 }
 
-const char *unpacker::get_abort_message()
-{
-	return abort_message;
-}
-
-void unpacker::dump_options()
-{
-	static const char *opts[] = {
-		UNPACK_DEFLATE_HINT,
-#ifdef HAVE_STRIP
-		UNPACK_STRIP_COMPILE,   UNPACK_STRIP_DEBUG, UNPACK_STRIP_JCOV,
-#endif /*HAVE_STRIP*/
-		UNPACK_REMOVE_PACKFILE, DEBUG_VERBOSE,	  UNPACK_MODIFICATION_TIME, nullptr};
-	for (int i = 0; opts[i] != nullptr; i++)
-	{
-		const char *str = get_option(opts[i]);
-		if (str == nullptr)
-		{
-			if (verbose == 0)
-				continue;
-			str = "(not set)";
-		}
-		fprintf(stderr, "%s=%s\n", opts[i], str);
-	}
-}
-
 // Usage: unpack a byte buffer
 // packptr is a reference to byte buffer containing a
 // packed file and len is the length of the buffer.
@@ -3833,7 +3579,6 @@ void unpacker::check_options()
 		// Turn off per-file modtime by force.
 		archive_options &= ~AO_HAVE_FILE_MODTIME;
 	}
-	// %%% strip_compile, etc...
 }
 
 // classfile writing
@@ -3854,7 +3599,7 @@ void unpacker::reset_cur_classfile()
 	requested_ics.empty();
 }
 
-cpindex *cpool::getKQIndex()
+cpindex *constant_pool::getKQIndex()
 {
 	char ch = '?';
 	if (u->cur_descr != nullptr)
@@ -3887,21 +3632,21 @@ cpindex *cpool::getKQIndex()
 		tag = CONSTANT_Integer;
 		break;
 	default:
-		abort("bad KQ reference");
+		unpack_abort("bad KQ reference");
 		break;
 	}
 	return getIndex(tag);
 }
 
-uint unpacker::to_bci(uint bii)
+uint32_t unpacker::to_bci(uint32_t bii)
 {
-	uint len = bcimap.length();
-	uint *map = (uint *)bcimap.base();
+	uint32_t len = bcimap.length();
+	uint32_t *map = (uint32_t *)bcimap.base();
 	assert(len > 0); // must be initialized before using to_bci
 	if (bii < len)
 		return map[bii];
 	// Else it's a fractional or out-of-range BCI.
-	uint key = bii - len;
+	uint32_t key = bii - len;
 	for (int i = len;; i--)
 	{
 		if (map[i - 1] - (i - 1) <= key)
@@ -4060,7 +3805,6 @@ unpacker::write_bc_ops()
 			--wp; // not really part of the code
 			int size = bc_escrefsize.getInt();
 			entry *ref = bc_escref.getRefN();
-			CHECK;
 			switch (size)
 			{
 			case 1:
@@ -4114,7 +3858,7 @@ unpacker::write_bc_ops()
 					if (ref == nullptr)
 						break; // oops, bad input
 					assert(ref->tag == CONSTANT_Methodref);
-					if (ref->memberDescr()->descrName() == cp.sym[cpool::s_lt_init_gt])
+					if (ref->memberDescr()->descrName() == cp.sym[constant_pool::s_lt_init_gt])
 					{
 						if (which_init++ == coding)
 							break;
@@ -4139,7 +3883,6 @@ unpacker::write_bc_ops()
 					putu1_fast(origBC);
 				}
 				entry *ref = bc_which->getRef();
-				CHECK;
 				putref(ref);
 				continue;
 			}
@@ -4162,7 +3905,6 @@ unpacker::write_bc_ops()
 			if (bc_which != nullptr)
 			{
 				entry *ref = bc_which->getRefCommon(bc_which->ix, bc_which->nullOK);
-				CHECK;
 				if (ref == nullptr && bc_which == &bc_classref)
 				{
 					// Shorthand for class self-references.
@@ -4285,7 +4027,6 @@ unpacker::write_code()
 		handler_count = code_handler_count.getInt();
 
 	int siglen = cur_descr->descrType()->typeSize();
-	CHECK;
 	if ((cur_descr_flags & ACC_STATIC) == 0)
 		siglen++;
 	max_locals += siglen;
@@ -4296,7 +4037,6 @@ unpacker::write_code()
 
 	// Write the bytecodes themselves.
 	write_bc_ops();
-	CHECK;
 
 	byte *bcbasewp = wp_at(bcbase);
 	putu4_at(bcbasewp, (int)(wp - (bcbasewp + 4))); // size of code attr
@@ -4311,10 +4051,9 @@ unpacker::write_code()
 		bii += code_handler_catch_PO.getInt();
 		putu2(to_bci(bii));
 		putref(code_handler_class_RCN.getRefN());
-		CHECK;
 	}
 
-	julong indexBits = cflags;
+	uint64_t indexBits = cflags;
 	if (cflags < 0)
 	{
 		bool haveLongFlags = attr_defs[ATTR_CONTEXT_CODE].haveLongFlags();
@@ -4323,9 +4062,8 @@ unpacker::write_code()
 	write_attrs(ATTR_CONTEXT_CODE, indexBits);
 }
 
-int unpacker::write_attrs(int attrc, julong indexBits)
+int unpacker::write_attrs(int attrc, uint64_t indexBits)
 {
-	CHECK_0;
 	if (indexBits == 0)
 	{
 		// Quick short-circuit.
@@ -4338,9 +4076,9 @@ int unpacker::write_attrs(int attrc, julong indexBits)
 	int i, j, j2, idx, count;
 
 	int oiCount = 0;
-	if (ad.isPredefined(X_ATTR_OVERFLOW) && (indexBits & ((julong)1 << X_ATTR_OVERFLOW)) != 0)
+	if (ad.isPredefined(X_ATTR_OVERFLOW) && (indexBits & ((uint64_t)1 << X_ATTR_OVERFLOW)) != 0)
 	{
-		indexBits -= ((julong)1 << X_ATTR_OVERFLOW);
+		indexBits -= ((uint64_t)1 << X_ATTR_OVERFLOW);
 		oiCount = ad.xxx_attr_count().getInt();
 	}
 
@@ -4371,7 +4109,6 @@ int unpacker::write_attrs(int attrc, julong indexBits)
 		entry *aname = nullptr;
 		entry *ref; // scratch
 		size_t abase = put_empty(2 + 4);
-		CHECK_0;
 		if (idx < (int)ad.flag_limit && ad.isPredefined(idx))
 		{
 			// Switch on the attrc and idx simultaneously.
@@ -4396,15 +4133,14 @@ int unpacker::write_attrs(int attrc, julong indexBits)
 			case ADH_BYTE(ATTR_CONTEXT_CLASS, CLASS_ATTR_InnerClasses) :
 				// note the existence of this attr, but save for later
 				if (cur_class_has_local_ics)
-					abort("too many InnerClasses attrs");
+					unpack_abort("too many InnerClasses attrs");
 				cur_class_has_local_ics = true;
 				wp = wp_at(abase);
 				continue;
 
 			case ADH_BYTE(ATTR_CONTEXT_CLASS, CLASS_ATTR_SourceFile) :
-				aname = cp.sym[cpool::s_SourceFile];
+				aname = cp.sym[constant_pool::s_SourceFile];
 				ref = class_SourceFile_RUN.getRefN();
-				CHECK_0;
 				if (ref == nullptr)
 				{
 					bytes &n = cur_class->ref(0)->value.b;
@@ -4431,23 +4167,23 @@ int unpacker::write_attrs(int attrc, julong indexBits)
 				break;
 
 			case ADH_BYTE(ATTR_CONTEXT_CLASS, CLASS_ATTR_EnclosingMethod) :
-				aname = cp.sym[cpool::s_EnclosingMethod];
+				aname = cp.sym[constant_pool::s_EnclosingMethod];
 				putref(class_EnclosingMethod_RC.getRefN());
 				putref(class_EnclosingMethod_RDN.getRefN());
 				break;
 
 			case ADH_BYTE(ATTR_CONTEXT_FIELD, FIELD_ATTR_ConstantValue) :
-				aname = cp.sym[cpool::s_ConstantValue];
+				aname = cp.sym[constant_pool::s_ConstantValue];
 				putref(field_ConstantValue_KQ.getRefUsing(cp.getKQIndex()));
 				break;
 
 			case ADH_BYTE(ATTR_CONTEXT_METHOD, METHOD_ATTR_Code) :
-				aname = cp.sym[cpool::s_Code];
+				aname = cp.sym[constant_pool::s_Code];
 				write_code();
 				break;
 
 			case ADH_BYTE(ATTR_CONTEXT_METHOD, METHOD_ATTR_Exceptions) :
-				aname = cp.sym[cpool::s_Exceptions];
+				aname = cp.sym[constant_pool::s_Exceptions];
 				putu2(count = method_Exceptions_N.getInt());
 				for (j = 0; j < count; j++)
 				{
@@ -4456,7 +4192,7 @@ int unpacker::write_attrs(int attrc, julong indexBits)
 				break;
 
 			case ADH_BYTE(ATTR_CONTEXT_CODE, CODE_ATTR_StackMapTable) :
-				aname = cp.sym[cpool::s_StackMapTable];
+				aname = cp.sym[constant_pool::s_StackMapTable];
 				// (keep this code aligned with its brother in unpacker::read_attrs)
 				putu2(count = code_StackMapTable_N.getInt());
 				for (j = 0; j < count; j++)
@@ -4504,7 +4240,7 @@ int unpacker::write_attrs(int attrc, julong indexBits)
 				break;
 
 			case ADH_BYTE(ATTR_CONTEXT_CODE, CODE_ATTR_LineNumberTable) :
-				aname = cp.sym[cpool::s_LineNumberTable];
+				aname = cp.sym[constant_pool::s_LineNumberTable];
 				putu2(count = code_LineNumberTable_N.getInt());
 				for (j = 0; j < count; j++)
 				{
@@ -4514,7 +4250,7 @@ int unpacker::write_attrs(int attrc, julong indexBits)
 				break;
 
 			case ADH_BYTE(ATTR_CONTEXT_CODE, CODE_ATTR_LocalVariableTable) :
-				aname = cp.sym[cpool::s_LocalVariableTable];
+				aname = cp.sym[constant_pool::s_LocalVariableTable];
 				putu2(count = code_LocalVariableTable_N.getInt());
 				for (j = 0; j < count; j++)
 				{
@@ -4530,7 +4266,7 @@ int unpacker::write_attrs(int attrc, julong indexBits)
 				break;
 
 			case ADH_BYTE(ATTR_CONTEXT_CODE, CODE_ATTR_LocalVariableTypeTable) :
-				aname = cp.sym[cpool::s_LocalVariableTypeTable];
+				aname = cp.sym[constant_pool::s_LocalVariableTypeTable];
 				putu2(count = code_LocalVariableTypeTable_N.getInt());
 				for (j = 0; j < count; j++)
 				{
@@ -4546,24 +4282,24 @@ int unpacker::write_attrs(int attrc, julong indexBits)
 				break;
 
 			case ADH_BYTE(ATTR_CONTEXT_CLASS, X_ATTR_Signature) :
-				aname = cp.sym[cpool::s_Signature];
+				aname = cp.sym[constant_pool::s_Signature];
 				putref(class_Signature_RS.getRefN());
 				break;
 
 			case ADH_BYTE(ATTR_CONTEXT_FIELD, X_ATTR_Signature) :
-				aname = cp.sym[cpool::s_Signature];
+				aname = cp.sym[constant_pool::s_Signature];
 				putref(field_Signature_RS.getRefN());
 				break;
 
 			case ADH_BYTE(ATTR_CONTEXT_METHOD, X_ATTR_Signature) :
-				aname = cp.sym[cpool::s_Signature];
+				aname = cp.sym[constant_pool::s_Signature];
 				putref(method_Signature_RS.getRefN());
 				break;
 
 			case ADH_BYTE(ATTR_CONTEXT_CLASS, X_ATTR_Deprecated) :
 			case ADH_BYTE(ATTR_CONTEXT_FIELD, X_ATTR_Deprecated) :
 			case ADH_BYTE(ATTR_CONTEXT_METHOD, X_ATTR_Deprecated) :
-				aname = cp.sym[cpool::s_Deprecated];
+				aname = cp.sym[constant_pool::s_Deprecated];
 				// no data
 				break;
 			}
@@ -4575,7 +4311,7 @@ int unpacker::write_attrs(int attrc, julong indexBits)
 			layout_definition *lo = ad.getLayout(idx);
 			if (lo == nullptr)
 			{
-				abort("bad layout index");
+				unpack_abort("bad layout index");
 				break;
 			}
 			assert((int)lo->idx == idx);
@@ -4600,8 +4336,7 @@ int unpacker::write_attrs(int attrc, julong indexBits)
 		}
 
 		if (aname == nullptr)
-			abort("bad attribute index");
-		CHECK_0;
+			unpack_abort("bad attribute index");
 
 		byte *wp1 = wp;
 		wp = wp_at(abase);
@@ -4628,7 +4363,6 @@ int unpacker::write_attrs(int attrc, julong indexBits)
 
 void unpacker::write_members(int num, int attrc)
 {
-	CHECK;
 	attr_definitions &ad = attr_defs[attrc];
 	band &member_flags_hi = ad.xxx_flags_hi();
 	band &member_flags_lo = ad.xxx_flags_lo();
@@ -4636,18 +4370,16 @@ void unpacker::write_members(int num, int attrc)
 	bool haveLongFlags = ad.haveLongFlags();
 
 	putu2(num);
-	julong indexMask = attr_defs[attrc].flagIndexMask();
+	uint64_t indexMask = attr_defs[attrc].flagIndexMask();
 	for (int i = 0; i < num; i++)
 	{
-		julong mflags = member_flags_hi.getLong(member_flags_lo, haveLongFlags);
+		uint64_t mflags = member_flags_hi.getLong(member_flags_lo, haveLongFlags);
 		entry *mdescr = member_descr.getRef();
 		cur_descr = mdescr;
 		putu2(cur_descr_flags = (ushort)(mflags & ~indexMask));
-		CHECK;
 		putref(mdescr->descrName());
 		putref(mdescr->descrType());
 		write_attrs(attrc, (mflags & indexMask));
-		CHECK;
 	}
 	cur_descr = nullptr;
 }
@@ -4669,14 +4401,12 @@ void unpacker::write_classfile_tail()
 	attr_definitions &ad = attr_defs[ATTR_CONTEXT_CLASS];
 
 	bool haveLongFlags = ad.haveLongFlags();
-	julong kflags = class_flags_hi.getLong(class_flags_lo, haveLongFlags);
-	julong indexMask = ad.flagIndexMask();
+	uint64_t kflags = class_flags_hi.getLong(class_flags_lo, haveLongFlags);
+	uint64_t indexMask = ad.flagIndexMask();
 
 	cur_class = class_this.getRef();
 	cur_super = class_super.getRef();
 
-	CHECK;
-
 	if (cur_super == cur_class)
 		cur_super = nullptr;
 	// special representation for java/lang/Object
@@ -4693,7 +4423,6 @@ void unpacker::write_classfile_tail()
 
 	write_members(class_field_count.getInt(), ATTR_CONTEXT_FIELD);
 	write_members(class_method_count.getInt(), ATTR_CONTEXT_METHOD);
-	CHECK;
 
 	cur_class_has_local_ics = false; // may be set true by write_attrs
 
@@ -4760,7 +4489,6 @@ void unpacker::write_classfile_tail()
 	{
 		inner_class &extra_ic = extra_ics[i];
 		extra_ic.inner = class_InnerClasses_RC.getRef();
-		CHECK;
 		// Find the corresponding equivalent global IC:
 		inner_class *global_ic = cp.getIC(extra_ic.inner);
 		int flags = class_InnerClasses_F.getInt();
@@ -4769,7 +4497,7 @@ void unpacker::write_classfile_tail()
 			// The extra IC is simply a copy of a global IC.
 			if (global_ic == nullptr)
 			{
-				abort("bad reference to inner class");
+				unpack_abort("bad reference to inner class");
 				break;
 			}
 			extra_ic = (*global_ic); // fill in rest of fields
@@ -4812,7 +4540,7 @@ void unpacker::write_classfile_tail()
 	if (local_ics > 0)
 	{
 		// append the new attribute:
-		putref(cp.sym[cpool::s_InnerClasses]);
+		putref(cp.sym[constant_pool::s_InnerClasses]);
 		putu4(2 + 2 * 4 * local_ics);
 		putu2(local_ics);
 		PTRLIST_QSORT(requested_ics, raw_address_cmp);
@@ -4832,7 +4560,6 @@ void unpacker::write_classfile_tail()
 				putu2(ic->flags);
 			}
 		}
-		assert(local_ics == 0);		  // must balance
 		putu2_at(wp_at(naOffset), ++na); // increment class attr count
 	}
 
@@ -4844,7 +4571,6 @@ void unpacker::write_classfile_tail()
 	}
 	requested_ics.empty();
 
-	CHECK;
 	close_output();
 
 	// rewrite CP references in the tail
@@ -4868,7 +4594,6 @@ void unpacker::write_classfile_tail()
 			assert(false); // should not reach here
 		}
 	}
-	CHECK;
 }
 
 void unpacker::write_classfile_head()
@@ -4919,7 +4644,7 @@ void unpacker::write_classfile_head()
 			putu2(e.refs[1]->getOutputIndex());
 			break;
 		default:
-			abort(ERROR_INTERNAL);
+			unpack_abort(ERROR_INTERNAL);
 		}
 	}
 	close_output();
@@ -4927,7 +4652,6 @@ void unpacker::write_classfile_head()
 
 unpacker::file *unpacker::get_next_file()
 {
-	CHECK_0;
 	free_temps();
 	if (files_remaining == 0)
 	{
@@ -4936,9 +4660,9 @@ unpacker::file *unpacker::get_next_file()
 		cur_file.size = 0;
 		if (archive_size != 0)
 		{
-			julong predicted_size = unsized_bytes_read + archive_size;
+			uint64_t predicted_size = unsized_bytes_read + archive_size;
 			if (predicted_size != bytes_read)
-				abort("archive header had incorrect size");
+				unpack_abort("archive header had incorrect size");
 		}
 		return nullptr;
 	}
@@ -4953,7 +4677,6 @@ unpacker::file *unpacker::get_next_file()
 	if (files_written < file_count)
 	{
 		entry *e = file_name.getRef();
-		CHECK_0;
 		cur_file.name = e->utf8String();
 		bool haveLongSize = ((archive_options & AO_HAVE_FILE_SIZE_HI) != 0);
 		cur_file.size = file_size_hi.getLong(file_size_lo, haveLongSize);
@@ -4973,20 +4696,17 @@ unpacker::file *unpacker::get_next_file()
 		classes_written += 1;
 		if (cur_file.size != 0)
 		{
-			abort("class file size transmitted");
-			return nullptr;
+			unpack_abort("class file size transmitted");
 		}
 		reset_cur_classfile();
 
 		// write the meat of the classfile:
 		write_classfile_tail();
 		cur_file.data[1] = cur_classfile_tail.b;
-		CHECK_0;
 
 		// write the CP of the classfile, second:
 		write_classfile_head();
 		cur_file.data[0] = cur_classfile_head.b;
-		CHECK_0;
 
 		cur_file.size += cur_file.data[0].len;
 		cur_file.size += cur_file.data[1].len;
@@ -5006,8 +4726,7 @@ unpacker::file *unpacker::get_next_file()
 		if (cur_file.size != (size_t)cur_file.size)
 		{
 			// Silly size specified.
-			abort("resource file too large");
-			return nullptr;
+			unpack_abort("resource file too large");
 		}
 		size_t rpleft = input_remaining();
 		if (rpleft > 0)
@@ -5024,7 +4743,6 @@ unpacker::file *unpacker::get_next_file()
 			bytes_read += fleft; // Credit it to the overall archive size.
 		}
 	}
-	CHECK_0;
 	bytes_written += cur_file.size;
 	files_written += 1;
 	return &cur_file;
@@ -5034,7 +4752,7 @@ unpacker::file *unpacker::get_next_file()
 void unpacker::write_file_to_jar(unpacker::file *f)
 {
 	size_t htsize = f->data[0].len + f->data[1].len;
-	julong fsize = f->size;
+	uint64_t fsize = f->size;
 	if (htsize == fsize)
 	{
 		jarout->addJarEntry(f->name, f->deflate_hint(), f->modtime, f->data[0], f->data[1]);
@@ -5070,10 +4788,9 @@ void unpacker::write_file_to_jar(unpacker::file *f)
 				input.ensureSize(fleft);
 			}
 			rplimit = rp = input.base();
-			CHECK;
 			input.setLimit(rp + fleft);
 			if (!ensure_input(fleft))
-				abort("EOF reading resource file");
+				unpack_abort("EOF reading resource file");
 			part2.ptr = input_scan();
 			part2.len = input_remaining();
 			rplimit = rp = input.base();
@@ -5085,14 +4802,3 @@ void unpacker::write_file_to_jar(unpacker::file *f)
 		fprintf(stderr, "Wrote " LONG_LONG_FORMAT " bytes to: %s\n", fsize, f->name);
 	}
 }
-
-void unpacker::abort(const char *message)
-{
-	if (message == nullptr)
-		message = "error unpacking archive";
-	if (message[0] == '@')
-		++message;
-	fprintf(stderr, "%s\n", message);
-	fflush(stderr);
-	exit(-1);
-}