begin reveng add-ons for lua

[proxmark3-svn] / client / reveng / poly.c

/* poly.c
 * Greg Cook, 9/Apr/2015
 */

/* CRC RevEng, an arbitrary-precision CRC calculator and algorithm finder
 * Copyright (C) 2010, 2011, 2012, 2013, 2014, 2015  Gregory Cook
 *
 * This file is part of CRC RevEng.
 *
 * CRC RevEng is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * CRC RevEng is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with CRC RevEng.  If not, see <http://www.gnu.org/licenses/>.
 */

/* 2015-04-03: added direct mode to strtop()
 * 2014-01-11: added LOFS(), RNDUP()
 * 2013-09-16: SIZE(), IDX(), OFS() macros bitshift if BMP_POF2
 * 2013-02-07: conditional non-2^n fix, pmpar() return mask constant type
 * 2013-01-17: fixed pfirst(), plast() for non-2^n BMP_BIT
 * 2012-07-16: added pident()
 * 2012-05-23: added pmpar()
 * 2012-03-03: internal lookup tables stored better
 * 2012-03-02: fixed full-width masking in filtop()
 * 2011-09-06: added prevch()
 * 2011-08-27: fixed zero test in piter()
 * 2011-01-17: fixed ANSI C warnings, uses bmp_t type
 * 2011-01-15: palloc() and praloc() gracefully handle lengths slightly
 *	       less than ULONG_MAX
 * 2011-01-15: strtop() error on invalid argument. pkchop() special case
 *	       when argument all zeroes
 * 2011-01-14: added pkchop()
 * 2011-01-04: fixed bogus final length calculation in wide pcrc()
 * 2011-01-02: faster, more robust prcp()
 * 2011-01-01: commented functions, full const declarations, all-LUT rev()
 * 2010-12-26: renamed CRC RevEng
 * 2010-12-18: removed pmods(), finished pcrc(), added piter()
 * 2010-12-17: roughed out pcrc(). difficult, etiam aberat musa heri :(
 * 2010-12-15: added psnorm(), psncmp(); optimised pnorm(); fix to praloc()
 * 2010-12-14: strtop() resets count between passes
 * 2010-12-12: added pright()
 * 2010-12-11: filtop won't read more than length bits
 * 2010-12-10: finished filtop. 26 public functions
 * 2010-12-05: finished strtop, pxsubs; unit tests
 * 2010-12-02: project started
 */

/* Note: WELL-FORMED poly_t objects have a valid bitmap pointer pointing
 * to a malloc()-ed array of at least as many bits as stated in its
 * length field.  Any poly_t with a length of 0 is also a WELL-FORMED
 * poly_t (whatever value the bitmap pointer has.)
 * All poly_t objects passed to and from functions must be WELL-FORMED
 * unless otherwise stated.
 *
 * CLEAN (or CANONICAL) poly_t objects are WELL-FORMED objects in which
 * all spare bits in the bitmap word containing the last bit are zero.
 * (Any excess allocated words will not be accessed.)
 *
 * SEMI-NORMALISED poly_t objects are CLEAN objects in which the last
 * bit, at position (length - 1), is one.
 *
 * NORMALISED poly_t objects are SEMI-NORMALISED objects in which the
 * first bit is one.
 *
 * pfree() should be called on every poly_t object (including
 * those returned by functions) after its last use.
 * As always, free() should be called on every malloc()-ed string after
 * its last use.
 */

#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include "reveng.h"

static bmp_t getwrd(const poly_t poly, unsigned long iter);
static bmp_t rev(bmp_t accu, int bits);
static void prhex(char **spp, bmp_t bits, int flags, int bperhx);

static const poly_t pzero = PZERO;

/* word number (0..m-1) of var'th bit (0..n-1) */
#if BMP_POF2 >= 5
#  define IDX(var) ((var) >> BMP_POF2)
#else
#  define IDX(var) ((var) / BMP_BIT)
#endif

/* size of polynomial with var bits */
#if BMP_POF2 >= 5
#  define SIZE(var) ((BMP_BIT - 1UL + (var)) >> BMP_POF2)
#else
#  define SIZE(var) ((BMP_BIT - 1UL + (var)) / BMP_BIT)
#endif

/* polynomial length rounded up to BMP_BIT */
#ifdef BMP_POF2
#  define RNDUP(var) (~(BMP_BIT - 1UL) & (BMP_BIT - 1UL + (var)))
#else
#  define RNDUP(var) ((BMP_BIT - (var) % BMP_BIT) % BMP_BIT + (var))
#endif

/* bit offset (0..BMP_BIT-1, 0 = LSB) of var'th bit (0..n-1) */
#ifdef BMP_POF2
#  define OFS(var) ((int) ((BMP_BIT - 1UL) & ~(var)))
#else
#  define OFS(var) ((int) (BMP_BIT - 1UL - (var) % BMP_BIT))
#endif

/* bit offset (0..BMP_BIT-1, 0 = MSB) of var'th bit (0..n-1) */
#ifdef BMP_POF2
#  define LOFS(var) ((int) ((BMP_BIT - 1UL) & (var)))
#else
#  define LOFS(var) ((int) ((var) % BMP_BIT))
#endif

