path: root/packages/openslug-init/openslug-init-0.10/devio.c

/* vi: set sw=4 ts=4: */
/*
 * devio: correctly read a region of a device
 *
 * A dd like program designed to read correctly from mtd character
 * (and maybe block) devices.  Allows access to specific regions
 * of the device and allows output of numbers from specific locations.
 *
 * Copyright (C) 2005 John Bowler <jbowler@acm.org>
 *
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation files
 * (the "Software"), to deal in the Software without restriction,
 * including without limitation the rights to use, copy, modify,
 * merge, publish, distribute, sublicense, and/or sell copies of the
 * Software, and to permit persons to whom the Software is furnished
 * to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <limits.h>
#include <errno.h>

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>

#ifndef S_ISSOCK
#define S_ISSOCK(fd) 0
#endif

/* Define to 0 to remove the detailed help. */
#ifndef HELP
#define HELP 1
#endif

#ifndef STR_MAX
#define STR_MAX 4096
#endif

/* common error-and-die functions - reduces code size slightly. */
static int error_level = 1; /* Increased by write operations. */

/* NDEBUG will only save about 600 bytes! */
/* The noreturn attribute helps reduce size by 300 bytes, and removes
 * warning messages
 */
#if NDEBUG
static void do_die(const unsigned char *why) __attribute__((noreturn));
static void do_die(const unsigned char *why) {
	fprintf(stderr, "devio: %s\n", why);
	exit(error_level);
}
#define die(a,b) do_die(a)
#else
static void do_die(const unsigned char *why, const unsigned char *infile)
    __attribute__((noreturn));
static void do_die(const unsigned char *why, const unsigned char *infile) {
	fprintf(stderr, "devio: %s: %s\n", infile, why);
	exit(error_level);
}
#define die(a,b) do_die((a),(b))
#endif

#if NDEBUG
static void do_pdie(const unsigned char *why) __attribute__((noreturn));
static void do_pdie(const unsigned char *why) {
	fprintf(stderr, "devio: %s: %s\n", why, strerror(errno));
	exit(error_level);
}
#define pdie(a,b) do_pdie(a)
#else
static void do_pdie(const unsigned char *why, const unsigned char *infile)
    __attribute__((noreturn));
static void do_pdie(const unsigned char *why, const unsigned char *infile) {
	fprintf(stderr, "devio: %s: %s: %s\n", infile, why, strerror(errno));
	exit(error_level);
}
#define pdie(a,b) do_pdie((a),(b))
#endif

/* This is a non-standard assert but it saves quite a lot of
 * space (1kbyte) over the OS version.
 */
#if NDEBUG
#define assert(condition) do;while(0)
#elif 0 /* Expensive string asserts (lots of space in strings). */
static void do_assert(const unsigned char *why)
    __attribute__((noreturn));
static void do_assert(const unsigned char *why) {
	fprintf(stderr, "devio: internal error: %s\n", why);
	exit(error_level);
}
#define assert(condition) do if (!(condition)) do_assert(#condition); while (0)
#else
static void do_assert(int line) __attribute__((noreturn));
static void do_assert(int line) {
	fprintf(stderr, "devio: internal error: %d\n", line);
	exit(error_level);
}
#define assert(condition) do if (!(condition)) do_assert(__LINE__); while (0)
#endif

/* This is a non-ANSI extension. */
unsigned char *my_strdup(const unsigned char *from) {
	size_t cb = strlen(from)+1;
	unsigned char *to = malloc(cb);
	if (to == 0)
		die("out of memory", from);
	memcpy(to, from, cb);
	return to;
}


/***********************************************************************
 * mtd_file
 *
 * Basic device safe IO.
 * Set mtd_seek to set the desired read or write point.
 * Use mtd_getb and mtd_putb to read/write a single byte.
 * Use mtd_readbytes and mtd_writebytes to move multiple bytes.
 *********************************************************************/
/* File structure, used for read and write operations.  stdio() should do
 * everything this does pretty much except that this allows for no-write
 * buffering and it is 'weird' in that it won't overwrite beyond the end
 * of the data. */
typedef struct mtd_file {
	unsigned char* pname;
	int            fwrite;
	int            fverify;  /* do not write, just verify */
	int            fwritten; /* something to do! */
	int            fchanged; /* something was done! */
	int            fd;
	struct stat    stat;
	size_t         cbbuf;
	/* The user pointer is at 'useroffset', the buffer contains data from
	 * 'bufferoffset' to 'deviceoffset' (exclusive - the buffer may be empty), so
	 * the file descriptor is pointing to 'deviceoffset', which may be just beyond
	 * the end of the file.
	 */
	off_t          useroffset;   /* Current user position */
	off_t          bufferoffset; /* Base of current buffer */
	off_t          deviceoffset; /* End of current buffer */
	off_t          endoffset;    /* Length of char or block device. */
	unsigned char* pbuf;
	unsigned char* pwritebuf;
} mtd_file;


/* Initialise an mtd structure. */
static void init_mtd(mtd_file *pfile) {
	pfile->pname = 0;
	pfile->fwrite = 0;
	pfile->fverify = 0;
	pfile->fwritten = 0;
	pfile->fchanged = 0;
	pfile->fd = (-1);
	memset(&pfile->stat, 0, sizeof pfile->stat);
	pfile->cbbuf = 0;
	pfile->useroffset = 0;
	pfile->bufferoffset  = 0;
	pfile->deviceoffset = 0;
	pfile->endoffset = (off_t)-1;
	pfile->pbuf = 0;
	pfile->pwritebuf = 0;
}


/* Return the size, in bytes. */
static size_t size_mtd(mtd_file *pfile) {
	if (S_ISCHR(pfile->stat.st_mode) || S_ISBLK(pfile->stat.st_mode)) {
		if (pfile->endoffset == (off_t)-1) {
			off_t len;
			assert(pfile->stat.st_size == 0);
			assert(pfile->stat.st_blocks == 0);
			assert(pfile->stat.st_blksize > 0);
			/* So seek to the end then come back here. */
			len = lseek(pfile->fd, -pfile->stat.st_blksize, SEEK_END);
			if (len == (off_t)-1)
				pdie("lseek(length)", pfile->pname);
			if (lseek(pfile->fd, pfile->deviceoffset, SEEK_SET) != pfile->deviceoffset)
				pdie("lseek(length reset)", pfile->pname);
			len += pfile->stat.st_blksize;
			pfile->endoffset = len;
		}
		return pfile->endoffset;
	} else if (S_ISDIR(pfile->stat.st_mode) || S_ISFIFO(pfile->stat.st_mode) ||
				S_ISSOCK(pfile->stat.st_mode))
		die("cannot find size of this device", pfile->pname);
	else
		return pfile->stat.st_size;
}


/* Open the named file for read or write, the structure is initialised
 * appropriately.  The name is copied. */
static void new_mtd(mtd_file *pfile, const char *pname, int fwrite, int fverify, int fd) {
	pfile->pname = my_strdup(pname);
	pfile->fwrite = fwrite;
	pfile->fverify = fverify;
	pfile->fwritten = 0;
	pfile->fchanged = 0;
	pfile->fd = fd;

	if (fstat(fd, &pfile->stat) != 0)
		pdie("fstat", pname);
	/* This can be made to work with fifos on read because it is possible
	 * to seek by reading so long as we only seek forward, but it really
	 * isn't worth spending time on this.
	 */
	if (S_ISDIR(pfile->stat.st_mode) || S_ISFIFO(pfile->stat.st_mode) ||
			S_ISSOCK(pfile->stat.st_mode))
		die("invalid device", pname);
	/* Allow writing to a file for testing - i.e. S_ISREG is fine above. */
	pfile->cbbuf = pfile->stat.st_blksize;
	if (pfile->cbbuf == 0)
		pfile->cbbuf = 4096;
	pfile->useroffset = 0;
	pfile->bufferoffset = 0;
	pfile->deviceoffset = 0;
	pfile->pbuf = 0;
	pfile->pwritebuf = 0;
}

