/* tlgu: Translates TLG (D) text files to Unicode text
 *
 * Copyright (C) 2004, 2005 Dimitri Marinakis
 *
 * Licensed under the terms of the GNU General Public License.
 * ABSOLUTELY NO WARRANTY.
 * See the file `COPYING' in this directory.
 *
 * Usage:
 *	 tlgu [options] infile outfile
 *
 * Options:
 *	-r -- primarily Roman text; default betastate = ROMAN, reset on every ID code
 *	-vwxyz -- reference citations are printed in the form xxx.xxx...xxx
 *	-(a)b(cd) -- description citations are printed
 *	-B -- output blank space (tab) after each new line (beginning of line)
 *	-p -- pagination is observed, otherwise book lines are printed continuously
 *	-C -- citation debug information is printed
 *	-S -- special code debug information is printed
 *	-T -- bracket debug information is printed
 *	-V -- processing debug information is printed
 *	-W -- multiple output files, one for each work
 *
 * Returns: exit code 1 if unsuccesful
 *
 * Make: gcc tlgu.c -o tlgu
 *
 * History: This is a re-write of a DOS program (tlgft.asm) written several
 * years ago to translate Hellenic texts distributed on the TLG CD-ROM from
 * "beta code" to something readable, editable and printable.
 *
 * Pointers / References:
 *   TLG Project - www.tlg.uci.edu
 *   PHI CD ROM Format Description, Packard Humanities Institute, 19 April 1992
 *   Beta code reference - Text versions: tlgbeta.txt or tlgcode.txt
 *       a .pdf version is also available.
 *   ID locator reference - Text version tlgcodes.txt
 *
 * dm: 14-Jun-2001 ELOT-928
 *     14-Jun-2004 Unicode
 *     26-Jun-2004 Command-line options
 *     26-Feb-2005 Output file separation (-W option)
 *     06-Mar-2005 Latin accent characters added (without parentheses)
 *     21-Nov-2005 Added -Z -e and imported into sword-tools SVN repository
 */

#include <stdio.h>
#include <string.h>
#include "tlgu.h"
#include "tlgcodes.h"

/****************** PROTOTYPES FROM THE TOP DOWN *******************/

int tlgu (char * input_file, char * output_file);
void output_utf(int ucode);
void output_string(char *outstr);
int process_beta (int input_count);
void beta_code(int input_count);
int id_code(int input_count);
void store_accents(unsigned char bufferchar);
const char *resolve_cite_format(const char *cformat);

/****************** PROGRAM VERSION INFORMATION  *******************/
char *prog_version="1.2";

/****************** COMMAND LINE OPTIONS  **************************/
int opt_roman = 0;
int opt_page = 0;
int opt_blank = 0;
int opt_acit = 0;
int opt_bcit = 0;
int opt_ccit = 0;
int opt_dcit = 0;
int opt_cit_id = 0; /* combines a, b, c */
int opt_vcit = 0;
int opt_wcit = 0;
int opt_xcit = 0;
int opt_ycit = 0;
int opt_cprefix = 0;
char cformat[253];
int opt_ecit_blank = 0;
char ecite[253];
int opt_zcit = 0;
int opt_verbose = 0;
int opt_debug_bracket = 0;
int opt_debug_cit = 0;
int opt_debug_special = 0;
int opt_multiple = 0;

/****************** GLOBAL VARIABLES *******************************/

int iptr = 0;	/* input buffer pointer, reset before every read */
int optr = 0;	/* output buffer pointer, reset after every write */
unsigned char input_buffer[INRECSIZE];
unsigned char output_buffer[OUTRECSIZE];
#define MAXFILELEN 256

/************ GLOBAL BETA CODE PROCESSING VARIABLES **************/

unsigned int outcode;
int betastate;	/* translation state machine */
int previous_state;	/* needed for symbol translations */
int start_new_line = 0;	/* needed for symbol translations */
int book_change = 0;	/* needed for symbol translations */
int accents;	/* holds accent combinations */
char *accented_chars = "AEHIOUWR";
char *accent_chars = ")(+/\\=|";
char *latin_accent_chars = "+/\\=|";
char *escape_codes = "$&%\"@#^[]<>{}";
char *punctuation_codes = " .,:;_\"%{}$&";	/* used by which_sigma */
char previous_bcit[52][32];	/* holds previous work (book) citation */

/****************** GLOBAL DESCRIPTOR  VARIABLES *****************/

/*
	Space is reserved for descriptive data as follows:

	citations, binary component -- z, y, x, w, v, n (1 to 16383)
	citations, ascii component -- a-z (1 to 15 characters + null, only a-d, n, v-z are actually used)
	descriptors, binary component -- a-z (1 to 16383)
	descriptors, ascii component -- a-z (1 to 31 characters + null)

	Citations ---
	a - author citation
	b - work citation
	c - preferred abbreviation for the work
	d - preferred abbreviation for the author

	n - if present signifies a document within a work
		when it changes, v-z are nulled but are then independent
	if n is not present, a change in an upper level nulls out the rest

	v-z hierarchical citation levels, high to low

	v
	w
	x - (chapter)
	y - (verse) (book)
	z - line

	Descriptions ---

	z - comment sequence number within a work

	In the common data structures below, citations will hold the first 26 positions (0-25)
	while descriptors will hold the next 26 positions.
*/
int icitation[52];
char citation[52][32];
int id_level;	/* holds translated current id level as an index to ID arrays */
int id_char;	/* holds the pointer for the ascii part of the ID arrays */
int id_command;	/* holds the current instruction for ID handling */
int id_process;	/* if non-zero, command must be processed */