poly_t
filtop(FILE *input, unsigned long length, int flags, int bperhx) {
	/* reads binary data from input into a poly_t until EOF or until
	 * length bits are read.  Characters are read until
	 * ceil(bperhx / CHAR_BIT) bits are collected; if P_LTLBYT is
	 * set in flags then the first character contains the LSB,
	 * otherwise the last one does.  The least significant bperhx
	 * bits are taken, reflected (if P_REFIN) and appended to the
	 * result, then more characters are read.  The maximum number of
	 * characters read is
	 *   floor(length / bperhx) * ceil(bperhx / * CHAR_BIT).
	 * The returned poly_t is CLEAN.
	 */

	bmp_t accu = BMP_C(0);
	bmp_t mask = bperhx == BMP_BIT ? ~BMP_C(0) : (BMP_C(1) << bperhx) - BMP_C(1);
	unsigned long iter = 0UL, idx;
	int cmask = ~(~0 << CHAR_BIT), c;
	int count = 0, ofs;
	poly_t poly = PZERO;
	if(bperhx == 0) return(poly);

	length -= length % bperhx;
	palloc(&poly, length); /* >= 0 */

	while(iter < length && (c = fgetc(input)) != EOF) {
		if(flags & P_LTLBYT)
			accu |= (bmp_t) (c & cmask) << count;
		else
			accu = (accu << CHAR_BIT) | (bmp_t) (c & cmask);
		count += CHAR_BIT;
		if(count >= bperhx) {
			/* the low bperhx bits of accu contain bits of the poly.*/
			iter += bperhx;
			count = 0;
			if(flags & P_REFIN)
				accu = rev(accu, bperhx);
			accu &= mask;

			/* iter >= bperhx > 0 */
			idx = IDX(iter - 1UL);
			ofs = OFS(iter - 1UL);
			poly.bitmap[idx] |= accu << ofs;
			if(ofs + bperhx > BMP_BIT) {
				poly.bitmap[idx-1] |= accu >> (BMP_BIT - ofs);
			}
			accu = BMP_C(0); /* only needed for P_LTLBYT */
		}
	}
	praloc(&poly, iter);
	return(poly);
}

poly_t
strtop(const char *string, int flags, int bperhx) {
	/* Converts a hex or character string to a poly_t.
	 * Each character is converted to a hex nibble yielding 4 bits
	 * unless P_DIRECT, when each character yields CHAR_BIT bits.
	 * Nibbles and characters are accumulated left-to-right
	 * unless P_DIRECT && P_LTLBYT, when they are accumulated
	 * right-to-left without reflection.
	 * As soon as at least bperhx bits are accumulated, the
	 * rightmost bperhx bits are reflected (if P_REFIN)
	 * and appended to the poly.  When !P_DIRECT:
	 * bperhx=8 reads hex nibbles in pairs
	 * bperhx=7 reads hex nibbles in pairs and discards
	 *   b3 of first nibble
	 * bperhx=4 reads hex nibbles singly
	 * bperhx=3 reads octal
	 * bperhx=1 reads longhand binary
	 * in theory if !P_REFIN, bperhx can be any multiple of 4
	 * with equal effect
	 * The returned poly_t is CLEAN.
	 */

	/* make two passes, one to determine the poly size
	 * one to populate the bitmap
	 */
	unsigned long length = 1UL, idx;
	bmp_t accu;
	bmp_t mask = bperhx == BMP_BIT ? ~BMP_C(0) : (BMP_C(1) << bperhx) - BMP_C(1);
	int pass, count, ofs;
	int cmask = ~(~0 << CHAR_BIT), c;
	const char *s;

	poly_t poly = PZERO;
	if(bperhx > BMP_BIT || bperhx <= 0 || string == NULL || *string == '\0')
		return(poly);

	for(pass=0; pass<2 && length > 0UL; ++pass) {
		s = string;
		length = 0UL;
		count = 0;
		accu = BMP_C(0);
		while((c = *s++)) {
			if(flags & P_DIRECT) {
				if(flags & P_LTLBYT)
					accu |= (bmp_t) (c & cmask) << count;
				else
					accu = (accu << CHAR_BIT) | (bmp_t) (c & cmask);
				count += CHAR_BIT;
			} else {
				if(c == ' ' || c == '\t' || c == '\r' || c == '\n') continue;
				accu <<= 4;
				count += 4;
				switch(c) {
					case '0':
					case '1':
					case '2':
					case '3':
					case '4':
					case '5':
					case '6':
					case '7':
					case '8':
					case '9':
						accu |= (bmp_t) c - '0';
						break;
					case 'A':
					case 'a':
						accu |= BMP_C(0xa);
						break;
					case 'B':
					case 'b':
						accu |= BMP_C(0xb);
						break;
					case 'C':
					case 'c':
						accu |= BMP_C(0xc);
						break;
					case 'D':
					case 'd':
						accu |= BMP_C(0xd);
						break;
					case 'E':
					case 'e':
						accu |= BMP_C(0xe);
						break;
					case 'F':
					case 'f':
						accu |= BMP_C(0xf);
						break;
					default:
						uerror("invalid character in hexadecimal argument");
				}
			}

			if(count >= bperhx) {
				/* the low bperhx bits of accu contain bits of the poly.
				 * in pass 0, increment length by bperhx.
				 * in pass 1, put the low bits of accu into the bitmap. */
				length += bperhx;
				count = 0;
				if(pass == 1) {
					if(flags & P_REFIN)
						accu = rev(accu, bperhx);
					accu &= mask;

					/* length >= bperhx > 0 */
					idx = IDX(length - 1);
					ofs = OFS(length - 1);
					poly.bitmap[idx] |= accu << ofs;
					if(ofs + bperhx > BMP_BIT)
						poly.bitmap[idx-1] |= accu >> (BMP_BIT - ofs);
					accu = BMP_C(0); /* only needed for P_LTLBYT */
				}
			}
		}
		if(pass == 0) palloc(&poly, length);
	}
	return(poly);
}

char *
ptostr(const poly_t poly, int flags, int bperhx) {
	/* Returns a malloc()-ed string containing a hexadecimal
	 * representation of poly. See phxsubs().
	 */
	return(pxsubs(poly, flags, bperhx, 0UL, poly.length));
}