static void open_mtd(mtd_file *pfile, const char *pname, int fwrite, int fverify) {
	int fd = open(pname, (fwrite && !fverify) ? O_RDWR : O_RDONLY);
	if (fd < 0)
		pdie("open", pname);
	else if (fd < 3)
		die("no standard streams", "-");
	new_mtd(pfile, pname, fwrite, fverify, fd);
}


/* Do the actual write.  Any pending write buffers are checked and output
 * to the device.  Happens on close and can be called before.  Does not
 * do an fsync.  The fwritten flag indicates that write_mtd needs to be
 * called, the fchanegd flag indicates that something has been written and
 * an fdatasync needs to happen before the close.
 */
static void write_mtd(mtd_file *pfile) {
	if (pfile->fwritten) {
		size_t count = pfile->deviceoffset - pfile->bufferoffset;
		unsigned char *pbuf = pfile->pwritebuf;

		assert(pfile->pbuf != 0);
		assert(pbuf != 0);
		assert(pfile->deviceoffset > pfile->bufferoffset);
		assert(pfile->deviceoffset <= pfile->bufferoffset + pfile->cbbuf);
		/* If it changed write it. */
		if (memcmp(pfile->pbuf, pbuf, count) != 0) {
			/* If verifying the verify just failed... */
			if (pfile->fverify)
				die("verification failed", pfile->pname);

			/* So write the whole of this buffer back.  Do not do a sync here
			 * because that would force a complete write of the flash erase
			 * block - not good.
			 */
			if (lseek(pfile->fd, pfile->bufferoffset, SEEK_SET) != pfile->bufferoffset)
				pdie("lseek(write)", pfile->pname);
			/* write, well, you have to keep doing it until it works, you
			 * also have to RTFM several times to get this write, so if
			 * this looks wrong please fix it.  No, not that, that was
			 * deliberate.
			 */
			do {
				ssize_t cb = write(pfile->fd, pbuf, count);
				assert(cb != 0);
				assert(cb <= count);
				if (cb < 0) switch (errno) {
				case EINTR:  /* shall we try that again then? */
					/* This is the common case - this does happen, it is
					 * necessary to deal with it and it is sufficient to
					 * try again.
					 */
					break;
				case EAGAIN: /* what, oh well, if at once you don't succeed. */
					/* We didn't say O_NONBLOCK above so this should never
					 * happen, however it has.  The code will therefore go into
					 * a tight loop in the manner of a certain Scottish nobleman.
					 */
					break;
				case EPIPE:  /* you don't love me any more. */
					/* This is a little difficult, it means we were squirting
					 * data down a pipe, so somehow someone has managed to work
					 * out both how to create a named pipe and how much fun to
					 * have by passing it to this program on the command line,
					 * then they have worked out how to make the shell ignore
					 * SIGPIPE in a spawned program (possible with some shells)
					 * then they want to see the really dumb message that comes
					 * out as a result.  We just say no.
					 */
					exit(1);
				default:
					pdie("write", pfile->pname);
				} else {
					count -= cb;
					/* It is now necessary to fdatasync this file descriptor
					 * to ensure that this data really does get to its final
					 * destination.  (Note that even this is probably not certain
					 * if the destination is a disk with a RAM buffer - which
					 * means *any* disk these days.)
					 */
					pfile->fchanged = 1;
					/* Something has been written to flash, but not everything
					 * has (necessarily) been written yet, so if something goes
					 * wrong after this point we are in deep, deep, trouble.
					 */
					error_level = 3;
				}
			} while (count > 0);

			/* So now the device matches the write buffer and the device
			 * pointer is back where it was before.
			 */
			memcpy(pfile->pbuf, pfile->pwritebuf, pfile->deviceoffset-pfile->bufferoffset);
		}
		/* Nothing remains to write from this buffer (hence nothing at all
		 * for this device.)
		 */
		pfile->fwritten = 0;
	}
}


/* Close the file, if anything was written out does an fsync.
 */
static void close_mtd(mtd_file *pfile) {
	write_mtd(pfile);
	assert(!pfile->fwritten);
	if (pfile->pbuf != 0) {
		free(pfile->pbuf);
		pfile->pbuf = 0;
	}
	if (pfile->pwritebuf != 0) {
		free(pfile->pwritebuf);
		pfile->pwritebuf = 0;
	}
	if (pfile->fd >= 0) {
		/* For a write file be very very careful.  For read ignore errors:
		 * it is more important to successfully write than to whine about
		 * strange close errors from a file we don't care about.  For a
		 * write file with nothing written we don't care either.
		 */
		if (pfile->fchanged) {
			/* This is the all important bit.  Doing the fdatasync is what
			 * flushes the data to the flash.  If this isn't done there is
			 * no guarantee that close will detect a write error, 'cause the
			 * flash may not have completed the write before the close
			 * returns.
			 */
			if (fdatasync(pfile->fd) != 0) {
				/* Trying an fdatasync on a pipe, etc, is silly, but we do
				 * it anyway.  EROFS means we just tried to write to a
				 * read only file system, safe but still an error.
				 */
				if (errno != EINVAL)
					pdie("sync", pfile->pname);
			}
			if (close(pfile->fd) != 0)
				pdie("close", pfile->pname);
		} else
			(void)close(pfile->fd);
		pfile->fd = (-1);
	}
	if (pfile->pname != 0) {
		free(pfile->pname);
		pfile->pname = 0;
	}
	init_mtd(pfile);
}


/* Obtain an input and, if necessary, an output buffer. */
static void buffer_mtd(mtd_file *pfile) {
	if (pfile->pbuf == 0) {
		size_t blksize = pfile->cbbuf;
		assert(blksize > 0);
		assert(pfile->pwritebuf == 0);

		/* Get blksize bytes (note: things could be speeded up by aligning
		 * the buffer but this really doesn't matter, all the time goes in
		 * read/write of the flash!)
		 */
		pfile->pbuf = malloc(blksize);
		if (pfile->fwrite)
			pfile->pwritebuf = malloc(blksize);
		if (pfile->pbuf == 0 || (pfile->fwrite && pfile->pwritebuf == 0))
			die("out of memory", pfile->pname);
	}
}


/* Read some data including the current user position.  This will also *write* data
 * if something is waiting to be written.
 *
 * NOTE: in the original design I conceived of some scheme whereby all the writes
 * would be buffered up for the end, but I can't see how this would actually help
 * anything because even if data has to be read from the device to determine read
 * locations it tends to happen before the relevant writes.  In the access patterns
 * I know (they are very simple - and that is important in itself) there is never
 * a need to read from a write device.
 */