/****************** HANDLE ARGUMENTS AND SYNTAX *******************/

void usage_info(void)
{
	printf("\ntlgu: TLG beta code file to Unicode translator ver. %s\n", prog_version);
	printf("\ntlgu: Copyright (C) 2004, 2005 Dimitri Marinakis");
	printf("\ntlgu: This program is free software; you are encouraged to redistribute it under");
	printf("\ntlgu: the terms of the GNU General Public License.\n");
	printf("\ntlgu: This program comes with ABSOLUTELY NO WARRANTY. See the GNU General Public");
	printf("\ntlgu: License (e.g. in the file named `COPYING') for more details.\n");
	printf("\ntlgu: Syntax: [-options...] tlgu beta_code_file text_file\n\n");
	printf("tlgu: -r -- primarily Roman text; default betastate = ROMAN, reset on every ID code\n");
	printf("tlgu: -v -w -x -y -z -- work reference citations are printed in the form xxx.xxx...xxx\n");
	printf("tlgu: -Z <custom_cite_format_prefix> -- use special codes %%v %%w %%y %%z in string\n");
	printf("tlgu: -e <custom_blank_cite_seg_string> -- e.g. \"[NONE]\" instead of default \"\"\n");
	printf("tlgu: -b -- books are preceded by a page feed and description citations are printed\n");
	printf("tlgu: -p -- pagination is observed, otherwise book lines are printed continuously\n");
	printf("tlgu: -B -- output blank space (tab) at the beginning of each line\n");
	printf("tlgu: -C -- citation debug information is printed\n");
	printf("tlgu: -S -- special code debug information is printed\n");
 	printf("tlgu: -V -- processing debug information is printed\n");
	printf("tlgu: -W -- multiple output files, one for each work (book)\n\n");
}

main(int argc, char * argv[])
{
	unsigned char ucc;	/* test variable */
	int idx;

	if (sizeof(ucc) != 1) {
		printf("\ntlgu: I need 8-bit characters to work\n");
		exit(1);
	}

	if (argc < 3) {
		usage_info();
		exit(1);
	}

	--argc ;
	++argv ;

	while(argc > 2 && argv[0][0] == '-') {
		switch(argv[0][1]) {
			case 'W':
				opt_multiple =1;
				break ;
			case 'V':
				opt_verbose =1;
				break ;
			case 'S':
				opt_debug_special = 1;
				break ;
			case 'T':
				opt_debug_bracket = 1;
				break ;
			case 'C':
				opt_debug_cit = 1;
				break ;
			case 'B':
				opt_blank = 1;
				break ;
			case 'p':
				opt_page = 1;
				break ;
			case 'r':
				opt_roman = 1;
				break ;
			case 'a':
				opt_acit = 1;
				opt_cit_id =1;
				break ;
			case 'b':
				opt_bcit = 1;
				opt_cit_id =1;
				break ;
			case 'c':
				opt_ccit = 1;
				opt_cit_id =1;
				break ;
			case 'd':
				opt_dcit = 1;
				opt_cit_id =1;
				break ;
			case 'v':
				opt_vcit = 1;
				break ;
			case 'w':
				opt_wcit = 1;
				break ;
			case 'x':
				opt_xcit = 1;
				break;
			case 'y':
				opt_ycit = 1;
				break ;
			case 'z':
				opt_zcit = 1;
				break;
			case 'e':
				opt_ecit_blank = 1;
				strcpy(ecite, argv[1]);
				argc-- ;
				argv++ ;
				break;
			case 'Z':
				opt_cprefix = 1;
				strcpy(cformat, argv[1]);
				argc-- ;
				argv++ ;
				break;
			default:
				usage_info() ;
				exit(0) ;
		}
	argc-- ;
	argv++ ;
	}

	return tlgu(argv[0], argv[1]);
}


/****************** FILE READ-WRITE LOOP **************************/

