/*
Name   : TOKEN.C
Author : Kim Moser
Date   : 09/24/89
System : IBM PC / Borland Turbo-C 2.0
Descrip: For every line read from stdin, outputs argv[] (to stdout),
	 replacing each instance of '&n' with the n'th string parsed
	 from the line read from stdin.

Usage  : TOKEN [-options] {[<string>][&<n>][<string>]}

	OPTION		MEANING
	n0|1|2		n0=never append newline
			n1=append newline only when something
			  was output (default)
			n2=always append newline
s["[@]<separator>"]	Separate parameters with string <separator>
			(or, if '@' specified, file named "separator")
			Instances of '\n' in <separator> will be converted
			to a newline, and \t will be converted to a tab.
	     M		Suppress messages
	     W		Suppress warnings

	Note: "string" may contain instance(s) of "&n" (1 <= n <= 9),
	      in any order.  For example, if a file containing the lines:

			John Doe
			Jane Doe
			Olivia Newton John

		were piped to TOKEN, which was invoked as follows:

			TOKEN -M My name is &2, &1.

		the following output would be generated:

			My name is Doe, John.
			My name is Doe, Mary.
			My name is Newton, Olivia.

	 Example: piping a text file containing the lines

		Hello there.
		Are you happy?
		What could be more fun?

	 to TOKEN, when invoked as follows:

		TOKEN echo %1 %2 %3 This is a test.

	 will result in the following file being generated:

		echo Hello There. This is a test.
		echo Are you happy? This is a test.
		echo What could be This is a test.
*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>  /* isdigit() */
#include <io.h>  /* filelength() */

#define MAXSTR		9
  /* Max strings looked at per line from stdin */

int MSG=1;  /* Whether to print messages */
int WARN=1;  /* Whether to print warnings */
char SEPARATOR[255];  /* String which will separate command line arguments
			 as they are output (defaults to " ").  If
			 SEPARATOR[0] is set to '@', then SEPARATOR+1
			 points to filename to be used as separator, and
			 contents of file will be read into SEP. */

int inRAM=0;  /* Whether separator file has been read into *SEP */
char *SEP;  /* Points to where separator has been read into RAM */
long FLEN;  /* Length of separator file */

long OFFSETS[MAXSTR];  /* Offsets (to stdin) of where each string starts */
int APPEND_EOL=1;  /* Whether to print a newline after each line */
/* 0=never, 1=only when chars output for this line, 2=always */

int ENDFOUND=0;  /* Set to 1 when EOF found */
long START=0;  /* File pos of first char in next string (set by getoffsets()) */
int NUMSTRINGS;  /* How many offsets this line has.  Set by getoffsets(). */

void credits(void)
/* Displays (to stderr) credits */
{
	fputs("TOKEN  v1.0  09/28/89  Copyright (C) 1989 Kim Moser  All Rights Reserved\n", stderr);
}

void usage(void)
/* Displays (to stderr) usage */
{
	credits();
	fputs("Usage: TOKEN [-options] {[<string>][&<n>][<string>]}\n", stderr);
	fputs("       where 0 <= n <=9\n", stderr);

	fputs("\n     OPTION   MEANING\n", stderr);
	fputs("     n0|1|2   n0: never append a newline after each line\n", stderr);
	fputs("              n1: append a newline after each line only if characters\n", stderr);
	fputs("                  were output for that line\n", stderr);
	fputs("              n2: always append a newline after each line\n", stderr);
	fputs("s\"[@]<sep>\"   Separate parameters with string \"sep\"\n", stderr);
	fputs("              (or, if '@' specified, contents of file named \"sep\")\n", stderr);
	fputs("          M   Suppress messages\n", stderr);
	fputs("          W   Suppress warnings\n", stderr);

	fputs("\nFor every line read from stdin, outputs strings on command line,\n", stderr);
	fputs("replacing instances of \"&<n>\" with the n'th string parsed from the\n", stderr);
	fputs("line read from stdin.\n", stderr);

	fputs("\nWarns if <n> is larger than the index of the last string parsed from\n", stderr);
	fputs("any line, or if the line contains more than 9 strings.\n", stderr);
	exit(-1);
}

long where(void)
/* Gets file pos of stdin;
   If error, prints message to stderr and calls exit(),
   else returns file pos. */
{
	long r;

	if ( (r=ftell(stdin)) == -1L ) {
		fputs("\nUnable to read file pointer of stdin.\n", stderr);
		exit(-1);
	}
	return r;
}

void here(p)
long p;
/* Sets file pos of stdin to 'p';
   If error, prints message to stderr and exits. */
{
	if ( fseek(stdin,p,SEEK_SET) ) {
		if (WARN)
			fprintf(stderr,
"\nUnable to set stdin's file pointer to %d.\n", p);
		exit(-1);
	}
}