static void read_mtd(mtd_file *pfile) {
	size_t cbread;
	int ioffset;

	/* 'useroffset' is where we need to read from, 'deviceoffset' is where we are
	 * at (sic) and 'bufferoffset'..'deviceoffset' is what we have already.
	 */
	if (pfile->useroffset >= pfile->bufferoffset &&
		pfile->useroffset < pfile->deviceoffset)
		return;

	if (pfile->useroffset < 0 || pfile->useroffset >= size_mtd(pfile))
		die("read outside file", pfile->pname);

	/* Make sure there is a buffer. */
	buffer_mtd(pfile);

	/* This is the maximum amount which can be read. */
	cbread = pfile->cbbuf;
	if (pfile->useroffset >= pfile->bufferoffset &&
		pfile->useroffset < pfile->bufferoffset + cbread) {
		/* Just fill the rest of the buffer. */
		ioffset = pfile->deviceoffset - pfile->bufferoffset;

		assert(pfile->deviceoffset < pfile->bufferoffset + cbread);
		cbread -= ioffset;
	} else {
		off_t base;

		/* We to move the buffer therefore  any pending write needs to be flushed. */
		write_mtd(pfile);
		assert(!pfile->fwritten);

		/* Seek to the aligned buffer boundary if necessary. */
		base = (pfile->useroffset / cbread) * cbread;
		if (base != pfile->deviceoffset) {
			if (lseek(pfile->fd, base, SEEK_SET) != base)
				pdie("lseek(read)", pfile->pname);
			pfile->deviceoffset = base;
		}
		pfile->bufferoffset = base;
		ioffset = 0;
	}

	/* Reading is like writing, EINTR can stop it succeeding but is a
	 * continuable error.
	 */
	assert(pfile->bufferoffset <= pfile->useroffset);
	assert(pfile->useroffset < pfile->bufferoffset + cbread);
	assert(pfile->deviceoffset <= pfile->useroffset);
	do {
		ssize_t cb = read(pfile->fd, pfile->pbuf+ioffset, cbread);
		if (cb < 0) switch (errno) {
		case EINTR:  /* simple restart */
			/* POSIX allows this to happen when something has been
			 * read.  Reset the file pointer just in case.
			 */
			if (lseek(pfile->fd, pfile->deviceoffset, SEEK_SET) != pfile->deviceoffset)
				pdie("lseek(read reset)", pfile->pname);
			break;
		case EAGAIN: /* O_NONBLOCK on the input? */
			break;
		default:
			pdie("read", pfile->pname);
		} else if (cb == 0) {
			die("unexpected end of file", pfile->pname);
		} else {
			/* Save a copy of the data so that it can be written out again
			 * by a write file.
			 */
			if (pfile->pwritebuf != 0)
				memcpy(pfile->pwritebuf+ioffset, pfile->pbuf+ioffset, cb);
			cbread -= cb;
			ioffset += cb;
			pfile->deviceoffset += cb;
		}
	} while (cbread > 0 && pfile->useroffset >= pfile->deviceoffset);

	assert(pfile->useroffset < pfile->deviceoffset);
}


/* Basic IO - these are the functions to use, not the internal read/write
 * functions above.
 */
/* Set the current read/write pointer on this file. */
#if 0 /*UNUSED*/
static void mtd_seek(mtd_file *pfile, off_t offset) {
	pfile->useroffset = offset;
}
#endif


/* Get a single byte (returned) and advance the read pointer by one. */
static unsigned char mtd_getb(mtd_file *pfile) {
	read_mtd(pfile);
	return (pfile->fwrite ? pfile->pwritebuf : pfile->pbuf)[
		pfile->useroffset++ - pfile->bufferoffset];
}


/* Store a single byte in a write file and advance the pointer by one. */
static void mtd_putb(mtd_file *pfile, unsigned long b) {
	if (!pfile->fwrite)
		die("file is not writeable", pfile->pname);
	read_mtd(pfile);
	if (b != pfile->pwritebuf[pfile->useroffset-pfile->bufferoffset]) {
		pfile->pwritebuf[pfile->useroffset-pfile->bufferoffset] = b;
		pfile->fwritten = 1;
	}
	++(pfile->useroffset);
}


/* Read a given number of bytes, which must exist in the file, and
 * advance the pointer by that amount.
 */
static void mtd_readbytes(mtd_file *pfile, unsigned char *pbuf, size_t cb) {
	if (pfile->useroffset+cb > size_mtd(pfile))
		die("read beyond end of file", pfile->pname);

	while (cb > 0) {
		int cbavail;

		read_mtd(pfile);
		cbavail = pfile->deviceoffset - pfile->useroffset;
		assert(cbavail > 0 && cbavail <= pfile->cbbuf);
		if (cbavail > cb)
			cbavail = cb;

		assert(pfile->useroffset >= pfile->bufferoffset);
		assert(pfile->useroffset < pfile->deviceoffset);
		assert(pfile->deviceoffset <= pfile->bufferoffset + pfile->cbbuf);

		memcpy(pbuf, (pfile->fwrite ? pfile->pwritebuf : pfile->pbuf) +
					(pfile->useroffset-pfile->bufferoffset), cbavail);
		pfile->useroffset += cbavail;
		pbuf += cbavail;
		cb -= cbavail;
	}
}


/* Write a given number of bytes and advance the pointer.  As with readbytes
 * the bytes must already exist in the file - mtd_file will never extend the
 * file only change existing bytes.
 */
static void mtd_writebytes(mtd_file *pfile, const unsigned char *pbuf, size_t cb) {
	if (!pfile->fwrite)
		die("file is not writeable", pfile->pname);
	if (pfile->useroffset+cb > size_mtd(pfile))
		die("write beyond end of file", pfile->pname);
	while (cb > 0) {
		int cbavail;

		/* This may look strange but it is correct - this code always reads
		 * before it writes to avoid unnecessary writes.
		 */
		read_mtd(pfile);
		cbavail = pfile->deviceoffset - pfile->useroffset;
		if (cbavail > cb)
			cbavail = cb;
		memcpy(pfile->pwritebuf + (pfile->useroffset-pfile->bufferoffset), pbuf, cbavail);
		pfile->fwritten = 1;
		pfile->useroffset += cbavail;
		pbuf += cbavail;
		cb -= cbavail;
	}
}


#if 0 /* Commented out because I don't think this is worth while. */
/* Copy bytes from the pointer in one file to the pointer in another
 * file (avoids an intermediate buffer compared to readbytes/writebytes.)
 */
static void mtd_copy(mtd_file *pto, mtd_file *pfrom, size_t cb) {
	int cbfrom, cbto;

	if (!pto->fwrite)
		die("file is not writeable", pto->pname);
	if (pto->useroffset+cb > size_mtd(pto))
		die("write beyond end of file", pto->pname);
	if (pfrom->useroffset+cb > size_mtd(pfrom))
		die("read beyond end of file", pfrom->pname);
	/* Copying from and to the same place has no effect. */
	if (pfrom == pto)
		return;

	cbfrom = cbto = 0;
	while (cb > 0) {
		int cbavail;

		if (cbfrom <= 0) {
			read_mtd(pfrom);
			cbfrom = pfrom->deviceoffset - pfrom->useroffset;
		 compared to readbytes/writebytes}
		if (cbto <= 0) {
			read_mtd(pto);
			cbto = pto->deviceoffset - pto->useroffset;
		}

		/* Take the smallest byte count and copy it. */
		cbavail = cbfrom;
		if (cbavail > cbto)
			cbavail = cbto;
		if (cbavail > cb)
			cbavail = cb;

		memcpy(pto->pwritebuf + (pto->useroffset-pto->bufferoffset),
				pfrom->pbuf + (pfrom->useroffset-pfrom->bufferoffset),
				cbavail);
		pto->fwritten = 1;

		pto->useroffset += cbavail;
		cbto -= cbavail;
		pfrom->useroffset += cbavail;
		cbfrom -= cbavail;

		cb -= cbavail;
	}
}
#endif


/***********************************************************************
 * parse
 *
 * Parse a command line option or a single line.  See the help below
 * for details...
 ***********************************************************************/
#define STACK_BASE 8
#define STACK_SIZE 256
#define NUM_FILES  16
typedef struct parse_buf {
	int           fverify; /* Just verifying, do no write. */
	int           cstack;
	int           fbreak;  /* Break in an expression. */
	mtd_file*     pfrom;
	mtd_file*     pto;

	/* The buffers. */
	unsigned long variables[256];
	unsigned long stack[STACK_SIZE];
	mtd_file      files[NUM_FILES];
} parse_buf;