int tlgu(char *input_file, char *output_file)
{
	int i;      /* counter */
	int j;      /* counter */
	int infile; /* input file descriptor */
	int outfile;/* output file descriptor */

	int icnt;   /* input file bytes read in input buffer */
	int ocnt;   /* output file bytes written */
	int bytes_to_process;	/* bytes read minus bytes already processed */

	int wehaveinput;    /* flag for while */
	int beta_return;    /* process beta return code */

	char new_file[256];
	struct stat filestat;

	/* Open input and output files
	 */
	infile = open(input_file, O_RDONLY);
	if (infile < 0) {
		perror("tlgu input file open");
		return(1);
	} else {
		if (strlen(output_file) < MAXFILELEN-5) {
			strcpy(new_file, output_file);
		} else {
			printf("\ntlgu output filename too long - exiting\n");
			return(1);
		}
		outfile = open(new_file, O_WRONLY | O_CREAT | O_TRUNC);
		if (outfile < 0) {
			perror("tlgu output file create");
			close(infile);
			return(1);
		}
	}

	/* Initialize citation
	 * and descriptor indicators
	 */
	for (i = 0; i < 52; i++) {
		icitation[i] = 0;
		for (j = 0; j < 32; j++) {
			citation[i][j]=0;
		}
	}

	/* Initialize beta processing defaults
	 * e.g. The TLG Canon needs ROMAN as default
	 * Hellenic should be reset at each ID CODE
	 */
	if (opt_roman) betastate = ROMAN;
	else betastate = HELLENIC;

	/*  Read, process and write file blocks,
	 *  Optionally create one file per book (-W)
	 *  Change file mode (equivalent to chmod 644 output_file),
	 *  and return.
	 *  Note:  Local deblocking usually yields higher speeds
	 */
	wehaveinput = 1;
	while (wehaveinput) {
		/* Read and process beta code in input_buffer */
		icnt = read(infile, input_buffer, sizeof(input_buffer));
		if (icnt == 0) wehaveinput = 0;

		iptr = 0;
		while ((icnt > 0) && (iptr < icnt)) {
			bytes_to_process = icnt - iptr;
			beta_return = process_beta(bytes_to_process);

			/* Write processed data and reset output buffer pointer */
			if (optr > 0) {
				ocnt = write(outfile, output_buffer, optr);
				optr = 0;
				if (ocnt < 0) {
					perror("tlgu output file write");
					wehaveinput = 0;
				}
			} else if (beta_return != -2) {  /* no more bytes to write, no book change request */
				if (opt_verbose) printf("\ntlgu: no more bytes to write");
				wehaveinput = 0;    /* signal no more input */
			}
			if (beta_return == -2) {
			 	/* book change request, close current file and open a new one */
				if (opt_verbose) printf("\ntlgu: book change request: %s", previous_bcit[1]);
				if (close(outfile)) return(1);
				if (chmod(new_file, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)) return(1);

				/* request file information and delete zero-length files
				 */
				stat(new_file, &filestat);
				if (filestat.st_size == 0) unlink(new_file);

				sprintf(new_file, "%s-%s.txt", output_file, previous_bcit[1]);
				outfile = open(new_file, O_WRONLY | O_CREAT | O_TRUNC);
				if (outfile < 0) {
					perror("tlgu: new_file create");
					close(infile);
					return(1);
				}


			}
		}
	}

	/* Close input and output files,
	 * make output file readable
	 */
	close(infile);

	if (close(outfile)) {
		perror("tlgu output file close");
		return(1);
	}
	if (chmod(new_file, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)) {
		perror("tlgu output file chmod");
		return(1);
	}
	if (opt_verbose) printf("\ntlgu: processing complete\n");
	return(0);
}

/****************** PROCESSING *************************************/

/* process_beta:
 * Processes <input_count> bytes in <input_buffer>
 * Returns: -1 for EOF, -2 for book change
 * Changes: iptr
 */
int process_beta (int input_count)
{
	unsigned char inchar;
	unsigned int outcode;
	int processing;
	int iptr_max;       /* holds the calculated maximum input pointer value */
	int return_code;    /* id_code and beta_code bytes written; error if negative */
	char outstring[511];
	char nstring[253];

	return_code = 0;
	/* A beta code stream includes two kinds of data:
	 *   ID data - always has the high bit set.
	 *   Text data - always has the high bit reset.
	 */
	processing = 1;
	iptr_max = iptr + input_count;
	if (opt_verbose) printf("\n\ntlgu: process_beta - %d bytes, iptr = %4.4x, iptr_max = %4.4x", input_count, iptr, iptr_max);
	while (processing) {
		if ((iptr < INRECSIZE) && (iptr < iptr_max)) {
			inchar = input_buffer[iptr++];
			if (optr < OUTRECSIZE) {
				if (inchar == 0) {
					/* do nothing for null characters */
				} else if (inchar > 0x7F) {
					/* ID data - decrement input pointer before processing */
					--iptr;

					/* Reset beta decoding state if roman option specified */
					if (opt_roman) betastate = ROMAN;

					/* Process ID code */
					return_code = id_code(input_count);
					if (return_code == -1) {
						if (opt_verbose) printf("\ntlgu: EOF while processing id code");
						processing = 0;
					} else if (return_code == -2) {
						if (opt_verbose) printf("\ntlgu: book change request");
						processing = 0;
					}
					start_new_line = 1;
				} else {
					/* text data < 0x80 - decrement input pointer before processing */
					--iptr;
					if (start_new_line) {
								/* Write info on (book) citation change */
								if (book_change) {
									if (opt_cit_id) {
										sprintf(outstring, "\n\f[%s]  ", citation[0]);
										output_string(outstring);
										sprintf(outstring, "[%s]  ", citation[1]);
										output_string(outstring);
										sprintf(outstring, "[%s]  ", citation[2]);
										output_string(outstring);
										sprintf(outstring, "[%s]\n", citation[3]);
										output_string(outstring);
									}
									book_change = 0;
								}
								sprintf(outstring, "\n");
								if (opt_blank)
									strcat(outstring, "\t");
								else if (opt_cprefix) {
									strcat(outstring, resolve_cite_format(cformat));
								}
								else if (opt_vcit || opt_wcit || opt_xcit || opt_ycit || opt_zcit) {
									if (opt_vcit) {
										if (icitation[21] == 0) sprintf(nstring, "%s.",citation[21]);
										else sprintf(nstring, "%d%s.", icitation[21], citation[21]);
										if ((opt_ecit_blank) && (!*nstring)) strcpy(nstring, ecite);
										strcat(outstring, nstring);
									}
									if (opt_wcit) {
										if (icitation[22] == 0) sprintf(nstring, "%s.",citation[22]);
										else sprintf(nstring, "%d%s.", icitation[22], citation[22]);
										if ((opt_ecit_blank) && (!*nstring)) strcpy(nstring, ecite);
										strcat(outstring, nstring);
									}
									if (opt_xcit) {
										if (icitation[23] == 0) sprintf(nstring, "%s.",citation[23]);
										else sprintf(nstring, "%d%s.", icitation[23], citation[23]);
										if ((opt_ecit_blank) && (!*nstring)) strcpy(nstring, ecite);
										strcat(outstring, nstring);
									}
									if (opt_ycit) {
										if (icitation[24] == 0) sprintf(nstring, "%s.",citation[24]);
										else sprintf(nstring, "%d%s.", icitation[24], citation[24]);
										if ((opt_ecit_blank) && (!*nstring)) strcpy(nstring, ecite);
										strcat(outstring, nstring);
									}
									if (opt_zcit) {
										if (icitation[25] == 0) sprintf(nstring, "%s.",citation[25]);
										else sprintf(nstring, "%d%s", icitation[25], citation[25]);
										if ((opt_ecit_blank) && (!*nstring)) strcpy(nstring, ecite);
										strcat(outstring, nstring);
									}
									/* Separate text from citation using a tab character */
									strcat(outstring, "\t");
								}
								if (input_buffer[iptr] < 0x80) {
									/* Print only if not followed by another ID byte */
									output_string(outstring);
								}
						start_new_line = 0;
						if (opt_roman) betastate = ROMAN;
						else betastate = HELLENIC;
					}
					beta_code(input_count);
				}
			} else {
				/* Output size is greater than input -- intermediate write */
				printf("\ntlgu: FIXME -- DATA LOSS: ERROR output size iptr - %x optr - %x", iptr, optr);
				processing = 0;
			}
		} else {
			/* Finished processing all input */
			processing = 0;
		}
	} /* end while processing*/

	if (opt_verbose) printf("\ntlgu: iptr - %4.4x, optr - %4.4x ", iptr, optr);
	return return_code;
}
/****************** LIBRARY FUNCTIONS ******************************/
/* get_acents:
 * gets accents in <accents>
 * Returns: number of accents found or zero
 * Changes: accents, iptr
 */