char *
pxsubs(const poly_t poly, int flags, int bperhx, unsigned long start, unsigned long end) {
	/* Returns a malloc()-ed string containing a hexadecimal
	 * representation of a portion of poly, from bit offset start to
	 * (end - 1) inclusive.  The output is grouped into words of
	 * bperhx bits each.  If P_RTJUST then the first word is padded
	 * with zeroes at the MSB end to make a whole number of words,
	 * otherwise the last word is padded at the LSB end.  After
	 * justification the bperhx bits of each word are reversed (if
	 * P_REFOUT) and printed as a hex sequence, with words
	 * optionally separated by spaces (P_SPACE).
	 * If end exceeds the length of poly then zero bits are appended
	 * to make up the difference, in which case poly must be CLEAN.
	 */
	char *string, *sptr;
	unsigned long size, iter;
	bmp_t accu;
	bmp_t mask = bperhx == BMP_BIT ? ~BMP_C(0) : (BMP_C(1) << bperhx) - BMP_C(1);
	int cperhx, part;

	if(bperhx <= 0 || bperhx > BMP_BIT) return(NULL);

	if(start > poly.length) start = poly.length;
	if(end > poly.length) end = poly.length;
	if(end < start) end = start;

	cperhx = (bperhx + 3) >> 2;
	if(flags & P_SPACE) ++cperhx;

	size = (end - start + bperhx - 1UL) / bperhx;
	size *= cperhx;
	if(!size || ~flags & P_SPACE) ++size; /* for trailing null */

	if(!(sptr = string = (char *) malloc(size)))
		uerror("cannot allocate memory for string");

	size = end - start;
	part = (int) size % bperhx;
	if(part && flags & P_RTJUST) {
		iter = start + part;
		accu = getwrd(poly, iter - 1UL) & ((BMP_C(1) << part) - BMP_C(1));
		if(flags & P_REFOUT)
			/* best to reverse over bperhx rather than part, I think
			 * e.g. converting a 7-bit poly to 8-bit little-endian hex
			 */
			accu = rev(accu, bperhx);
		prhex(&sptr, accu, flags, bperhx);
		if(flags & P_SPACE && size > iter) *sptr++ = ' ';
	} else {
		iter = start;
	}

	while((iter+=bperhx) <= end) {
		accu = getwrd(poly, iter - 1UL) & mask;
		if(flags & P_REFOUT)
			accu = rev(accu, bperhx);
		prhex(&sptr, accu, flags, bperhx);
		if(flags & P_SPACE && size > iter) *sptr++ = ' ';
	}

	if(part && ~flags & P_RTJUST) {
		accu = getwrd(poly, end - 1UL);
		if(flags & P_REFOUT)
			accu = rev(accu, part);
		else
			accu = accu << (bperhx - part) & mask;
		prhex(&sptr, accu, flags, bperhx);
	}
	*sptr = '\0';
	return(string);
}

poly_t
pclone(const poly_t poly) {
	/* Returns a freestanding copy of poly.  Does not clean poly or
	 * the result.
	 */
	poly_t clone = PZERO;

	pcpy(&clone, poly);
	return(clone);
}

void
pcpy(poly_t *dest, const poly_t src) {
	/* Assigns (copies) src into dest.  Does not clean src or dest.
	 */
	unsigned long iter, idx;

	praloc(dest, src.length);
	for(iter=0UL, idx=0UL; iter < src.length; iter += BMP_BIT, ++idx)
		dest->bitmap[idx] = src.bitmap[idx];
}

void
pcanon(poly_t *poly) {
	/* Converts poly into a CLEAN object by freeing unused bitmap words
	 * and clearing any bits in the last word beyond the last bit.
	 * The length field has absolute priority over the contents of the bitmap.
	 * Canonicalisation differs from normalisation in that leading and trailing
	 * zero terms are significant and preserved.
	 * poly may or may not be WELL-FORMED.
	 */
	praloc(poly, poly->length);
}

void
pnorm(poly_t *poly) {
	/* Converts poly into a NORMALISED object by removing leading
	 * and trailing zeroes, so that the polynomial starts and ends
	 * with significant terms.
	 * poly may or may not be WELL-FORMED.
	 */
	unsigned long first;

	/* call pcanon() here so pfirst() and plast() return the correct
	 * results
	 */
	pcanon(poly);
	first = pfirst(*poly);
	if(first)
		pshift(poly, *poly, 0UL, first, plast(*poly), 0UL);
	else
		praloc(poly, plast(*poly));
}

void
psnorm(poly_t *poly) {
	/* Converts poly into a SEMI-NORMALISED object by removing
	 * trailing zeroes, so that the polynomial ends with a
	 * significant term.
	 * poly may or may not be WELL-FORMED.
	 */

	/* call pcanon() here so plast() returns the correct result */
	pcanon(poly);
	praloc(poly, plast(*poly));
}

void
pchop(poly_t *poly) {
	/* Normalise poly, then chop off the highest significant term
	 * (produces a SEMI-NORMALISED object).  poly becomes a suitable
	 * divisor for pcrc().
	 * poly may or may not be WELL-FORMED.
	 */

	 /* call pcanon() here so pfirst() and plast() return correct
	  * results
	  */
	pcanon(poly);
	pshift(poly, *poly, 0UL, pfirst(*poly) + 1UL, plast(*poly), 0UL);
}

void
pkchop(poly_t *poly) {
	/* Convert poly from Koopman notation to chopped form (produces
	 * a SEMI-NORMALISED object).  poly becomes a suitable divisor
	 * for pcrc().
	 * poly may or may not be WELL-FORMED.
	 */
	unsigned long first;

	/* call pcanon() here so pfirst() returns the correct result */
	pcanon(poly);
	first = pfirst(*poly);
	if(first >= poly->length) {
		pfree(poly);
		return;
	}
	pshift(poly, *poly, 0UL, first + 1UL, poly->length, 1UL);
	piter(poly);
}

unsigned long
plen(const poly_t poly) {
	/* Return length of polynomial.
	 * poly may or may not be WELL-FORMED.
	 */
	return(poly.length);
}