/* Initialiser. */
static void init_parse(parse_buf *pp, int fverify) {
	int i;
	memset(pp, 0, sizeof *pp);
	pp->fverify = fverify;
	pp->cstack = STACK_BASE;
	pp->fbreak = 0;
	pp->pfrom = 0;
	pp->pto = 0;
	for (i=0; i<NUM_FILES; ++i)
		init_mtd(pp->files+i);
}


/* Terminator. */
static void quit(parse_buf *pp, int exit_code) __attribute__((noreturn));
static void quit(parse_buf *pp, int exit_code) {
	int i;
	/* Close all the files. */
	for (i=0; i<NUM_FILES; ++i)
		if (pp->files[i].pname != 0)
			close_mtd(pp->files+i);

	/* And make sure the output worked too. */
	if (fflush(stdout) == EOF || ferror(stdout) || fclose(stdout) == EOF)
		pdie("output failed", "stdout");

	exit(exit_code);
}


/* Input a single byte. */
static unsigned char inb(parse_buf *pp) {
	int b;
	if (pp->pfrom == 0) {
		b = getchar();
		if (b == EOF)
			pdie("read error", "stdin");
	} else {
		b = mtd_getb(pp->pfrom);
	}
	return b;
}


/* Output a single byte. */
static void outb(parse_buf *pp, unsigned long b) {
	if (pp->pto == 0) {
		if (putchar(b) == EOF)
			pdie("write error", "stdout");
	} else {
		mtd_putb(pp->pto, b);
	}
}


/* Output these bytes. */
static void outputbytes(parse_buf *pp, const char *pbuf, size_t cb) {
	if (pp->pto == 0) {
		if (fwrite(pbuf, cb, 1, stdout) != 1)
			pdie("write error", "stdout");
	} else
		mtd_writebytes(pp->pto, pbuf, cb);
}

/* Copy a stream of bytes. */
static void copybytes(parse_buf *pp, size_t cb) {
	while (cb > 0) {
		size_t cbavail = cb;
		unsigned char buf[1024];
		if (cbavail > sizeof buf)
			cbavail = sizeof buf;
		if (pp->pfrom == 0) {
			if (fread(buf, cbavail, 1, stdin) != 1)
				pdie("read error", "stdin");
		} else
			mtd_readbytes(pp->pfrom, buf, cbavail);

		outputbytes(pp, buf, cbavail);

		cb -= cbavail;
	}
}


/* Fill the output with a count of bytes of a given value. */
static void fillbytes(parse_buf *pp, unsigned long val, size_t cb) {
	unsigned char buf[1024];
	memset(buf, val, sizeof buf);

	while (cb > 0) {
		size_t cbavail = cb;
		if (cbavail > sizeof buf)
			cbavail = sizeof buf;

		outputbytes(pp, buf, cbavail);

		cb -= cbavail;
	}
}


/* Push a single numeric value onto the stack. */
static void push(parse_buf *pp, unsigned long num, const unsigned char *str) {
	if (pp->cstack >= STACK_SIZE)
		die("stack overflow", str);
	pp->stack[pp->cstack++] = num;
}


/* Pop one or move variables. */
static void pop(parse_buf *pp, int num, const unsigned char *str) {
	if (pp->cstack < STACK_BASE+num)
		die("stack underflow", str);
	pp->cstack -= num;
}

/* Return (and pop) the top of stack. */
static unsigned long top(parse_buf *pp, const unsigned char *str) {
	if (pp->cstack <= STACK_BASE)
		die("stack underflow", str);
	return pp->stack[--(pp->cstack)];
}


/* Store the result of an operator. */
static void op(parse_buf *pp, int numpop, unsigned long num,
		const unsigned char *str) {
	pop(pp, numpop, str);
	push(pp, num, str);
}


/* Parse a single expression, which may be empty.  The conditional execution
 * stuff is identical to that for a command except that (:?) are used instead
 * of $($:$?$)
 */