int get_accents(void)
{
	unsigned char bufferchar;
	int processing = 1;
	int number_of_accents = 0;

	accents = 0;

	while (processing) {
		if (iptr < INRECSIZE) {
			bufferchar = input_buffer[iptr++];
			if (betastate == ROMAN) {
				if (strchr(latin_accent_chars, bufferchar)) {
					store_accents(bufferchar);
					number_of_accents++;
				} else {
					--iptr;
					processing = 0;
				}
			} else if (strchr(accent_chars, bufferchar)) {
					store_accents(bufferchar);
					number_of_accents++;
				} else {
					--iptr;
					processing = 0;
				}
		} else {
			processing = 0;
		}
	}
	return number_of_accents;
}

/* store_accents:
 * Stores accent character passed as a parameter to <accents>
 * 0 00 00 --- 0 00 00 no accent
 * |  |  |
 * |  |   ---- 01 psili, 10 dasia, 11 dialytika
 * |   ------- 01 varia, 10 oxia,  11 perispomeni
 * -----------  1 ypogegrammeni
 * Changes: accents
 * Caveat: currently only ORs new accent... expects an all-zero accent variable
 */
void store_accents(unsigned char bufferchar)
{
	switch (bufferchar)
	{
		case ')':
			accents = accents | 1;
			break;
		case '(':
			accents = accents | 2;
			break;
		case '+':
			accents = accents | 3;
			break;
		case '\\':
			accents = accents | 4;
			break;
		case '/':
			accents = accents | 8;
			break;
		case '=':
			accents = accents | 0xc;
			break;
		case '|':
			accents = accents | 0x10;
			break;
		default:
			break;
	}
	accents &= 0x1f;
}

/* output_accents:
 * Input: <accents>
 * 0 00 00 --- 0 00 00 no accent
 * |  |  |
 * |  |   ---- 01 psili, 10 dasia, 11 dialytika
 * |   ------- 01 varia, 10 oxia,  11 perispomeni
 * -----------  1 ypogegrammeni
 * Changes: optr (output_utf)
 */
void output_accents(void)
{
	int paccents;

	paccents = accents & 3;
	if (paccents == 1)
		output_utf(PSILI);
	else if (paccents == 2)
		output_utf(DASIA);
	else if (paccents == 3)
		output_utf(DIALYTIKA);

	paccents = (accents & 0xc) >> 2;
	if (paccents == 1)
		output_utf(VARIA);
	else if (paccents == 2)
		output_utf(OXIA);
	else if (paccents == 3) {
		if (betastate == ROMAN)
			output_utf(CARET);
		else
			output_utf(PERISPOMENI);
	}
	paccents = accents & 0x10;
	if (paccents)
		output_utf(YPOGEGRAMMENI);
}


/* getnum:
 * Collects a non-zero number from the current <input_buffer> position.
 * Returns: an integer or zero if no number found, -1 on end of buffer
 * Changes: iptr
 */
 int getnum(void)
{
	#define MAXNUMBERS 32
	unsigned char bufferchar;
	unsigned char modnumber[MAXNUMBERS];	/* symbol or font modifier number string */
	int imodnumber = 0;	/* index to modnumber */
	int convnumber = 0;	/* converted modnumber string */
	int processing = 1;

	modnumber[0] = 0;

	while (processing) {
		if ( (iptr < INRECSIZE) && (imodnumber < MAXNUMBERS) ) {
			bufferchar = input_buffer[iptr++];
			if (isdigit(bufferchar)) {
				modnumber[imodnumber++] = bufferchar;
			} else {
				--iptr;
				modnumber[imodnumber] = 0;
				sscanf(modnumber, "%d", &convnumber);
				processing = 0;
			}
		} else {
			convnumber = -1;
			processing = 0;
		}
	}
	if (convnumber < 0) perror("did not complete number\n");
	return convnumber;
}