int
pcmp(const poly_t *a, const poly_t *b) {
	/* Compares poly_t objects for identical sizes and contents.
	 * a and b must be CLEAN.
	 * Defines a total order relation for sorting, etc. although
	 * mathematically, polynomials of equal degree are no greater or
	 * less than one another.
	 */
	unsigned long iter;
	bmp_t *aptr, *bptr;

	if(!a || !b) return(!b - !a);
	if(a->length < b->length) return(-1);
	if(a->length > b->length) return(1);
	aptr = a->bitmap;
	bptr = b->bitmap;
	for(iter=0UL; iter < a->length; iter += BMP_BIT) {
		if(*aptr < *bptr)
			return(-1);
		if(*aptr++ > *bptr++)
			return(1);
	}
	return(0);
}

int
psncmp(const poly_t *a, const poly_t *b) {
	/* Compares polys for identical effect, i.e. as though the
	 * shorter poly were padded with zeroes to the length of the
	 * longer.
	 * a and b must still be CLEAN, therefore psncmp() is *not*
	 * identical to pcmp() on semi-normalised polys as psnorm()
	 * clears the slack space.
	 */
	unsigned long length, iter, idx;
	bmp_t aword, bword;
	if(!a || !b) return(!b - !a);
	length = (a->length > b->length) ? a->length : b->length;
	for(iter = 0UL, idx = 0UL; iter < length; iter += BMP_BIT, ++idx) {
		aword = (iter < a->length) ? a->bitmap[idx] : BMP_C(0);
		bword = (iter < b->length) ? b->bitmap[idx] : BMP_C(0);
		if(aword < bword)
			return(-1);
		if(aword > bword)
			return(1);
	}
	return(0);
}


int
ptst(const poly_t poly) {
	/* Tests whether a polynomial equals zero.  Returns 0 if equal,
	 * a nonzero value otherwise.
	 * poly must be CLEAN.
	 */
	unsigned long iter;
	bmp_t *bptr;
	if(!poly.bitmap) return(0);
	for(iter = 0UL, bptr = poly.bitmap; iter < poly.length; iter += BMP_BIT)
		if(*bptr++) return(1);
	return(0);
}

unsigned long
pfirst(const poly_t poly) {
	/* Returns the index of the first nonzero term in poly.  If none
	 * is found, returns the length of poly.
	 * poly must be CLEAN.
	 */
	unsigned long idx = 0UL, size = SIZE(poly.length);
	bmp_t accu = BMP_C(0); /* initialiser for Acorn C */
	unsigned int probe = BMP_SUB, ofs = 0;

	while(idx < size && !(accu = poly.bitmap[idx])) ++idx;
	if(idx >= size) return(poly.length);
	while(probe) {
#ifndef BMP_POF2
		while((ofs | probe) >= (unsigned int) BMP_BIT) probe >>= 1;
#endif
		if(accu >> (ofs | probe)) ofs |= probe;
		probe >>= 1;
	}

	return(BMP_BIT - 1UL - ofs + idx * BMP_BIT);
}

unsigned long
plast(const poly_t poly) {
	/* Returns 1 plus the index of the last nonzero term in poly.
	 * If none is found, returns zero.
	 * poly must be CLEAN.
	 */
	unsigned long idx, size = SIZE(poly.length);
	bmp_t accu;
	unsigned int probe = BMP_SUB, ofs = 0;

	if(!poly.length) return(0UL);
	idx = size - 1UL;
	while(idx && !(accu = poly.bitmap[idx])) --idx;
	if(!idx && !(accu = poly.bitmap[idx])) return(0UL);
	/* now accu == poly.bitmap[idx] and contains last significant term */
	while(probe) {
#ifndef BMP_POF2
		while((ofs | probe) >= (unsigned int) BMP_BIT) probe >>= 1;
#endif
		if(accu << (ofs | probe)) ofs |= probe;
		probe >>= 1;
	}

	return(idx * BMP_BIT + ofs + 1UL);
}

poly_t
psubs(const poly_t src, unsigned long head, unsigned long start, unsigned long end, unsigned long tail) {
	poly_t dest = PZERO;
	pshift(&dest, src, head, start, end, tail);
	return(dest);
}

void
pright(poly_t *poly, unsigned long length) {
	/* Trims or extends poly to length at the left edge, prepending
	 * zeroes if necessary.  Analogous to praloc() except the
	 * rightmost terms of poly are preserved.
	 * On entry, poly may or may not be WELL-FORMED.
	 * On exit, poly is CLEAN.
	 */

	if(length > poly->length)
		pshift(poly, *poly, length - poly->length, 0UL, poly->length, 0UL);
	else if(length < poly->length)
		pshift(poly, *poly, 0UL, poly->length - length, poly->length, 0UL);
	else
		praloc(poly, poly->length);
}