static int parse_expression(parse_buf *pp, const unsigned char *line, int Ac, int AcEnd) {
	int SP = 0, fnoexec = 0, test = 0;
	int stack[16];

	for (;Ac<AcEnd;++Ac) {
		const unsigned char *lp = line+Ac;
		unsigned char ch = *lp;
		switch (ch) {
			/* Control flow.  These operators have to explicitly check
			 * the fnoexec state because they manipulate it.
			 */
		case '(': /* if */
			if (SP >= 16)
				die("() stack overflow", lp);
			stack[SP++] = Ac;
			if (fnoexec) {
				fnoexec += 3;
			} else {
				fnoexec = top(pp, lp) == 0;
			}
			break;

		case '[': /* test start */
			/* If fnoexec >= 3 the whole block is disabled. */
			if (fnoexec <= 2) {
				/* Valid only inside an () block and there should only
				 * be one active at once.
				 */
				if (test != 0 || SP <= 0)
					goto badnest;
				/* Record the start of the test. */
				test = Ac+1;
				/* If the previous block executed record this. */
				if (fnoexec == 0)
					fnoexec = 2;
			}
			break;

		case ':': /* elif */
			/* fnoexec is 1 if nothing has executed in this block yet,
			 * and if the block itself is executing, it is 2 if something
			 * did execute, it is >2 for a non-executed block, including
			 * one with a break.
			 */
			if (fnoexec <= 2) {
				if (test == 0 || SP <= 0)
					goto badnest;

				assert(fnoexec > 0);
				assert(!pp->fbreak);
				/* 1: nothing has executed yet.
				 * 2: an if or elif has executed.
				 */
				if (fnoexec == 1) {
					/* Parse the test.  If this results in a break no
					 * condition is popped from the stack, otherwise
					 * the condition which the expression should push
					 * is popped.
					 */
					(void)parse_expression(pp, line, test, Ac);
					if (pp->fbreak) {
						fnoexec = 3;
						pp->fbreak = 0;
					} else
						fnoexec = top(pp, lp) == 0;
				}

				/* And the test has been consumed. */
				test = 0;
			}
			break;

		case ')': /* end+loop if */
			/* The stack must always be popped. */
			if (SP <= 0)
				goto badnest;
			--SP;
			/* If fnoexec>2 then this is a nested disabled block or, in
			 * the case of 3, a break.  In neither case is the expression
			 * evaluated and the test setting is for an enclosing block.
			 */
			if (fnoexec > 2) {
				fnoexec -= 3;
			} else {
				/* In this case there must be a test. */
				if (test == 0)
					goto badnest;

				/* Execution resumes regardless. */
				fnoexec = 0;
				assert(!pp->fbreak);

				/* So make the loop test now - this may cause a branch back
				 * to the ( and that will push the stack again.  Evaluate
				 * the test.
				 */
				(void)parse_expression(pp, line, test, Ac);
				if (pp->fbreak)
					pp->fbreak = 0;
				else if (top(pp, lp) != 0) {
					Ac = stack[SP]-1; /* Ac is incremented below */
				}

				/* And the test has been consumed. */
				test = 0;
			}
			break;

		badnest:
			die("bad [: or [) nesting", lp);
			break;

		case ';':
		case '\n':
			/* end of line terminates the loop, but Ac is stepped beyond the
			 * terminator.
			 */
			++Ac;
			goto end;

		case ' ':
		case '\f':
		case '\r':
		case '\t':
		case '\v':
		case ',':  /* Treat as a space */
			/* Skip other white space. */
			break;

			/* Everything else is glommed together because the fnoexec case
			 * can be simply handled by skipping character-by-character (because
			 * (:?); do not occur inside numbers!)
			 */
		default:
			if (fnoexec)
				break;

			if (isupper(ch))
				push(pp, pp->variables[ch], lp);
			else if (isdigit(ch)) {
				char *end = (char*)lp;
				unsigned long num;
				errno = 0;
				num = strtoul(lp, &end, 0);
				if (num == ULONG_MAX && (errno == EINVAL || errno == ERANGE))
					pdie("invalid number", lp);
				push(pp, num, lp);
				/* strotul returns a pointer to the first invalid character in
				 * end, so Ac becomes end-line-1, because it is incremented below.
				 */
				Ac = (const unsigned char*)end-line-1;
			} else {
				/* The operators are handled here.  An unrecognised character is an
				 * error at this point.  The left, right are always valid because
				 * the stack has 8 unused slots at the top...
				 */
				unsigned long left = pp->stack[pp->cstack - 2];
				unsigned long right = pp->stack[pp->cstack - 1];

				switch (ch) {
				case '?': /* break */
					/* break inside a condition is actually allowed, so this may
					 * happen with SP==0 while evaluating a condition.  For the
					 * moment ? is also allowed outside a loop, it terminates the
					 * processing of the whole expression.
					 */
					if (top(pp, lp) != 0) {
						/* break: skip to the ) and do not do the test on
						 * that either.
						 */
						fnoexec = 3;
					}
					break;

				#define DIOP(operator) op(pp, 2, left operator right, lp); break
				#define MONOP(operator) op(pp, 1, operator right, lp); break
					/* The C operators */
				case '*': DIOP(*);
				case '+': DIOP(+);
				case '-': DIOP(-);
				case '/': DIOP(/);
				case '%': DIOP(%);
				case '<': DIOP(<);
				case '>': DIOP(>);
				case '|': DIOP(|);
				case '&': DIOP(&);
				case '^': DIOP(^);
				case '~': MONOP(~);
				case '!': MONOP(!);
				case '=': /* equality */
					op(pp, 2, left == right, lp);
					break;
				case '{': /* shift left */
					op(pp, 2, left << right, lp);
					break;
				case '}': /* shift right */
					op(pp, 2, left >> right, lp);
					break;
				case 'r': /* rotate right */
					op(pp, 2, (left >> right) + (left << (32-right)), lp);
					break;
				case 'e': /* sign extend (right is number of valid bits). */
					op(pp, 2, (long)(left << (32-right)) >> (32-right), lp);
					break;
				case 'm': /* mask (right is number of valid bits). */
					op(pp, 2, (left << (32-right)) >> (32-right), lp);
					break;
				case '$': /* Size of input. */
					if (pp->pfrom == 0)
						die("size of input unknown", lp);
					push(pp, size_mtd(pp->pfrom), lp);
					break;
				case 'f': /* position of input ('from' pointer). */
					if (pp->pfrom == 0)
						die("position of input unknown", lp);
					push(pp, pp->pfrom->useroffset, lp);
					break;
				case '#': /* Size of output. */
					if (pp->pto == 0)
						die("size of output unknown", lp);
					push(pp, size_mtd(pp->pto), lp);
					break;
				case 't': /* position of output ('to' pointer). */
					if (pp->pto == 0)
						die("position of output unknown", lp);
					push(pp, pp->pto->useroffset, lp);
					break;
				case 'd': /* device number of the input device */
					if (pp->pfrom == 0)
						die("input device number unknown", lp);
					push(pp, pp->pfrom->stat.st_rdev == 0 ? pp->pfrom->stat.st_dev :
							pp->pfrom->stat.st_rdev, lp);
					break;
				case '@': /* one byte read. */
					push(pp, inb(pp), lp);
					break;
				case 'b': /* big endian 4 byte read. */
					#define P(st) (void)parse_expression(pp, st, 0, (sizeof st)-1)
					P("@8{@+8{@+8{@+;# 4 byte big-endian read");
					break;
				case 'l': /* little endian 4 byte read. */
					P("@@@@8{+8{+8{+;# 4 byte little-endian read");
					break;
				case '.': /* copy (dup) */
					push(pp, right, lp);
					break;
				case 'p': /* pop */
					pop(pp, 1, lp);
					break;
				case 's': /* swap (top two elements of the stack) */
					pop(pp, 2, lp);
					push(pp, right, lp);
					push(pp, left, lp);
					break;
				default:
					die("invalid operator", lp);
				}
			}
		}
	}

	/* Here on terminator or Ac==AcEnd. */
end:
	/* If SP>0 then there was some bad nesting going on - i.e. the brackets have
	 * not been closed.  fnoexec must be zero if SP is 0.
	 */
	if (SP > 0)
		die("unclosed ( )", line);
	assert(fnoexec == 0 || fnoexec == 3);
	if (fnoexec == 3)
		pp->fbreak = 1;
	return Ac;
}


/* Parse an expression and return numbers off the top of stack. */
static int need(parse_buf *pp, unsigned long arg[2],
		const unsigned char *line, int Ac, int AcEnd, int num) {
	int Acnew = parse_expression(pp, line, Ac, AcEnd);

	assert(num <= 2);
	if (pp->cstack < STACK_BASE+num)
		die("too few arguments", line+Ac);

	while (num > 0)
		arg[--num] = pp->stack[--(pp->cstack)];

	/* cancel a break at the top level. */
	pp->fbreak = 0;
	return Acnew;
}


/* Parse a string.  The string ends up in the buffer and is limited in
 * size to STR_MAX.  The API returns a null string for empty quoted
 * strings and for the unquoted case where there is only whitespace
 * in the rest of the command.  The result is the index of the first
 * character after the end of the command (*not* the end of the string.)
 */
static int string(unsigned char *buffer, const unsigned char *line, int Ac) {
	int start, end;

	while (isspace(line[Ac]) && line[Ac] != '\n') ++Ac;

	if (line[Ac] == '"' || line[Ac] == '\'') {
		const unsigned char quote = line[Ac];
		start = Ac;
		end = Ac+1;
		while (line[end] != 0 && line[end] != '\n' && line[end] != quote) ++end;
		if (line[end] != quote)
			die("unterminated quoted string", line+start);
		Ac = end+1;
		while (isspace(line[Ac]) && line[Ac] != '\n') ++Ac;
		if (line[Ac] != 0 && line[Ac] != ';' && line[Ac] != '\n')
			die("stuff on line after quoted string", line+start);
		++start;
	} else {
		start = Ac;
		while (line[Ac] != 0 && line[Ac] != ';' && line[Ac] != '\n') ++Ac;
		end = Ac;
	}

	end -= start;
	if (end >= STR_MAX)
		die("string too long", line+start);

	/* Copy out the string into the buffer and null terminate it. */
	memcpy(buffer, line+start, end);
	buffer[end] = 0;

	/* Skip over EOL, if present, and store the string pointer back. */
	if (line[Ac] != 0) ++Ac;
	return Ac;
}


/* Find the end of line, Ac always points to the start. */
static int eol(const unsigned char *line, int Ac) {
	unsigned char quote = 0;
	while (line[Ac] != '\n' && (line[Ac] != ';' || quote)) {
		if (line[Ac] == 0)
			return Ac;
		if (line[Ac] == '"' || line[Ac] == '\"') {
			if (quote == 0)
				quote = line[Ac];
			else if (quote == line[Ac])
				quote = 0;
		}
		++Ac;
	}
	return Ac+1;
}


/* Find a file given its name. */
static mtd_file *find_file(parse_buf *pp, const unsigned char *name) {
	int i;
	for (i=0; i<NUM_FILES; ++i) {
		if (pp->files[i].pname != 0 &&
			strcmp(name, pp->files[i].pname) == 0)
			return pp->files+i;
	}
	return 0;
}