/* output_utf:
 * Converts the input code into a UTF-8 byte sequence in output_buffer
 * Changes: optr, output_buffer
 */
void output_utf(int ucode)
{
	if ((optr+3) > OUTRECSIZE) {
		perror("optr out of range");
	} else if (ucode == 0){
		/* do nothing */
	} else if (ucode < 0x80) {
		output_buffer[optr++] = ucode;
	} else if (ucode < 0x800) {
		output_buffer[optr++] = (ucode >> 6) | 0xc0;
		output_buffer[optr++] = (ucode & 0x3f) | 0x80;
	} else if (ucode <= 0xffff) {
		output_buffer[optr++] = ((ucode & 0xf000) >> 12) | 0xe0;
		output_buffer[optr++] = ((ucode & 0x0fc0) >>  6) | 0x80;
		output_buffer[optr++] = (ucode & 0x3f) | 0x80;
	} else {
		/* higher unicodes are ignored */
	}
}

/* output_string:
 * Calls output_utf to write a string in <output_buffer>
 * Returns: the number of bytes written
 * Changes: optr, output_buffer
 */
void output_string(char *outstr)
{
	int nextchar;
	int cnt;

	for (cnt = 0; cnt < strlen(outstr); cnt++) {
		output_utf(outstr[cnt]);
	}
}

/* handle_escape_codes:
 * Formatting and character output based on escape codes: $&%"@#^[]<>{}
 * Input: escape code, optional number
 * Changes: optr, output_buffer
 */
void handle_escape_codes(unsigned char beta, int number)
{
	int temp = 0;

	switch (beta)
	{
		case '$':
			betastate = HELLENIC;
			accents = 0;
			break;
		case '&':
			betastate = ROMAN;
			accents = 0;
			break;
		case '%':
			if (opt_debug_special) printf("%%%d -- %s %d.%d.%d\n", number, citation[1], icitation[23], icitation[24], icitation[25]);
			if (number < MAX_PUNCTUATION)
				output_utf(punctuation[number]);
			break;
		case '\"':
			if (opt_debug_special) printf("\"%d -- %s %d.%d.%d\n", number, citation[1], icitation[23], icitation[24], icitation[25]);
			if (number < MAX_QUOTATION) {
				if (quotation_open[number]) {
					output_utf(quotation_close_symbol[number]);
					quotation_open[number] = 0;
				} else {
					output_utf(quotation_open_symbol[number]);
					quotation_open[number] = 1;
				}
			}
			break;
		case '@':
			/* FIXME: If citations are active, paging should be disabled */
			if (opt_debug_special) printf("@%d -- %s %d.%d.%d\n", number, citation[1], icitation[23], icitation[24], icitation[25]);
			/* Page formats -- FIXME: incomplete */
			if (number == 0) {
				output_utf(0x20);
				output_utf(0x20);
			} else if (number == 1) {
				if (opt_page) output_utf(0xc);
//FIXME: reinstate				else output_utf(0xa);
			} //fixme: reinstate else output_utf(0xa);
			break;
		case '#':
			if (opt_debug_special) printf("#%d -- %s %d.%d.%d\n", number, citation[1], icitation[23], icitation[24], icitation[25]);
			if (number < MAX_TEXT_SYMBOLS) {
				output_utf(text_symbols[number]);
			}
			break;
		case '^':
			/* quarter-spaces: will output at least one space */
			if (number > 0) temp = number / 4;
			while (temp >= 0) {
				output_utf(0x20);
				temp--;
			}
			break;
		case '[':
			if (opt_debug_bracket) printf("[%d -- %s %d.%d.%d\n", number, citation[1], icitation[23], icitation[24], icitation[25]);
			if (number < MAX_BRACKET) {
				output_utf(bracket_open_symbol[number]);
			}
			break;
		case ']':
			if (opt_debug_bracket) printf("]%d -- %s %d.%d.%d\n", number, citation[1], icitation[23], icitation[24], icitation[25]);
			if (number < MAX_BRACKET) {
				output_utf(bracket_close_symbol[number]);
			}
			break;
		case '<':
			if (opt_debug_bracket) printf("<%d -- %s %d.%d.%d\n", number, citation[1], icitation[23], icitation[24], icitation[25]);
			if (number < MAX_QUASI_BRACKET) {
				output_utf(quasi_bracket_open_symbol[number]);
			}
			break;
		case '>':
			if (opt_debug_bracket) printf(">%d -- %s %d.%d.%d\n", number, citation[1], icitation[23], icitation[24], icitation[25]);
			if (number < MAX_QUASI_BRACKET) {
				output_utf(quasi_bracket_close_symbol[number]);
			}
			break;
		case '{':
			if (opt_debug_bracket) printf("{%d -- %s %d.%d.%d\n", number, citation[1], icitation[23], icitation[24], icitation[25]);
			if (number < MAX_NON_TEXT) {
				output_utf(non_text_open_symbol[number]);

			}
			break;
		case '}':
			if (opt_debug_bracket) printf("{%d -- %s %d.%d.%d\n", number, citation[1], icitation[23], icitation[24], icitation[25]);
			if (number < MAX_NON_TEXT) {
				output_utf(non_text_close_symbol[number]);
			}
			break;
		default:
			break;
	}
}