void
pshift(poly_t *dest, const poly_t src, unsigned long head, unsigned long start, unsigned long end, unsigned long tail) {
	/* copies bits start to end-1 of src to dest, plus the number of leading and trailing zeroes given by head and tail.
	 * end may exceed the length of src in which case more zeroes are appended.
	 * dest may point to src, in which case the poly is edited in place.
	 * On exit, dest is CLEAN.
	 */

	unsigned long length, fulllength, size, fullsize, iter, idx, datidx;
	/* condition inputs; end, head and tail may be any value */
	if(end < start) end = start;

	length = end - start + head;
	fulllength = length + tail;
	if(fulllength > src.length)
		praloc(dest, fulllength);
	else
		praloc(dest, src.length);

	/* number of words in new poly */
	size = SIZE(length);
	fullsize = SIZE(fulllength);
	/* array index of first word ending up with source material */
	datidx = IDX(head);

	if(head > start && end > start) {
		/* shifting right, size > 0 */
		/* index of the source bit ending up in the LSB of the last word
		 * size * BMP_BIT >= length > head > 0 */
		iter = size * BMP_BIT - head - 1UL;
		for(idx = size - 1UL; idx > datidx; iter -= BMP_BIT, --idx)
			dest->bitmap[idx] = getwrd(src, iter);
		dest->bitmap[idx] = getwrd(src, iter);
		/* iter == size * BMP_BIT - head - 1 - BMP_BIT * (size - 1 - datidx)
		 *      == BMP_BIT * (size - size + 1 + datidx) - head - 1
		 *      == BMP_BIT * (1 + head / BMP_BIT) - head - 1
		 *      == BMP_BIT + head - head % BMP_BIT - head - 1
		 *      == BMP_BIT - head % BMP_BIT - 1
		 *      >= 0
		 */
	} else if(head <= start) {
		/* shifting left or copying */
		/* index of the source bit ending up in the LSB of bitmap[idx] */
		iter = start - head + BMP_BIT - 1UL;
		for(idx = datidx; idx < size; iter += BMP_BIT, ++idx)
			dest->bitmap[idx] = getwrd(src, iter);
	}

	/* clear head */
	for(idx = 0UL; idx < datidx; ++idx)
		dest->bitmap[idx] = BMP_C(0);
	if(size)
		dest->bitmap[datidx] &= ~BMP_C(0) >> LOFS(head);

	/* clear tail */
	if(LOFS(length))
		dest->bitmap[size - 1UL] &= ~(~BMP_C(0) >> LOFS(length));
	for(idx = size; idx < fullsize; ++idx)
		dest->bitmap[idx] = BMP_C(0);

	/* call praloc to shrink poly if required */
	if(dest->length > fulllength)
		praloc(dest, fulllength);
}

void
ppaste(poly_t *dest, const poly_t src, unsigned long skip, unsigned long seek, unsigned long end, unsigned long fulllength) {
	/* pastes terms of src, starting from skip, to positions seek to end-1 of dest
	 * then sets length of dest to fulllength (>= end)
	 * to paste n terms of src, give end = seek + n
	 * to truncate dest at end of paste, set fulllength = end
	 * to avoid truncating, set fulllength = plen(*dest)
	 * dest may point to src, in which case the poly is edited in place.
	 * src must be CLEAN in the case that the end is overrun.
	 * On exit, dest is CLEAN.
	 */
	bmp_t mask;
	unsigned long seekidx, endidx, iter;
	int seekofs;
	if(end < seek) end = seek;
	if(fulllength < end) fulllength = end;

	/* expand dest if necessary. don't shrink as dest may be src */
	if(fulllength > dest->length)
		praloc(dest, fulllength);
	seekidx = IDX(seek);
	endidx = IDX(end);
	seekofs = OFS(seek);
	/* index of the source bit ending up in the LSB of the first modified word */
	iter = skip + seekofs;
	if(seekidx == endidx) {
		/* paste affects one word (traps end = seek case) */
		mask = ((BMP_C(1) << seekofs) - (BMP_C(1) << OFS(end))) << 1;
		dest->bitmap[seekidx] = (dest->bitmap[seekidx] & ~mask) | (getwrd(src, iter) & mask);
	} else if(seek > skip) {
		/* shifting right */
		/* index of the source bit ending up in the LSB of the last modified word */
		iter += (endidx - seekidx) * BMP_BIT;
		mask = ~BMP_C(0) >> LOFS(end);
		dest->bitmap[endidx] = (dest->bitmap[endidx] & mask) | (getwrd(src, iter) & ~mask);
		for(iter -= BMP_BIT, --endidx; endidx > seekidx; iter -= BMP_BIT, --endidx)
			dest->bitmap[endidx] = getwrd(src, iter);
		mask = ~BMP_C(0) >> LOFS(seek);
		dest->bitmap[endidx] = (dest->bitmap[endidx] & ~mask) | (getwrd(src, iter) & mask);
		/* iter == skip + seekofs + (endidx - seekidx) * BMP_BIT - BMP_BIT * (endidx - seekidx)
		 *      == skip + seekofs + BMP_BIT * (endidx - seekidx - endidx + seekidx)
		 *      == skip + seekofs
		 *      >= 0
		 */
	} else {
		/* shifting left or copying */
		mask = ~BMP_C(0) >> LOFS(seek);
		dest->bitmap[seekidx] = (dest->bitmap[seekidx] & ~mask) | (getwrd(src, iter) & mask);
		for(iter += BMP_BIT, ++seekidx; seekidx < endidx; iter += BMP_BIT, ++seekidx)
			dest->bitmap[seekidx] = getwrd(src, iter);
		mask = ~BMP_C(0) >> LOFS(end);
		dest->bitmap[seekidx] = (dest->bitmap[seekidx] & mask) | (getwrd(src, iter) & ~mask);
	}
	/* shrink poly if required */
	if(dest->length > fulllength)
		praloc(dest, fulllength);
}

void
pdiff(poly_t *dest, const poly_t src, unsigned long ofs) {
	/* Subtract src from dest (modulo 2) at offset ofs.
	 * In modulo 2 arithmetic, subtraction is equivalent to addition
	 * We include an alias for those who wish to retain the distinction
	 * src and dest must be CLEAN.
	 */
	psum(dest, src, ofs);
}

void
psum(poly_t *dest, const poly_t src, unsigned long ofs) {
	/* Adds src to dest (modulo 2) at offset ofs.
	 * When ofs == dest->length, catenates src on to dest.
	 * src and dest must be CLEAN.
	 */
	unsigned long fulllength, idx, iter, end;

	fulllength = ofs + src.length;
	if(fulllength > dest->length)
		praloc(dest, fulllength);
	/* array index of first word in dest to be modified */
	idx = IDX(ofs);
	/* index of bit in src to be added to LSB of dest->bitmap[idx] */
	iter = OFS(ofs);
	/* stop value for iter */
	end = BMP_BIT - 1UL + src.length;
	for(; iter < end; iter += BMP_BIT, ++idx)
		dest->bitmap[idx] ^= getwrd(src, iter);
}