/* Open a file for read or write. */
static mtd_file *open_file(parse_buf *pp, const unsigned char *name, int fwrite) {
	int i;
	for (i=0; i<NUM_FILES; ++i)
		if (pp->files[i].pname == 0)
			break;
	if (i >= NUM_FILES)
		die("no more files", name);
	open_mtd(pp->files+i, name, fwrite, pp->fverify);
	return pp->files+i;
}


/* Basic parse function.  Does all the work.  Simple line-by-line command
 * parser.  The input is a vector of strings (an argv), 'input' says where
 * it came from.
 */
static void parse(parse_buf *pp, int lines, const char **prog) {
	/* The program pointer is a line index Al and a character within the
	 * line Ac.  The exec stack just has those references (i.e. (Al,Ac)
	 * is a PC).
	 */
	int Al = 0, SP = 0, fnoexec = 0;
	struct stack {
		int Al, Ac;
	} stack[16];

	/* fnoexec has these values:
	 *    0: normal execution
	 *    1: within an if $($:$) and none of the tests have passed (so
	 *       nothing has been executed in this block.)
	 *    2: within an if and a test has passed (a previous block has
	 *       been executed.)
	 *    3: within an if and a break ($?) has succeeded, execute nothing
	 *       until *and including* the $) (i.e. do not evaluate the value
	 *       on that either.)
	 * This applies to nested if blocks too when the block is executable.
	 * If a block is nested within a non-executing environment the $(
	 * adds 3 to fnoexec.  The $) always subtracts 3 unless fnoexec is
	 * 0, 1, 2 or 3 thus the prior state is reliably restored.
	 */

	while (Al < lines) {
		int Ac = 0;
		const unsigned char *line = prog[Al];
		const int AcEnd = strlen(line);

		while (line[Ac]) {
			const unsigned char *lp = line+Ac;
			unsigned char ch = *lp;

			/* A command is two characters, except that ';' is end-of-line,
			 * skip these things until we see a command, then use the next
			 * two characters.  line[Ac] != 0 so the read of Ac+1 is safe.
			 */
			if (isspace(ch) || ch == ';') {
				++Ac;
			} else if ((ch != '$' && fnoexec) || ch == '#') {
				/* disabled execution and not a control flow command, or
				 * a comment.
				 */
				Ac = eol(line, Ac);
			} else switch ((ch << 8) + line[Ac+1]) {
				unsigned long arg[2];
				unsigned char buffer[STR_MAX];

				/* Control flow.  These commands have to explicitly check
				 * the fnoexec state because they manipulate it.
				 */
			#define CASE(l,r) case (((l)<<8)+(r))
			CASE('$','('): /* if */
				if (SP >= 16)
					die("exec stack overflow", lp);
				stack[SP].Al = Al;
				stack[SP++].Ac = Ac;
				if (fnoexec) {
					fnoexec += 3;
					goto noexec;
				}
				Ac = need(pp, arg, line, Ac+2, AcEnd, 1);
				fnoexec = arg[0] == 0;
				break;

			CASE('$',':'): /* elif */
				/* fnoexec is 1 if nothing has executed in this block yet,
				 * and if the block itself is executing.
				 */
				if (SP <= 0)
					goto underflow;
				if (fnoexec != 1) {
					/* If the previous block executed record this. */
					if (fnoexec == 0)
						fnoexec = 2;
					goto noexec;
				}
				Ac = need(pp, arg, line, Ac+2, AcEnd, 1);
				fnoexec = arg[0] == 0;
				break;

			CASE('$',')'): /* end+loop if */
				/* The stack must always be popped. */
				if (SP <= 0)
					goto underflow;
				--SP;
				/* If fnoexec>2 then this is a nested disabled block or, in
				 * the case of 3, a break.  In neither case is the expression
				 * evaluated.
				 */
				if (fnoexec > 2) {
					fnoexec -= 3;
					goto noexec;
				}
				fnoexec = 0;
				/* So make the loop test now - this may cause a branch back
				 * to the $( and that will push the stack again.
				 */
				Ac = need(pp, arg, line, Ac+2, AcEnd, 1);
				if (arg[0] != 0) {
					Al = stack[SP].Al;
					Ac = stack[SP].Ac;
					/* Do not ever forget this, because we may not exit the
					 * immediately enclosing loop and line is set up outside
					 * it!
					 */
					line = prog[Al];
				}
				break;

			CASE('$','?'): /* break */
				if (SP <= 0)
					goto underflow;
				if (fnoexec)
					goto noexec;
				Ac = need(pp, arg, line, Ac+2, AcEnd, 1);
				if (arg[0] != 0) {
					/* break: skip to the $) and do not do the test on
					 * that either.
					 */
					fnoexec = 3;
				}
				break;

			underflow:
				die("exec stack underflow", lp);
			noexec:
				/* Control flow no-exec case. */
				Ac = eol(line, Ac);
				break;

				/* Program termination */
			CASE('!','?'): /* exit if non-zero */
				Ac = need(pp, arg, line, Ac+2, AcEnd, 1);
				if (arg[0] != 0)
					quit(pp, arg[0]);
				break;

			CASE('!','!'): /* exit unconditionally */
				Ac = need(pp, arg, line, Ac+2, AcEnd, 1);
				quit(pp, arg[0]);
				break;

				/* Input/output */
			CASE('>','>'): /* write to (no argument reverts to stdout) */
				Ac = string(buffer, line, Ac+2);
				if (buffer[0] != 0) {
					mtd_file *pfile = find_file(pp, buffer);
					if (pfile == 0)
						pfile = open_file(pp, buffer, 1);
					else if (!pfile->fwrite)
						die("attempt to open a read file for write", buffer);
					pp->pto = pfile;
				} else
					pp->pto = 0;
				break;

			CASE('<','<'): /* read from */
				Ac = string(buffer, line, Ac+2);
				if (buffer[0] != 0) {
					mtd_file *pfile = find_file(pp, buffer);
					if (pfile == 0)
						pfile = open_file(pp, buffer, 0);
					pp->pfrom = pfile;
				} else
					pp->pfrom = 0;
				break;

			CASE('<','>'): /* close */
			CASE('>','<'): /* synonym of close */
				Ac = string(buffer, line, Ac+2);
				if (buffer[0] != 0) {
					mtd_file *pfile = find_file(pp, buffer);
					if (pfile == 0)
						die("no such file to close", buffer);

					if (pfile == pp->pfrom)
						pp->pfrom = 0;
					if (pfile == pp->pto)
						pp->pto = 0;
					close_mtd(pfile);
				} else
					die("<> (close) requires an argument", lp);
				break;

			CASE('>','='): /* set to pointer */
				Ac = need(pp, arg, line, Ac+2, AcEnd, 1);
				if (pp->pto == 0)
					die("no output file", lp);
				pp->pto->useroffset = arg[0];
				break;

			CASE('<','='): /* set from pointer */
				Ac = need(pp, arg, line, Ac+2, AcEnd, 1);
				if (pp->pfrom == 0)
					die("no input file", lp);
				pp->pfrom->useroffset = arg[0];
				break;

				/* writing to output */
			CASE('w','b'): /* bigendian number bytes */
				Ac = need(pp, arg, line, Ac+2, AcEnd, 2);
				switch (arg[1]) {
				case 4: outb(pp, arg[0] >> 24);
				case 3: outb(pp, arg[0] >> 16);
				case 2: outb(pp, arg[0] >>  8);
				case 1: outb(pp, arg[0]);
						break;
				default:die("byte count out of range", lp);
				}
				break;

			CASE('w','l'): /* little endian number bytes */
				Ac = need(pp, arg, line, Ac+2, AcEnd, 2);
				switch (arg[1]) {
				case 4: outb(pp, arg[0]); arg[0] >>= 8;
				case 3: outb(pp, arg[0]); arg[0] >>= 8;
				case 2: outb(pp, arg[0]); arg[0] >>= 8;
				case 1: outb(pp, arg[0]);
						break;
				default:die("byte count out of range", lp);
				}
				break;

			CASE('w','s'): /* write string */
				Ac = string(buffer, line, Ac+2);
				outputbytes(pp, buffer, strlen(buffer));
				break;

			CASE('f','b'): /* fill bytes */
				Ac = need(pp, arg, line, Ac+2, AcEnd, 2);

				/* The likely error is forgetting an argument, that may
				 * put the byte count into the fill value.
				 */
				if (arg[1] > 255)
					die("fill value out of range", lp);

				/* Now call fillbytes, arguments same order as memset, but
				 * the reverse from the command (fb number value).
				 */
				fillbytes(pp, arg[1], arg[0]);
				break;

			CASE('c','p'): /* copy bytes */
				Ac = need(pp, arg, line, Ac+2, AcEnd, 1);
				copybytes(pp, arg[0]);
				break;

				/* writing to stdout */
			CASE('p','r'): /* printf("%lu\n") */
				Ac = need(pp, arg, line, Ac+2, AcEnd, 1);
				printf("%lu\n", arg[0]);
			stdout_check:
				if (ferror(stdout))
					pdie("write error", "stdout");
				break;

			CASE('p','f'): /* printf(string) */
				Ac = string(buffer, line, Ac+2);
				/* This flushes the whole stack, so "printf;" can be useful
				 * under some circumstances!
				 */
					{
					unsigned long *stack = pp->stack + pp->cstack - 1;
					pp->cstack = STACK_BASE;
					printf(buffer, stack[0], stack[-1], stack[-2], stack[-3],
									stack[-4], stack[-5], stack[-6], stack[-7]);
					}
				goto stdout_check;

			CASE('p','n'): /* printf("\n") */
				Ac = need(pp, arg, line, Ac+2, AcEnd, 0);
				printf("\n");
				goto stdout_check;


			CASE('.','='): /* eval */
				Ac = need(pp, arg, line, Ac+2, AcEnd, 0);
				break;

			default:
				/* Assignment is handled here. */
				if (isupper(ch) && line[Ac+1] == '=') {
					/* Assignment. */
					Ac = need(pp, arg, line, Ac+2, AcEnd, 1);
					pp->variables[ch] = arg[0];
				} else
					die("unknown command", lp);
				break;
			}
		}

		/* end of line (line[Ac] is '\0'), move to the next line. */
		++Al;
	}

	/* If SP>0 then there was some bad nesting going on - i.e. the brackets have
	 * not been closed.  fnoexec must be zero if SP is 0.
	 */
	if (SP > 0)
		die("unclosed $( $)", "eof");
	assert(fnoexec == 0);
}