void printsep(void)
/* If SEPARATOR is a filename (i.e. begins with '@' then sends contents
   of that file to stdout, else sends SEPARATOR verbatim to stdout */
{
	FILE *fp;
	long i;
	int prev, ch=0;

	if (SEPARATOR[0]=='@') {  /* It's a filename */
		if (!inRAM) {
			inRAM=1;
			/* Open in BINARY mode: */
			if ( (fp=fopen(SEPARATOR+1,"rb"))==NULL ) {
				if (WARN)
					fprintf(stderr,
"Error opening separator file '%s'.\n", SEPARATOR+1);
				exit(-1);
			}
			if ( (FLEN=filelength(fileno(fp)))==-1 ) {
				if (WARN)
					fprintf(stderr,
"Error getting length of separator file '%s'.\n", SEPARATOR+1);
				exit(-1);
			}
			if ( (SEP=(char*)malloc((size_t)FLEN))==NULL ) {
				if (WARN)
					fprintf(stderr,
"Error allocating %ld bytes for separator file '%s'.\n", FLEN, SEPARATOR+1);
				exit(-1);
			}
			if ( (i=fread(SEP,1,FLEN,fp))!=FLEN ) {
				if (WARN)
					fprintf(stderr,
"Able to read only %ld of %ld bytes from separator file '%s'.\n",
						i, FLEN, SEPARATOR+1);
				exit(-1);
			}
			if ( fclose(fp) ) {
				if (WARN)
					fprintf(stderr,
"Error closing separator file '%s'.\n", SEPARATOR+1);
				exit(-1);
			}
		}
	}

	/* Print separator: */
	for (i=0; (inRAM ? i<FLEN : SEPARATOR[i]); i++) {
		prev=ch;
		ch=( (inRAM ? SEP[i] : SEPARATOR[i]) );
		if (prev=='\\' && ch=='n') {
			putchar('\n');
		} else {
			putchar(ch);
		}
	}
}

int SOFARPARAM;  /* Whether any chars have been output for this param */
int SOFARLINE;  /* Whether any chars have been output for this line */

void outchar(ch)
int ch;
/* If at least 1 char has been output so far for this line, and if
   no chars have been output so far for this param, then print separator.
   Print ch. */
{
	/* Force short-circuiting by breaking into two statements: */
	if (SOFARLINE) {
		if (!SOFARPARAM) {
			printsep();
			SOFARPARAM++;
		}
	}
	putchar(ch);
}

int printtoEOS(void)
/* Prints characters until ' ', EOF, or '\n' found.
   Returns last char read. */
{
	int ch;

	while ( (ch=getchar()) != EOF ) {
		if ( (ch==' ') || (ch=='\n') )
			break;
		else
			outchar(ch);
	}

	return ch;
}

int seektoBOS(void)
/* Seeks to beginning of current string (or EOL or EOF) and returns
   last char read */
{
	int ch;

	while ( (ch=getchar()) == ' ' );

	return ch;
}

int seektoEOS(void)
/* Seeks to end of current string and returns last char read */
{
	int ch;

	while ( (ch=getchar()) != EOF )
		if ( (ch==' ') || (ch=='\n') )
			break;

	return ch;
}

void getoffsets(void)
{
	int i;
	int EOLfound=0;

	/* Start at the beginning of the line: */
	here(START);

	for (i=0; i<MAXSTR && !ENDFOUND && !EOLfound; i++) {
		switch (seektoBOS()) {
			case EOF:
				ENDFOUND = 1;
				/* Fall through */
			case '\n':
				EOLfound = 1;
				break;
			default:  /* Beginning of string found */
				NUMSTRINGS++;
				/* Remember where it starts */
				OFFSETS[i] = where() - 1;
				/* Get to the end of it */
				switch (seektoEOS()) {
					case EOF:
						ENDFOUND = 1;
						/* Fall through */
					case '\n':
						EOLfound = 1;
						break;
				}
				break;
		}
	}

	/* If we still haven't gotten to EOL or EOF, then get there: */
	if ( !(ENDFOUND||EOLfound) ) {
		ENDFOUND = (seektoEOS()==EOF);
	}
	/* Remember where to start for the next line: */
	if (!ENDFOUND) {
		START = where();  /* After the newline */
	}
}

int printstr(n)
int n;
/* If there's an nth string, get to where it starts and print it, else
   warn that string wasn't available.
   Returns 1 if string printed, else returns 0 (string not printed). */
{
	int r;  /* Return value */

	/* "!=0" specified to suppress "possibly incorrect assignment" warning: */
	if ( (r = (OFFSETS[n]==-1)) !=0 ) {
		if (WARN)
			fprintf(stderr,
"\nWarning: parameter %d requested but line contains only %d.\n",
				n, NUMSTRINGS);
	} else {
		here(OFFSETS[n]);
		printtoEOS();
	}

	return r;
}