void
prev(poly_t *poly) {
	/* Reverse or reciprocate a polynomial.
	 * On exit, poly is CLEAN.
	 */
	unsigned long leftidx = 0UL, rightidx = SIZE(poly->length);
	unsigned long ofs = LOFS(BMP_BIT - LOFS(poly->length));
	unsigned long fulllength = poly->length + ofs;
	bmp_t accu;

	if(ofs)
		/* removable optimisation */
		if(poly->length < (unsigned long) BMP_BIT) {
			*poly->bitmap = rev(*poly->bitmap >> ofs, (int) poly->length) << ofs;
			return;
		}

		/* claim remaining bits of last word (as we use public function pshift()) */
		poly->length = fulllength;

	/* reverse and swap words in the array, leaving it right-justified */
	while(leftidx < rightidx) {
		/* rightidx > 0 */
		accu = rev(poly->bitmap[--rightidx], BMP_BIT);
		poly->bitmap[rightidx] = rev(poly->bitmap[leftidx], BMP_BIT);
		poly->bitmap[leftidx++] = accu;
	}
	/* shift polynomial to left edge if required */
	if(ofs)
		pshift(poly, *poly, 0UL, ofs, fulllength, 0UL);
}

void
prevch(poly_t *poly, int bperhx) {
	/* Reverse each group of bperhx bits in a polynomial.
	 * Does not clean poly.
	 */
	unsigned long iter = 0, idx, ofs;
	bmp_t mask, accu;

	if(bperhx < 2 || bperhx > BMP_BIT)
		return;
	if(poly->length % bperhx)
		praloc(poly, bperhx - (poly->length % bperhx) + poly->length);
	mask = ~BMP_C(0) >> (BMP_BIT - bperhx);
	for(iter = (unsigned long) (bperhx - 1); iter < poly->length; iter += bperhx) {
		accu = getwrd(*poly, iter) & mask;
		accu ^= rev(accu, bperhx);
		idx = IDX(iter);
		ofs = OFS(iter);
		poly->bitmap[idx] ^= accu << ofs;
		if(ofs + bperhx > (unsigned int) BMP_BIT)
			/* (BMP_BIT - 1UL - (iter) % BMP_BIT) + bperhx > BMP_BIT
			 * (-1UL - (iter) % BMP_BIT) + bperhx > 0
			 * (- (iter % BMP_BIT)) + bperhx > 1
			 * - (iter % BMP_BIT) > 1 - bperhx
			 * iter % BMP_BIT < bperhx - 1, iter >= bperhx - 1
			 * iter >= BMP_BIT
			 * idx >= 1
			 */
			poly->bitmap[idx-1] ^= accu >> (BMP_BIT - ofs);
	}
}

void
prcp(poly_t *poly) {
	/* Reciprocate a chopped polynomial.  Use prev() on whole
	 * polynomials.
	 * On exit, poly is SEMI-NORMALISED.
	 */
	unsigned long first;

	praloc(poly, RNDUP(poly->length));
	prev(poly);
	first = pfirst(*poly);
	if(first >= poly->length) {
		pfree(poly);
		return;
	}
	pshift(poly, *poly, 0UL, first + 1UL, poly->length, 1UL);
	piter(poly);
}

void
pinv(poly_t *poly) {
	/* Invert a polynomial, i.e. add 1 (modulo 2) to the coefficient of each term
	 * on exit, poly is CLEAN.
	 */
	unsigned long idx, size = SIZE(poly->length);

	for(idx = 0UL; idx<size; ++idx)
		poly->bitmap[idx] = ~poly->bitmap[idx];
	if(LOFS(poly->length))
		poly->bitmap[size - 1UL] &= ~(~BMP_C(0) >> LOFS(poly->length));
}

poly_t
pmod(const poly_t dividend, const poly_t divisor) {
	/* Divide dividend by normalised divisor and return the remainder
	 * This function generates a temporary 'chopped' divisor for pcrc()
	 * If calling repeatedly with a constant divisor, produce a chopped copy
	 * with pchop() and call pcrc() directly for higher efficiency.
	 * dividend and divisor must be CLEAN.
	 */

	/* perhaps generate an error if divisor is zero */
	poly_t subdivisor = psubs(divisor, 0UL, pfirst(divisor) + 1UL, plast(divisor), 0UL);
	poly_t result = pcrc(dividend, subdivisor, pzero, pzero, 0);
	pfree(&subdivisor);
	return(result);
}