/* which_sigma:
 * Tries to decide on which sigma form to use.
 * Input: index of input_buffer (iptr) after the sigma
 * Returns: output character code
 */
int which_sigma(int nextptr)
{
	int scanning;
	int nextcode;
	/* If the next character is a hyphen, it is a medial sigma
	 * Otherwise, a few characters are examined in the input buffer:
	 * if an alphabetic character is found before we hit a space, or
	 * other punctuation character, it is a medial sigma
	 * otherwise it is a final sigma (there is one exception in 4085 - POS(.))
	 */
	if (input_buffer[iptr] == '-')
		return(SIGMEDIAL);
	else {
		scanning = 10;
		while(scanning) {
			nextcode = input_buffer[nextptr++];
			if (isalpha(nextcode))
				return(SIGMEDIAL);
			if (nextcode > 0x7f)
				return(SIGFINAL);
			if (strchr(punctuation_codes, nextcode))
				return(SIGFINAL);
			scanning--;
		}
		return(SIGMEDIAL);
	}
}

/* beta_code:
 * Processes <input_count> characters in <input_buffer> and
 * writes processed output to output_buffer>
 * Changes: optr, output_buffer
 */
void beta_code(int input_count)
{
	int processing;
	int input_pointer_max;
	unsigned char betachar;
	unsigned int outputchar;
	int tmp;

	input_pointer_max = iptr + input_count;
	processing = 1;

	while (processing) {
		if ( (iptr < INRECSIZE) && (iptr < input_pointer_max) ) {
			betachar = input_buffer[iptr++];
			if ((betachar > 0x7F)) {
				/* ID data found - restore pointer and stop processing*/
				--iptr;
				processing = 0;
			} else {
				outputchar = 0;
				if (strchr(escape_codes, betachar)) {
					/* Handle escape codes */
					handle_escape_codes(betachar, getnum());
				} else if (betastate == HELLENIC && betachar == '*') {
					/* Handle Hellenic uppercase character */
					get_accents();
					betachar = input_buffer[iptr++];
					if (accents == 0) get_accents(); //FIXME: handle suffix accents differently
					if (strchr(accented_chars, betachar)) {
						switch (betachar) {
							case 'A':
								outputchar = Alpha[accents];
								break;
							case 'E':
								outputchar = Epsilon[accents];
								break;
							case 'H':
								outputchar = Eta[accents];
								break;
							case 'I':
								outputchar = Iota[accents];
								break;
							case 'O':
								outputchar = Omicron[accents];
								break;
							case 'U':
								outputchar = Ypsilon[accents];
								break;
							case 'W':
								outputchar = Omega[accents];
								break;
							case 'R':
								outputchar = Rho[accents];
								break;
							default:
								break;
						}
					} else if (betachar == 'S') {
						tmp = getnum();
						if (tmp == 3) outputchar = SIGLUNATEUPPER;
						else outputchar = SIGMEDIALUPPER;
					} else if (isalpha(betachar)) {
						/* not an accented character */
						outputchar = hellenic[betachar];
					} else {
						outputchar = hellenic[betachar - 0x20];
					}
					if (outputchar == 0) outputchar = hellenic[betachar]; /* error condition */
					output_utf(outputchar);
				} else if (betastate == HELLENIC && isalpha(betachar)) {
					/* Handle hellenic lower case:
					 * Get default character and then try to pin accents
					 */
					if (strchr(accented_chars, betachar)) {
						get_accents();
						switch (betachar) {
							case 'A':
								outputchar = alpha[accents];
								break;
							case 'E':
								outputchar = epsilon[accents];
								break;
							case 'H':
								outputchar = eta[accents];
								break;
							case 'I':
								outputchar = iota[accents];
								break;
							case 'O':
								outputchar = omicron[accents];
								break;
							case 'U':
								outputchar = ypsilon[accents];
								break;
							case 'W':
								outputchar = omega[accents];
								break;
							case 'R':
								outputchar = rho[accents];
								break;
							default:
								break;
						}
					} else if (betachar == 'S') {
						tmp = getnum();
						if (tmp == 1) outputchar = SIGMEDIAL;
						else if (tmp == 2)outputchar = SIGFINAL;
						else if (tmp == 3) outputchar = SIGLUNATE;
						if (outputchar == 0) {
							outputchar = which_sigma(iptr);
						}
					}

					if (outputchar == 0) outputchar = hellenic[betachar - 0x20];
					output_utf(outputchar);
				} else if (betastate == ROMAN && isalpha(betachar)) {
					/* Handle Roman characters */
					//FIXME: need to process roman characters
					if (isalpha(betachar)) get_accents();
					outputchar = betachar;
					output_utf(outputchar);
					/* ROMAN uses combining accent forms */
					output_accents();
				} else {
					//FIXME: placeholder
					if (betachar != '`') outputchar = betachar;
					output_utf(outputchar);
				}
			}
		} else {
			/* Requested number of characters have been processed
			 * or no more characters available in buffer
			 */
			processing = 0;
        	}
	}
}