int replace_and_print(s)
char *s;
/* Outputs (to stdout) chars from 's'.
   When char is '&' and next char is a digit, prints (n-1)th string
   (calls printstr()).
   Returns 1 if any chars output, else returns 0 (no chars output).
*/
{
	int i;
	int last_was_amper=0;
	int last_was_backslash=0;
	int print_it;  /* Whether to output the char */
	int r=0;  /* Return value */  /* Assume */

	SOFARPARAM=0;
	for (i=0; s[i]; i++) {
		print_it = 0;  /* Assume */
		if (isdigit(s[i])) {
			if (last_was_amper) {
				/* Convert to an index (into OFFSETS[])
				   and print that string: */
				r |= printstr(s[i]-'1');
				last_was_amper = 0;
			} else {
				/* Just print the character */
				print_it = 1;
			}
			last_was_backslash = 0;
		} else if (s[i]=='&') {
			if (last_was_amper) {
				/* Two consecutive ampersands, so
				   output just one: */
				outchar('&');
				r = 1;
				last_was_amper = 0;
			} else {
				last_was_amper = 1;
			}
			last_was_backslash = 0;
		} else if (s[i] == '\\') {
			last_was_amper = 0;
			last_was_backslash = 1;
			if (i && (s[i-1] == '\\')) {
				print_it = 1;
				last_was_backslash = 0;
			}
		} else {
			if (last_was_backslash) {
				if (s[i] == 'n') {
					outchar('\n');
				} else if (s[i] == 't') {
					outchar('\t');
				} else {
					outchar('\\');
				}
				last_was_backslash = 0;
				last_was_amper = 0;
				print_it = 0;
			} else if (last_was_amper) {  /* Ex: "&a" */
				outchar('&');
				last_was_amper = 0;
				last_was_backslash = 0;
				print_it = 1;
			}
		}

		if (print_it) {
			outchar(s[i]);
			r = 1;
		}
	}
	return r;
}

int params(s, max)
char **s;
int max;
/* Parses params from string 's[0]' (argv[0]), moving on to s[1] if separator
   is specified, >and< if s[0] abruptly ends (indicating that separator
   is in s[1]).  'max' is argc.
   Returns index of last param looked at. */
{
	int i=1, k=1;
	int j;  /* Index into SEPARATOR */
	int r=2;  /* Result */  /* Assume */

	while(s[k][i]) {
		switch(s[k][i]) {
			case 's':  /* Separator follows */
				/* Is separator in next string? */
				if (!s[k][i+1]) {
					/* Separator is in next string */
					k++;
					i=0;
					r=3;
				} else {
					/* Separator is in same string */
					i++;
				}
				if (r<=max) {
					/* We're still in a valid param */
					j=0;
					/* Read until EOS: */
					while (s[k][i]) {
						SEPARATOR[j++]=s[k][i++];
					}
					SEPARATOR[j]='\0';
				} else {
					/* We went past argv[argc-1] while
					   looking for separator, so assume
					   separator is blank */
					   SEPARATOR[0]='\0';
				}
				return r;
			case 'n':  /* Expect '0', '1', or '2': */
				APPEND_EOL=s[k][++i]-'0';
				if (APPEND_EOL<0 || APPEND_EOL>2) {
					usage();
				}
				break;
			case 'M':  /* Suppress messages */
				MSG = 0;
				break;
			case 'W':  /* Suppress warnings */
				WARN = 0;
				break;
			default:
				usage();
		}
		i++;
	}
	return r;
}

void main(argc, argv)
int argc;
char **argv;
{
	int i;
	int start=1;  /* argv with which to start */  /* Assume */

	strcpy(SEPARATOR, " ");  /* Init to defaut */

	start=1;  /* Start at argv[1] (assume) */
	/* If any params specified, parse them: */
	if ( (argc>1) && (argv[1][0]=='-') ) {
		start = params(argv, argc);
	}

	if (MSG) {  /* Display settings: */
		credits();
		fputs("\nSETTINGS:\n", stderr);
		fprintf(stderr, "  %s warnings\n", WARN?"Display":"Suppress");
		fprintf(stderr, "  %s messages\n", MSG?"Display":"Suppress");
		fputs("  Separator: ", stderr);
		if (SEPARATOR[0]=='@') {
			fprintf(stderr, "contents of file '%s'\n", SEPARATOR+1);
		} else {
			fprintf(stderr, "\"%s\"\n", SEPARATOR);
		}
		fputs("  Output newline: ", stderr);
		switch(APPEND_EOL) {
			case 0:
				fputs("Never\n", stderr);
				break;
			case 1:
				fputs("Only if line is not empty\n", stderr);
				break;
			case 2:
				fputs("After each line\n", stderr);
				break;
			default:
				fprintf(stderr, "Internal error: APPEND_EOL is neither 0, 1, nor 2.\n");
				exit(-1);
		}
	}

	while(1) {
		SOFARLINE=0;  /* Assume */
		/* Clear array of file offsets: */
		for (i=0; i<MAXSTR; OFFSETS[i++] = -1L);

		getoffsets();
		for (i=start; i<argc; i++) {
			SOFARLINE|=replace_and_print(argv[i]);
		}

		/* Print newline only if any params printed, or if
		   requested to print newline always: */
		if ( (APPEND_EOL==1)&&SOFARLINE || (APPEND_EOL==2) ) {
			putchar('\n');
		}

		if (ENDFOUND) break;  /* No lines left */
	}

	if (inRAM) {
		free((void*)SEP);
	}
}