poly_t
pcrc(const poly_t message, const poly_t divisor, const poly_t init, const poly_t xorout, int flags) {
	/* Divide message by divisor and return the remainder.
	 * init is added to divisor, highest terms aligned, before
	 * division.
	 * xorout is added to the remainder, highest terms aligned.
	 * If P_MULXN is set in flags, message is multiplied by x^n
	 * (i.e. trailing zeroes equal to the CRC width are appended)
	 * before adding init and division.  Set P_MULXN for most CRC
	 * calculations.
	 * All inputs must be CLEAN.
	 * If all inputs are CLEAN, the returned poly_t will be CLEAN.
	 */
	unsigned long max = 0UL, iter, ofs, resiter;
	bmp_t probe, rem, dvsr, *rptr, *sptr;
	const bmp_t *bptr, *eptr;
	poly_t result = PZERO;

	if(flags & P_MULXN)
		max = message.length;
	else if(message.length > divisor.length)
		max = message.length - divisor.length;
	bptr=message.bitmap;
	eptr=message.bitmap+SIZE(message.length);
	probe=~(~BMP_C(0) >> 1);
	if(divisor.length <= (unsigned long) BMP_BIT
		&& init.length <= (unsigned long) BMP_BIT) {
		rem = init.length ? *init.bitmap : BMP_C(0);
		dvsr = divisor.length ? *divisor.bitmap : BMP_C(0);
		for(iter = 0UL, ofs = 0UL; iter < max; ++iter, --ofs) {
			if(!ofs) {
				ofs = BMP_BIT;
				rem ^= *bptr++;
			}
			if(rem & probe)
				rem = (rem << 1) ^ dvsr;
			else
				rem <<= 1;
		}
		if(bptr < eptr)
			/* max < message.length */
			rem ^= *bptr >> OFS(BMP_BIT - 1UL + max);
		if(init.length > max && init.length - max > divisor.length) {
			palloc(&result, init.length - max);
			*result.bitmap = rem;
		} else if(divisor.length) {
			palloc(&result, divisor.length);
			*result.bitmap = rem;
		}
	} else {
		/* allocate maximum size plus one word for shifted divisors and one word containing zero.
		 * This also ensures that result[1] exists
		 */
		palloc(&result, (init.length > divisor.length ? init.length : divisor.length) + (unsigned long) (BMP_BIT << 1));
		/*if there is content in init, there will be an extra word in result to clear it */
		psum(&result, init, 0UL);
		if(max)
			*result.bitmap ^= *bptr++;
		for(iter = 0UL, ofs = 0UL; iter < max; ++iter, probe >>= 1) {
			if(!probe) {
				probe = ~(~BMP_C(0) >> 1);
				ofs = 0UL;
				sptr = rptr = result.bitmap;
				++sptr;
				/* iter < max <= message.length, so bptr is valid
				 * shift result one word to the left, splicing in a message word
				 * and clearing the last active word
				 */
				*rptr++ = *sptr++ ^ *bptr++;
				for(resiter = (unsigned long) (BMP_BIT << 1); resiter < result.length; resiter += BMP_BIT)
					*rptr++ = *sptr++;
			}
			++ofs;
			if(*result.bitmap & probe)
				psum(&result, divisor, ofs);
		}
		rptr = result.bitmap;
		++rptr;
		while(bptr < eptr)
			*rptr++ ^= *bptr++;
		/* 0 <= ofs <= BMP_BIT, location of the first bit of the result */
		pshift(&result, result, 0UL, ofs, (init.length > max + divisor.length ? init.length - max - divisor.length : 0UL) + divisor.length + ofs, 0UL);
	}
	psum(&result, xorout, 0UL);
	return(result);
}

int
piter(poly_t *poly) {
	/* Replace poly with the 'next' polynomial of equal length.
	 * Returns zero if the next polynomial is all zeroes, a nonzero
	 * value otherwise.
	 * Does not clean poly.
	 */
	bmp_t *bptr;
	if(!poly->length) return(0);

	bptr = poly->bitmap + IDX(poly->length - 1UL);
	*bptr += BMP_C(1) << OFS(poly->length - 1UL);
	while(bptr != poly->bitmap && !*bptr)
		++(*--bptr);
	return(*bptr != BMP_C(0));
}

void
palloc(poly_t *poly, unsigned long length) {
	/* Replaces poly with a CLEAN object of the specified length,
	 * consisting of all zeroes.
	 * It is safe to call with length = 0, in which case the object
	 * is freed.
	 * poly may or may not be WELL-FORMED.
	 * On exit, poly is CLEAN.
	 */
	unsigned long size = SIZE(length);

	poly->length = 0UL;
	free(poly->bitmap);
	poly->bitmap = NULL;
	if(!length) return;
	if(!size)
		size = IDX(length) + 1UL;
	poly->bitmap = (bmp_t *) calloc(size, sizeof(bmp_t));
	if(poly->bitmap) {
		poly->length = length;
	} else
		uerror("cannot allocate memory for poly");
}

void
pfree(poly_t *poly) {
	/* Frees poly's bitmap storage and sets poly equal to the empty
	 * polynomial (PZERO).
	 * poly may or may not be WELL-FORMED.
	 * On exit, poly is CLEAN.
	 */

	/* palloc(poly, 0UL); */

	poly->length = 0UL;
	free(poly->bitmap);
	poly->bitmap = NULL;
}

void
praloc(poly_t *poly, unsigned long length) {
	/* Trims or extends poly to length at the right edge, appending
	 * zeroes if necessary.
	 * On entry, poly may or may not be WELL-FORMED.
	 * On exit, poly is CLEAN.
	 */
	unsigned long oldsize, size = SIZE(length);
	if(!poly) return;
	if(!length) {
		poly->length = 0UL;
		free(poly->bitmap);
		poly->bitmap = NULL;
		return;
	}
	if(!size)
		size = IDX(length) + 1UL;
	if(!poly->bitmap)
		poly->length = 0UL;
	oldsize = SIZE(poly->length);
	if(oldsize != size)
		/* reallocate if array pointer is null or array resized */
		poly->bitmap = (bmp_t *) realloc((void *)poly->bitmap, size * sizeof(bmp_t));
	if(poly->bitmap) {
		if(poly->length < length) {
			/* poly->length >= 0, length > 0, size > 0.
			 * poly expanded. clear old last word and all new words
			 */
			if(LOFS(poly->length))
				poly->bitmap[oldsize - 1UL] &= ~(~BMP_C(0) >> LOFS(poly->length));
			while(oldsize < size)
				poly->bitmap[oldsize++] = BMP_C(0);
		} else if(LOFS(length))
			/* poly->length >= length > 0.
			 * poly shrunk. clear new last word
			 */
			poly->bitmap[size - 1UL] &= ~(~BMP_C(0) >> LOFS(length));
		poly->length = length;
	} else
		uerror("cannot reallocate memory for poly");
}