const char *resolve_cite_format(const char *cformat) {
	static char outbuf[511];
	char nstring[253];
	int z;
	*outbuf = 0;
	const char *c;
	for (c = cformat; *c; c++) {
		if (*c == '%') {
			const char c2 = *(c+1);
			signed char cstart = -1;
			if ((c2 >= 'a') && (c2 <= 'z')) {
				cstart = c2 - 'a';
			}
			else if ((c2 >= 'A') && (c2 <= 'Z')) {
				cstart = 26 + (c2 - 'A');
			}
			else if (c2 == '%') {
				*nstring = '%'; nstring[1] = 0; strcat(outbuf, nstring);
			}
			else {
				fprintf(stderr, "unknown escape sequence: %%%c\n", c2);
			}
			c++;		//skip both our '%' and following character (by loop inc);

			if (cstart > 20) {
				if (icitation[cstart] == 0) sprintf(nstring, "%s",citation[cstart]);
				else sprintf(nstring, "%d%s", icitation[cstart], citation[cstart]);
				if ((opt_ecit_blank) && (!*nstring)) strcpy(nstring, ecite);
// ADDED FOR SWORD KEY DELIMETER
				for (z = 0; z < strlen(nstring); z++) {
					if (nstring[z] == '/') nstring[z] = ':';
				}
// -----------------------------
				strcat(outbuf, nstring);
			}
			else if (cstart > -1) {
				if (!citation[cstart] || !citation[cstart][0]) {
					if (opt_ecit_blank) strcat(outbuf, ecite);
				}
				else {
// ADDED FOR SWORD KEY DELIMETER
				for (z = 0; z < strlen(nstring); z++) {
					if (nstring[z] == '/') nstring[z] = ':';
				}
// -----------------------------
					strcat(outbuf, citation[cstart]);
				}
			}
		}
		else if (*c == '\\') {
			switch (*(c+1)) {
			case 't': strcat(outbuf, "\t"); break;
			case 'n': strcat(outbuf, "\n"); break;
			case 'r': strcat(outbuf, "\r"); break;
			default: *nstring = *(c+1); nstring[1] = 0; strcat(outbuf, nstring); break;
			}
			c++;		//skip both our '%' and following character (by loop inc);
		}
		else {
			*nstring = *c; nstring[1] = 0; strcat(outbuf, nstring);
		}
	}
	return outbuf;
}


/* id_code:
 * <iptr> points to the next character in the <input_buffer> to process;
 * <optr> points to the next empty <output_buffer position.
 * Returns: 0 or -1 for EOF
 */