/* The command only understands two options, -v for verify and -h for
 * help.
 */
int main(int argc, const char **argv) {
	int i = 0;
	parse_buf p;

	/* the option must be the first argument. */
	if (argc < 2 || strcmp(argv[1], "-h") == 0) {
		fprintf(stderr, "%s: usage: %s ([-v] {comands} |-h [command])\n", argv[0], argv[0]);
#if HELP
		if (argc < 3) {
			fprintf(stderr, " options:\n"
							"  -v: do not write, just verify a previous write\n"
							"  -h: output this help\n"
							"  -h commands: output command help\n"
							"  -h <command>: output help for command <command>\n");
		} else {
			for (i=2; i<argc; ++i) {
				const unsigned char *p = argv[i];
				switch ((argv[i][0] << 8) + argv[i][1]) {
				CASE('a','d'):
					p = "Enter the keyword in [] contained after the command list\n"
						"for more information about those commands";
					break;
				CASE('c','o'):
					if (argv[i][2] != 'n')
						p = " commands are terminated by ';', newline or the end of input:\n"
						"  <command> {arguments} ;\n\n"
						" command: a two character command:       [additional info]\n"
						"  conditional execution: $( $: $? $)     [conditional]\n"
						"  program termination:   !? !!           [exit]\n"
						"  input/output control:  >> << <> >= <=  [io]\n"
						"  writing to the output: wb wl ws fb cp  [write]\n"
						"  writing to stdout:     pr pf pn        [messages]\n"
						"  assignment:            <C>= .=         [assign]\n"
						"  comment:               #\n\n"
						"  -h <command>: output the syntax of command <command>\n\n"
						" arguments: a string or a postfix numeric expression\n"
						"  -h string:   output the syntax of a string argument\n"
						"  -h number:   output the syntax of a numeric argument\n"
						"  -h operator: output a summary of the operators\n\n"
						" A command which starts with '#' is ignored (a comment).";
					else
						p = "conditional evalation\n"
						"  Conditional evalation has the general form:\n\n"
						"    $( cond; $? cond; $: cond; $) cond;  (command form)\n"
						"    cond(,  cond?,  [cond:,  [cond),     (operator from)\n\n"
						"  Conditional commands bracket other commands, conditional\n"
						"  operators bracket other numbers and operators in the expression\n"
						"  The conditions (cond) are intrepreted as boolean values, with 0\n"
						"  false and any other value true.  Notice that the numbers come off\n"
						"  the number stack so it is not necessary for them to be given with\n"
						"  the specific command or before the specifc operator but it can\n"
						"  be very confusing if this is not done.\n\n"
						"  The commands/operators behave exactly as the following ANSI C\n"
						"  syntax:\n\n"
						"    $( n       do if (n) {\n"
						"    $? n       if (n) break;\n"
						"    $: n       } else if (n) {\n"
						"    $) n       } while (n);\n\n"
						"  Thus a simple if/then/else sequence might be:\n\n"
						"    $( condition; $: 1; $) 0\n"
						"    condition( [1: [0)\n\n"
						"  And a simple do while loop:\n\n"
						"    $( 1; $) condition\n"
						"    1( [condition)\n\n"
						"  Notice that the operator syntax requires [cond: and [cond)";
					break;
				CASE('$','('): /* if */
					p = "conditional: $( condition;  do if (condition) {\n";
					break;
				CASE('$',':'): /* elif */
					p = "conditional: $( condition;  } else if (condition) {\n";
					break;
				CASE('$',')'): /* end+loop if */
					p = "conditional: $: condition;  } while (condition);\n";
					break;
				CASE('$','?'): /* break */
					p = "conditional: $: condition;  if (condition) break;\n";
					break;
				CASE('e','x'):
					p = "program termination commands:\n"
						"  !? and !! cause immediate termination of the program.\n"
						"  The currently opened files are closed (and flushed) on\n"
						"  termination and the program exits with the given code.\n"
						"  !? is condition - it only causes an exit if the code is\n"
						"  non zero.";
					break;
				CASE('!','?'): /* exit if non-zero */
					p = "exit: !? code;  if (code != 0) exit(code);\n";
					break;
				CASE('!','!'): /* exit unconditionally */
					p = "exit: !! code;  exit(code);\n";
					break;
				CASE('i','o'):
					p = "input/output control:\n"
						"  >> << allow files to be opened for write or read (respectively)\n"
						"  A file may be opened for both write and read, but in that case\n"
						"  the first open must be the write one.  Such a file has only one\n"
						"  position pointer.  Supplying an empty file name to the commands\n"
						"  causes the standard IO stream (stdout or stdin) to be used, but\n"
						"  the file remains open.  A file may be reselected by repeating\n"
						"  the open command.  The position pointer will not have changed.\n\n"
						"  <> closes a file.  If it is the current input or output then the\n"
						"  input or output, as appropriate, is redirected to the standard\n"
						"  streams.\n\n"
						"  <= >= set the input (from) or output (to) pointer.  The pointer is\n"
						"  changed on the current input or output device and is a property of\n"
						"  that device, not a global setting.";
					break;
				CASE('>','>'): /* write to (no argument reverts to stdout) */
					p = "io: >> file;  select file as the current output device\n"
						"    >> ;      select stdout as the current output device\n";
					break;
				CASE('<','<'): /* read from */
					p = "io: << file;  select file as the current input device\n"
						"    << ;      select stdin as the current input device\n";
					break;
				CASE('<','>'): /* close */
					p = "io: <> file;  close file\n";
					break;
				CASE('>','<'): /* synonym of close */
					p = "io: <> file;  close file\n";
					break;
				CASE('>','='): /* set to pointer */
					p = "io: >= offset;  set the 'to' pointer: output device file pointer\n";
					break;
				CASE('<','='): /* set from pointer */
					p = "io: <= offset;  set the 'from' pointer: input device file pointer\n";
					break;
				CASE('w','r'):
					p = "writing to the output:\n"
						"  wb, wl, ws, fb and cp write bytes to the current output device at\n"
						"  the current output position (which may be set using >=.)\n\n"
						"  See the individual command descriptions for more information.";
					break;
				CASE('w','b'): /* bigendian number bytes */
					p = "write: wb number bytes; write number in bytes big endian bytes\n";
					break;
				CASE('w','l'): /* little endian number bytes */
					p = "write: wl number bytes; write number in bytes little endian bytes\n";
					break;
				CASE('w','s'): /* write string */
					p = "write: wl string;       write string\n";
					break;
				CASE('f','b'): /* fill bytes */
					p = "write: fb number byte;  write number bytes of value 'byte'\n";
					break;
				CASE('c','p'): /* copy bytes */
					p = "write: cp number;       copy number bytes from input to output\n";
					break;
				CASE('m','e'):
					p = "writing to stdout:\n"
						"  pr pf and pn allow output to stdout ignoring the current output\n"
						"  device.  pf uses a C printf(3) format string and no checking is\n"
						"  made on the validity or number of parameters.  The program will\n"
						"  crash if a pointer format (like %s) is used.  This is by design.\n"
						"  Use of \\ escapes within the string will probably not produce the\n"
						"  expected result.  The only way to output a newline is via the\n"
						"  separate pn command.";
					break;
				CASE('p','r'): /* printf("%lu\n") */
					p = "message: pr number;   printf(\"%lu\\n\", number);\n";
					break;
				CASE('p','f'): /* printf(string) */
					p = "message: pf string;   printf(string, 1, 2, 3, 4, 5, 6, 7, 8)\n"
						"                      uses string as a format string for the\n"
						"                      top (up to) 8 arguments on the stack\n"
						"                      Empties the stack!\n";
					break;
				CASE('p','n'): /* printf("\n") */
					p = "message: pn;          prints a newline (printf(\"\\n\");)\n";
					break;
				CASE('.','='):
					p = ".= [number]\n"
						"  The number is evaluated and pushed to the stack";
				CASE('a','s'):
					p = "<C>= [number] (<C> is an upper case character in the range A-Z)\n"
						"  The number is assigned to the variable <C>.";
					break;
				CASE('s','t'):
					p = "string format\n"
						"  A string is either quoted or unquoted.  An unquoted string is\n"
						"  the rest of the line, terminated by ';' or newline (or the end\n"
						"  of the command).  A quoted string is enclosed in either single\n"
						"  or double quotes (which are removed) and must be the only thing\n"
						"  on the line apart from white space.";
					break;
				CASE('n','u'):
					p = "number format\n"
						"  A number is a post-fix expression consisting of numeric values,\n"
						"  variable values and operators.\n"
						"  A numeric value is anything starting with a digit.  0x prefixes a\n"
						"  hexadecimal value, 0 prefixes an octal value otherwise the value\n"
						"  is interpreted as decimal.\n"
						"  Variables are single upper case characters in the range A-Z,\n"
						"  thus 26 variables are available.\n"
						"  Numeric values and variables are pushed onto a stack which can\n"
						"  store up to 248 numbers.\n"
						"  Operators are single characters not identified as numeric values\n"
						"  or variables.  They operate on the stack combining elements.\n"
						"  Use -h operators for more information.";
					break;
				CASE('o','p'):
					p = "operators\n"
						"  The following operators are defined.  Operators take one or\n"
						"  two elements from the stack and push back up to two elements\n"
						"  The conditional operators (:?) are special, see the description\n"
						"  under -h conditionals for more information.  (Conditional\n"
						"  operators and the conditional commands behave identically.)\n\n"
						"  In the following descriptions 'left' is the last-but-one\n"
						"  number on the stack and 'right' is the last number pushed.\n"
						"  'new' is a new number pushed on to the top of the stack.\n\n"
						" arithmetic operators:\n"
						"     *: new := left * right        (multiplication)\n"
						"     +: new := left + right\n"
						"     -: new := left - right\n"
						"     /: new := left / right        (division)\n"
						"     %: new := left % right        (i.e. C style modulus)\n"
						"     <: new := left < right\n"
						"     >: new := left > right\n"
						"     =: new := left == right       (i.e. equality)\n"
						"     |: new := left | right        (bitwise or)\n"
						"     &: new := left | right        (bitwise and)\n"
						"     ^: new := left | right        (bitwise xor)\n"
						"     ~: new := ~right              (ones complement)\n"
						"     !: new := !right              (logical complement - right == 0)\n"
						"     {: new := left << right       (bitwise shift left by right bits)\n"
						"     }: new := left << right       (bitwise shift right by right bits)\n"
						"     r: new := left ROR right      (bitwise rotate right by right bits)\n"
						"     e: new := left SXT right      (right least significant bits of\n"
						"                                    left are sign extended to 32 bits)\n"
						"     m: new := left MASK right     (right least significant bits of left\n"
						"                                    are masked, upper bits become 0)\n"
						" operators to read bytes:\n"
						"     @: new := input-byte          (one byte is read from current input)\n"
						"     b: new := input-big-endian    (4 big endian bytes are read)\n"
						"     l: new := input-little-endian (4 little endian bytes)\n"
						" enquiry operators:\n"
						"     $: the size of the current input device\n"
						"     f: the current 'from' offset\n"
						"     #: the size of the current output device\n"
						"     t: the current 'to' offset\n"
						"     d: the full device number of the current input device\n"
						"        this returns the number of the underlying device for a file\n"
						" operators to manipulate the stack:\n"
						"     .: new := right,right         (i.e. right is duplicated)\n"
						"     p: pop - right is removed from the stack\n"
						"     s: swap - right and left are swapped on the stack\n"
						" conditional operators:\n"
						"     ( exec := right         (execution is stopped if right is 0)\n"
						"     : exec := else if right (execution is resumed or stopped)\n"
						"     ? if right break        (break out of if/loop if right)\n"
						"     ) loop if right         (end of current if/loop)";
					break;
				default:
					fprintf(stderr, "command '%s' not recognised\n", p);
					p = 0;
				}

				if (p != 0)
					fprintf(stderr, "%s\n", p);
			}
		}
#endif
		exit(1);
	} else if (strcmp(argv[1], "-v") == 0)
		i = 1;
		
	init_parse(&p, i);
	++i;
	parse(&p, argc-i, argv+i);
	quit(&p, 0);
}