int
pmpar(const poly_t poly, const poly_t mask) {
	/* Return even parity of poly masked with mask.
	 * Poly and mask must be CLEAN.
	 */
	bmp_t res = BMP_C(0);
	int i = BMP_SUB;
	const bmp_t *pptr = poly.bitmap, *mptr = mask.bitmap;
	const bmp_t *const pend = poly.bitmap + SIZE(poly.length);
	const bmp_t *const mend = mask.bitmap + SIZE(mask.length);

	while(pptr < pend && mptr < mend)
		res ^= *pptr++ & *mptr++;
	do
		res ^= res >> i;
	while(i >>= 1);

	return((int) (res & BMP_C(1)));
}

int
pident(const poly_t a, const poly_t b) {
	/* Return nonzero if a and b have the same length
	 * and point to the same bitmap.
	 * a and b need not be CLEAN.
	 */
	return(a.length == b.length && a.bitmap == b.bitmap);
}

/* Private functions */

static bmp_t
getwrd(const poly_t poly, unsigned long iter) {
	/* Fetch unaligned word from poly where LSB of result is
	 * bit iter of the bitmap (counting from zero).  If iter exceeds
	 * the length of poly then zeroes are appended as necessary.
	 * Factored from ptostr().
	 * poly must be CLEAN.
	 */
	bmp_t accu = BMP_C(0);
	unsigned long idx, size;
	int ofs;

	idx = IDX(iter);
	ofs = OFS(iter);
	size = SIZE(poly.length);

	if(idx < size)
		accu |= poly.bitmap[idx] >> ofs;
	if(idx && idx <= size && ofs > 0)
		accu |= poly.bitmap[idx - 1UL] << (BMP_BIT - ofs);
	return(accu);
}

static bmp_t
rev(bmp_t accu, int bits) {
	/* Returns the bitmap word argument with the given number of
	 * least significant bits reversed and the rest cleared.
	 */
	static const unsigned char revtab[256] = {
		0x00,0x80,0x40,0xc0,0x20,0xa0,0x60,0xe0,
		0x10,0x90,0x50,0xd0,0x30,0xb0,0x70,0xf0,
		0x08,0x88,0x48,0xc8,0x28,0xa8,0x68,0xe8,
		0x18,0x98,0x58,0xd8,0x38,0xb8,0x78,0xf8,
		0x04,0x84,0x44,0xc4,0x24,0xa4,0x64,0xe4,
		0x14,0x94,0x54,0xd4,0x34,0xb4,0x74,0xf4,
		0x0c,0x8c,0x4c,0xcc,0x2c,0xac,0x6c,0xec,
		0x1c,0x9c,0x5c,0xdc,0x3c,0xbc,0x7c,0xfc,
		0x02,0x82,0x42,0xc2,0x22,0xa2,0x62,0xe2,
		0x12,0x92,0x52,0xd2,0x32,0xb2,0x72,0xf2,
		0x0a,0x8a,0x4a,0xca,0x2a,0xaa,0x6a,0xea,
		0x1a,0x9a,0x5a,0xda,0x3a,0xba,0x7a,0xfa,
		0x06,0x86,0x46,0xc6,0x26,0xa6,0x66,0xe6,
		0x16,0x96,0x56,0xd6,0x36,0xb6,0x76,0xf6,
		0x0e,0x8e,0x4e,0xce,0x2e,0xae,0x6e,0xee,
		0x1e,0x9e,0x5e,0xde,0x3e,0xbe,0x7e,0xfe,
		0x01,0x81,0x41,0xc1,0x21,0xa1,0x61,0xe1,
		0x11,0x91,0x51,0xd1,0x31,0xb1,0x71,0xf1,
		0x09,0x89,0x49,0xc9,0x29,0xa9,0x69,0xe9,
		0x19,0x99,0x59,0xd9,0x39,0xb9,0x79,0xf9,
		0x05,0x85,0x45,0xc5,0x25,0xa5,0x65,0xe5,
		0x15,0x95,0x55,0xd5,0x35,0xb5,0x75,0xf5,
		0x0d,0x8d,0x4d,0xcd,0x2d,0xad,0x6d,0xed,
		0x1d,0x9d,0x5d,0xdd,0x3d,0xbd,0x7d,0xfd,
		0x03,0x83,0x43,0xc3,0x23,0xa3,0x63,0xe3,
		0x13,0x93,0x53,0xd3,0x33,0xb3,0x73,0xf3,
		0x0b,0x8b,0x4b,0xcb,0x2b,0xab,0x6b,0xeb,
		0x1b,0x9b,0x5b,0xdb,0x3b,0xbb,0x7b,0xfb,
		0x07,0x87,0x47,0xc7,0x27,0xa7,0x67,0xe7,
		0x17,0x97,0x57,0xd7,0x37,0xb7,0x77,0xf7,
		0x0f,0x8f,0x4f,0xcf,0x2f,0xaf,0x6f,0xef,
		0x1f,0x9f,0x5f,0xdf,0x3f,0xbf,0x7f,0xff
	};
	bmp_t result = BMP_C(0);
	while(bits > 8) {
		bits -= 8;
		result = result << 8 | revtab[accu & 0xff];
		accu >>= 8;
	}
	result = result << bits | (bmp_t) (revtab[accu & 0xff] >> (8 - bits));
	return(result);
}

static void
prhex(char **spp, bmp_t bits, int flags, int bperhx) {
	/* Appends a hexadecimal string representing the bperhx least
	 * significant bits of bits to an external string.
	 * spp points to a character pointer that in turn points to the
	 * end of a hex string being built.  prhex() advances this
	 * second pointer by the number of characters written.
	 * The unused MSBs of bits MUST be cleared.
	 * Set P_UPPER in flags to write A-F in uppercase.
	 */
	static const char hex[] = "0123456789abcdef0123456789ABCDEF";
	const int upper = (flags & P_UPPER ? 0x10 : 0);
	while(bperhx > 0) {
		bperhx -= ((bperhx + 3) & 3) + 1;
		*(*spp)++ = hex[(bits >> bperhx & BMP_C(0xf)) | upper];
	}
}