int id_code(int input_count)
{
	int input_pointer_max;
	int return_code;
	int scratch;
	int processing;
	unsigned char idchar;
	unsigned char outcode;


	return_code = 0;
	input_pointer_max = iptr + input_count;
	processing = 1;
	while (processing) {
		if ((iptr < INRECSIZE) && (iptr < input_pointer_max)) {
			outcode = 0;
			idchar = input_buffer[iptr++];
			if ((idchar < 0x80)) { /* text data - restore pointer and return*/
				--iptr;
				processing = 0;
			} else {  /* ID data - translate and write */
				if (optr < OUTRECSIZE) {
					id_process = 0; /* we don't have a command yet */
					if (idchar >= 0xF0) {
						switch (idchar)
						{
							case 0xF0:  /* EOF */
								return_code = -1; /* indicate EOF */
								processing = 0;
								break;
							case 0xFE:  /* End of block -- block is padded with nulls */
								while (!input_buffer[iptr] && iptr<INRECSIZE) {
									iptr++;
								}
								if (opt_debug_cit) printf("tlgu: EOB %x\n", iptr-1);
								break;
							case 0xFF:  /* End of ASCII string */
								if (opt_debug_cit) printf("tlgu: %d %s\n", id_level, citation[id_level]);
								if (opt_debug_cit) printf("tlgu: EOS %x\n ", iptr-1);
								break;
							case 0xF8:  /* Exception start */
								if (opt_debug_cit) printf("tlgu: Exc start %x\n", iptr-1);
								break;
							case 0xF9:  /* Exception end */
								if (opt_debug_cit) printf("tlgu: Exc end %x\n", iptr-1);
								break;
							default:
								break;
						}
					} else if (idchar >= 0xE0) {
						/* The byte following an escape code is an ID byte
						 * Citation IDs can only be 0=a, 1=b, 2=c and 4=d
						 */
						if (opt_debug_cit) printf("tlgu: Escape %x", idchar);
						id_command = idchar & 0xF;  /* get "command" nybble */
						idchar = input_buffer[iptr++] & 0x7F;  /* get ID level byte */
						if (idchar >= 97) { /* descriptors hold the upper part of the array */
							id_level = idchar - 97 + 26; /* create an index offset */
							if (id_level > 51) {id_level = 51;} /* default to z */
						} else {
							id_level = idchar & 7;    /* must be 0 - 4 */
							if (id_level == 4) {id_level = 3;}    /* adjust d level */
						}
						if (opt_debug_cit) printf(" ID level: %d\n", id_level);
						id_process = 1; /* command must be processed */
					} else if ((idchar >= 0x80) && (id_process == 0)) {
						id_command = idchar & 0xF;  /* get command first */
						scratch = (idchar >> 4) & 0x7;    /* try to create an offset */
						//printf(" %x %x ", idchar, scratch);
						switch (scratch)
						{
							case 0:
								id_level = 25;  /* z */
								id_process = 1; /* command must be processed */
								break;
							case 1:
								id_level = 24;  /* y */
								id_process = 1; /* command must be processed */
								break;
							case 2:
								id_level = 23;  /* x */
								id_process = 1; /* command must be processed */
								break;
							case 3:
								id_level = 22;  /* w */
								id_process = 1; /* command must be processed */
								break;
							case 4:
								id_level = 21;  /* v */
								id_process = 1; /* command must be processed */
								break;
							case 5:
								id_level = 13;  /* n */
								id_process = 1; /* command must be processed */
								break;
							default:
								break;
						}

					}
					if (id_process) {
						switch (id_command)
						{
							case 0:
								icitation[id_level]++;  /* increment ID */
								break;
							case 1:
								icitation[id_level] = 1;  /* literal value */
								break;
							case 2:
								icitation[id_level] = 2;  /* literal value */
								break;
							case 3:
								icitation[id_level] = 3;  /* literal value */
								break;
							case 4:
								icitation[id_level] = 4;  /* literal value */
								break;
							case 5:
								icitation[id_level] = 5;  /* literal value */
								break;
							case 6:
								icitation[id_level] = 6;  /* literal value */
								break;
							case 7:
								icitation[id_level] = 7;  /* literal value */
								break;
							case 8:
								idchar = input_buffer[iptr++];  /* 7 bit binary value */
								icitation[id_level] = idchar & 0x7F;
								break;
							case 9:
								idchar = input_buffer[iptr++];  /* 7 bit binary value */
								icitation[id_level] = idchar & 0x7F;
								idchar = input_buffer[iptr++];  /* single character */
								citation[id_level][0] = idchar & 0x7F;
								citation[id_level][1] = 0;
								break;
							case 0xa:
								idchar = input_buffer[iptr++];  /* 7 bit binary value */
								icitation[id_level] = idchar & 0x7F;
								for (id_char=0; id_char < 31; id_char++) {
									idchar = input_buffer[iptr++];  /* string */
									if (idchar == 0xFF) {
										citation[id_level][id_char] = 0;    /* end of string */
										break;
									} else {
										citation[id_level][id_char] = idchar & 0x7F;
									}
								}
								break;
							case 0xb:
								idchar = input_buffer[iptr++];  /* 14 bit binary value */
								scratch = (idchar & 0x7F) << 7; /* shift upper */
								idchar = input_buffer[iptr++];  /* 14 bit binary value */
								idchar &= 0x7F; /* mask sign bit */
								scratch = scratch | idchar; /* combine */
								icitation[id_level] = scratch;
								break;
							case 0xc:
								idchar = input_buffer[iptr++];  /* 14 bit binary value */
								scratch = (idchar & 0x7F) << 7; /* shift upper */
								idchar = input_buffer[iptr++];  /* 14 bit binary value */
								idchar &= 0x7F; /* mask sign bit */
								scratch = scratch | idchar; /* combine */
								icitation[id_level] = scratch;
								idchar = input_buffer[iptr++];  /* single character */
								citation[id_level][0] = idchar & 0x7F;
								citation[id_level][1] = 0; /* end of string */
								break;
							case 0xd:
								idchar = input_buffer[iptr++];  /* 14 bit binary value */
								scratch = (idchar & 0x7F) << 7; /* shift upper */
								idchar = input_buffer[iptr++];  /* 14 bit binary value */
								idchar &= 0x7F; /* mask sign bit */
								scratch = scratch | idchar; /* combine */
								icitation[id_level] = scratch;
								for (id_char=0; id_char < 31; id_char++) {
									idchar = input_buffer[iptr++];  /* string */
									if (idchar == 0xFF) {
										citation[id_level][id_char] = 0;    /* end of string */
										break;
									} else {
										citation[id_level][id_char] = idchar & 0x7F;
									}
								}
								break;
							case 0xe:
								/* same binary value, single character */
								idchar = input_buffer[iptr++];  /* single character */
								citation[id_level][0] = idchar & 0x7F;
								citation[id_level][1] = 0; /* end of string */
								break;
							case 0xf:
								icitation[id_level] = 0;    /* no binary value */
								for (id_char=0; id_char < 31; id_char++) {
									idchar = input_buffer[iptr++];  /* string */
									if (idchar == 0xFF) {
										citation[id_level][id_char] = 0;    /* end of string */
										break;
									} else {
										citation[id_level][id_char] = idchar & 0x7F;
									}
								}

								/* Keep tab of book changes, optionally split into books */
								if (id_level == 1) {
									if (strncmp(citation[1], previous_bcit[1], 31)) {
										if (opt_multiple) {
											/* Signal outer loop to stop
											 * after processing citation change
											 */
											return_code = -2;
											processing = 0;
											if (opt_verbose) printf("\ntlgu: book citation: %s, previous: %s", citation[1], previous_bcit[1]);
										}
										strncpy(previous_bcit[1], citation[1], 31);
										previous_bcit[1][31] = 0;
									}
									book_change = 1;
								}
								break;
							default:
								printf("tlgu: Unknown id_command: %x, iptr %x\n", id_command, iptr);
								break;
						}
						if (opt_debug_cit) printf("tlgu: Command: %x ID level: %d, Binary: %d, ASCII: %s iptr++ %x\n",\
						id_command, id_level,icitation[id_level], citation[id_level], iptr);

						/* Adjust lower citation levels */
						switch (id_level)
						{
							case 21:
								icitation[22] = 1;
							case 22:
								icitation[23] = 1;
							case 23:
								icitation[24] = 1;
							case 24:
								icitation[25] = 1;
							case 25:
								outcode = 0;
								break;
							default:
								break;
						}

					} /* id_process */

					if (outcode) {
						output_utf(outcode);
					}

				} else {
					--iptr; /* output buffer full - restore pointer and return */
					processing = 0;
				}
			} /* ID data processing */
		} else {     /* Finished processing all input */
			processing = 0;
		}
	} /* while processing loop */
	return return_code;
}