/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2015 Gary Mills
 * Copyright (c) 1996-1997 by Sun Microsystems, Inc.
 * All rights reserved.
 */

/*	Copyright (c) 1988 AT&T	*/
/*	  All Rights Reserved  	*/

/* Copyright (c) 1979 Regents of the University of California */

/*LINTLIBRARY*/

#include	"curses_inc.h"
#include	"curshdr.h"
#include	"term.h"
#include	<string.h>
#include	<setjmp.h>
#include	<stdlib.h>
#include	<stdio.h>

#ifndef	_CHCTRL
#define	_CHCTRL(c)	((c) & 037)
#endif	/* _CHCTRL */

char	*_branchto(char *, char);

/*
 * Routine to perform parameter substitution.
 * instring is a string containing printf type escapes.
 * The whole thing uses a stack, much like an HP 35.
 * The following escapes are defined for substituting row/column:
 *
 *	%[:[-+ #0]][0-9][.][0-9][dsoxX]
 *		print pop() as in printf(3), as defined in the local
 *		sprintf(3), except that a leading + or - must be preceded
 *		with a colon (:) to distinguish from the plus/minus operators.
 *
 *	%c	print pop() like %c in printf(3)
 *	%l	pop() a string address and push its length.
 *	%P[a-z] set dynamic variable a-z
 *	%g[a-z] get dynamic variable a-z
 *	%P[A-Z] set static variable A-Z
 *	%g[A-Z] get static variable A-Z
 *
 *	%p[1-0]	push ith parm
 *	%'c'	char constant c
 *	%{nn}	integer constant nn
 *
 *	%+ %- %* %/ %m		arithmetic (%m is mod): push(pop() op pop())
 *	%& %| %^		bit operations:		push(pop() op pop())
 *	%= %> %<		logical operations:	push(pop() op pop())
 *	%A %O			logical AND, OR		push(pop() op pop())
 *	%! %~			unary operations	push(op pop())
 *	%%			output %
 *	%? expr %t thenpart %e elsepart %;
 *				if-then-else, %e elsepart is optional.
 *				else-if's are possible ala Algol 68:
 *				%? c1 %t %e c2 %t %e c3 %t %e c4 %t %e %;
 *	% followed by anything else
 *				is not defined, it may output the character,
 *				and it may not. This is done so that further
 *				enhancements to the format capabilities may
 *				be made without worrying about being upwardly
 *				compatible from buggy code.
 *
 * all other characters are ``self-inserting''.  %% gets % output.
 *
 * The stack structure used here is based on an idea by Joseph Yao.
 */

#define	MAX		10
#define	MEM_ALLOC_FAIL	1
#define	STACK_UNDERFLOW	2

typedef struct {
	long	top;
	int	stacksize;
	long	*stack;

}STACK;

static jmp_buf env;

static long
tops(STACK *st)
{

	if (st->top < 0) {
		longjmp(env, STACK_UNDERFLOW);
	}
	return (st->stack[st->top]);
}

static void
push(STACK *st, long i)
{
	if (st->top >= (st->stacksize - 1)) {
		st->stacksize += MAX;
		if ((st->stack = (void *)realloc(st->stack,
		    (st->stacksize * sizeof (long)))) == NULL) {
			longjmp(env, MEM_ALLOC_FAIL);
		}
	}
	st->stack[++st->top] = (i);
}

static long
pop(STACK *st)
{
	if (st->top < 0) {
		longjmp(env, STACK_UNDERFLOW);
	}
	return (st->stack[st->top--]);
}

/*
 * The following routine was added to make lint shut up about converting from
 * a long to a char *.  It is identical to the pop routine, except for the
 * cast on the return statement.
 */
static char *
pop_char_p(STACK *st)
{
	if (st->top < 0) {
		longjmp(env, STACK_UNDERFLOW);
	}
	return ((char *)(st->stack[st->top--]));
}

static void
init_stack(STACK *st)
{
	st->top = -1;
	st->stacksize = MAX;
	if ((st->stack = (void *)malloc(MAX * sizeof (long))) == NULL) {
		longjmp(env, MEM_ALLOC_FAIL);
	}
}

static void
free_stack(STACK *st)
{
	free(st->stack);
}


char *
tparm_p0(char *instring)
{
	long	p[] = {0, 0, 0, 0, 0, 0, 0, 0, 0};

	return (tparm(instring, p[0], p[1], p[2], p[3], p[4], p[5], p[6],
	    p[7], p[8]));
}

char *
tparm_p1(char *instring, long l1)
{
	long	p[] = {0, 0, 0, 0, 0, 0, 0, 0, 0};

	p[0] = l1;

	return (tparm(instring, p[0], p[1], p[2], p[3], p[4], p[5], p[6],
	    p[7], p[8]));
}

char *
tparm_p2(char *instring, long l1, long l2)
{
	long	p[] = {0, 0, 0, 0, 0, 0, 0, 0, 0};

	p[0] = l1;
	p[1] = l2;

	return (tparm(instring, p[0], p[1], p[2], p[3], p[4], p[5], p[6],
	    p[7], p[8]));
}

char *
tparm_p3(char *instring, long l1, long l2, long l3)
{
	long	p[] = {0, 0, 0, 0, 0, 0, 0, 0, 0};

	p[0] = l1;
	p[1] = l2;
	p[2] = l3;

	return (tparm(instring, p[0], p[1], p[2], p[3], p[4], p[5], p[6],
	    p[7], p[8]));
}

char *
tparm_p4(char *instring, long l1, long l2, long l3, long l4)
{
	long	p[] = {0, 0, 0, 0, 0, 0, 0, 0, 0};

	p[0] = l1;
	p[1] = l2;
	p[2] = l3;
	p[3] = l4;

	return (tparm(instring, p[0], p[1], p[2], p[3], p[4], p[5], p[6],
	    p[7], p[8]));
}

char *
tparm_p7(char *instring, long l1, long l2, long l3, long l4, long l5, long l6,
    long l7)
{
	long	p[] = {0, 0, 0, 0, 0, 0, 0, 0, 0};

	p[0] = l1;
	p[1] = l2;
	p[2] = l3;
	p[3] = l4;
	p[4] = l5;
	p[5] = l6;
	p[6] = l7;

	return (tparm(instring, p[0], p[1], p[2], p[3], p[4], p[5], p[6],
	    p[7], p[8]));
}

/* VARARGS */
char *
tparm(char *instring, long fp1, long fp2, long p3, long p4,
    long p5, long p6, long p7, long p8, long p9)
{
	static	char	result[512];
	static	char	added[100];
	long		vars[26];
	STACK		stk;
	char		*cp = instring;
	char		*outp = result;
	char		c;
	long		op;
	long		op2;
	int		sign;
	volatile int	onrow = 0;
	volatile long	p1 = fp1, p2 = fp2; /* copy in case < 2 actual parms */
	char		*xp;
	char		formatbuffer[100];
	char		*format;
	int		looping;
	short		*regs = cur_term->_regs;
	int		val;


	if ((val = setjmp(env)) != 0) {
#ifdef DEBUG
		switch (val) {
			case MEM_ALLOC_FAIL:
				fprintf(outf, "TPARM: Memory allocation"
				    " failure.");
				break;
			case STACK_UNDERFLOW:
				fprintf(outf, "TPARM: Stack underflow.");
				break;
		}
#endif  /* DEBUG */

		if (val == STACK_UNDERFLOW)
			free_stack(&stk);
		return (NULL);
	}

	init_stack(&stk);
	push(&stk, 0);

	if (instring == 0) {
#ifdef	DEBUG
		if (outf)
			fprintf(outf, "TPARM: null arg\n");
#endif	/* DEBUG */
		free_stack(&stk);
		return (NULL);
	}

	added[0] = 0;

	while ((c = *cp++) != 0) {
		if (c != '%') {
			*outp++ = c;
			continue;
		}
		op = tops(&stk);
		switch (c = *cp++) {
			/* PRINTING CASES */
			case ':':
			case ' ':
			case '#':
			case '0':
			case '1':
			case '2':
			case '3':
			case '4':
			case '5':
			case '6':
			case '7':
			case '8':
			case '9':
			case '.':
			case 'd':
			case 's':
			case 'o':
			case 'x':
			case 'X':
				format = formatbuffer;
				*format++ = '%';

			/* leading ':' to allow +/- in format */
			if (c == ':')
				c = *cp++;

			/* take care of flags, width and precision */
			looping = 1;
			while (c && looping)
				switch (c) {
					case '-':
					case '+':
					case ' ':
					case '#':
					case '0':
					case '1':
					case '2':
					case '3':
					case '4':
					case '5':
					case '6':
					case '7':
					case '8':
					case '9':
					case '.':
						*format++ = c;
						c = *cp++;
						break;
					default:
						looping = 0;
				}

			/* add in the conversion type */
			switch (c) {
				case 'd':
				case 's':
				case 'o':
				case 'x':
				case 'X':
					*format++ = c;
					break;
				default:
#ifdef	DEBUG
				if (outf)
					fprintf(outf, "TPARM: invalid "
					    "conversion type\n");
#endif	/* DEBUG */
				free_stack(&stk);
				return (NULL);
			}
			*format = '\0';

			/*
			 * Pass off the dirty work to sprintf.
			 * It's debatable whether we should just pull in
			 * the appropriate code here. I decided not to for
			 * now.
			 */
			if (c == 's')
				(void) sprintf(outp, formatbuffer, (char *)op);
			else
				(void) sprintf(outp, formatbuffer, op);
			/*
			 * Advance outp past what sprintf just did.
			 * sprintf returns an indication of its length on some
			 * systems, others the first char, and there's
			 * no easy way to tell which. The Sys V on
			 * BSD emulations are particularly confusing.
			 */
				while (*outp)
					outp++;
				(void) pop(&stk);

				continue;

			case 'c':
			/*
			 * This code is worth scratching your head at for a
			 * while.  The idea is that various weird things can
			 * happen to nulls, EOT's, tabs, and newlines by the
			 * tty driver, arpanet, and so on, so we don't send
			 * them if we can help it.  So we instead alter the
			 * place being addessed and then move the cursor
			 * locally using UP or RIGHT.
			 *
			 * This is a kludge, clearly.  It loses if the
			 * parameterized string isn't addressing the cursor
			 * (but hopefully that is all that %c terminals do
			 * with parms).  Also, since tab and newline happen
			 * to be next to each other in ASCII, if tab were
			 * included a loop would be needed.  Finally, note
			 * that lots of other processing is done here, so
			 * this hack won't always work (e.g. the Ann Arbor
			 * 4080, which uses %B and then %c.)
			 */
				switch (op) {
				/*
				 * Null.  Problem is that our
				 * output is, by convention, null terminated.
				 */
					case 0:
						op = 0200; /* Parity should */
							/* be ignored. */
						break;
				/*
				 * Control D.  Problem is that certain very
				 * ancient hardware hangs up on this, so the
				 * current(!) UNIX tty driver doesn't xmit
				 * control D's.
				 */
					case _CHCTRL('d'):
				/*
				 * Newline.  Problem is that UNIX will expand
				 * this to CRLF.
				 */
					case '\n':
						xp = (onrow ? cursor_down :
						    cursor_right);
					if (onrow && xp && op < lines-1 &&
					    cursor_up) {
						op += 2;
						xp = cursor_up;
					}
					if (xp && instring ==
					    cursor_address) {
						(void) strcat(added, xp);
						op--;
					}
					break;
				/*
				 * Tab used to be in this group too,
				 * because UNIX might expand it to blanks.
				 * We now require that this tab mode be turned
				 * off by any program using this routine,
				 * or using termcap in general, since some
				 * terminals use tab for other stuff, like
				 * nondestructive space.  (Filters like ul
				 * or vcrt will lose, since they can't stty.)
				 * Tab was taken out to get the Ann Arbor
				 * 4080 to work.
				 */
				}

				/* LINTED */
				*outp++ = (char)op;
				(void) pop(&stk);
				break;

			case 'l':
				xp = pop_char_p(&stk);
				push(&stk, strlen(xp));
				break;

			case '%':
				*outp++ = c;
				break;

			/*
			 * %i: shorthand for increment first two parms.
			 * Useful for terminals that start numbering from
			 * one instead of zero(like ANSI terminals).
			 */
			case 'i':
				p1++;
				p2++;
				break;

			/* %pi: push the ith parameter */
			case 'p':
				switch (c = *cp++) {
					case '1':
						push(&stk, p1);
						break;
					case '2':
						push(&stk, p2);
						break;
					case '3':
						push(&stk, p3);
						break;
					case '4':
						push(&stk, p4);
						break;
					case '5':
						push(&stk, p5);
						break;
					case '6':
						push(&stk, p6);
						break;
					case '7':
						push(&stk, p7);
						break;
					case '8':
						push(&stk, p8);
						break;
					case '9':
						push(&stk, p9);
						break;
					default:
#ifdef	DEBUG
						if (outf)
							fprintf(outf, "TPARM:"
							    " bad parm"
							    " number\n");
#endif	/* DEBUG */
						free_stack(&stk);
						return (NULL);
				}
			onrow = (c == '1');
			break;

			/* %Pi: pop from stack into variable i (a-z) */
			case 'P':
				if (*cp >= 'a' && *cp <= 'z') {
					vars[*cp++ - 'a'] = pop(&stk);
				} else {
					if (*cp >= 'A' && *cp <= 'Z') {
						regs[*cp++ - 'A'] =
						    /* LINTED */
						    (short)pop(&stk);
					}
#ifdef	DEBUG
					else if (outf) {
						fprintf(outf, "TPARM: bad"
						    " register name\n");
					}
#endif	/* DEBUG */
				}
				break;

			/* %gi: push variable i (a-z) */
			case 'g':
				if (*cp >= 'a' && *cp <= 'z') {
					push(&stk, vars[*cp++ - 'a']);
				} else {
					if (*cp >= 'A' && *cp <= 'Z') {
						push(&stk, regs[*cp++ - 'A']);
					}
#ifdef	DEBUG
					else if (outf) {
						fprintf(outf, "TPARM: bad"
						    " register name\n");

					}
#endif	/* DEBUG */
				}
				break;

			/* %'c' : character constant */
			case '\'':
				push(&stk, *cp++);
				if (*cp++ != '\'') {
#ifdef	DEBUG
					if (outf)
						fprintf(outf, "TPARM: missing"
						    " closing quote\n");
#endif	/* DEBUG */
					free_stack(&stk);
					return (NULL);
				}
				break;

			/* %{nn} : integer constant.  */
			case '{':
				op = 0;
				sign = 1;
				if (*cp == '-') {
					sign = -1;
					cp++;
				} else
					if (*cp == '+')
						cp++;
				while ((c = *cp++) >= '0' && c <= '9') {
					op = 10 * op + c - '0';
				}
				if (c != '}') {
#ifdef	DEBUG
					if (outf)
						fprintf(outf, "TPARM: missing "
						    "closing brace\n");
#endif	/* DEBUG */
					free_stack(&stk);
					return (NULL);
				}
				push(&stk, (sign * op));
				break;

			/* binary operators */
			case '+':
				op2 = pop(&stk);
				op = pop(&stk);
				push(&stk, (op + op2));
				break;
			case '-':
				op2 = pop(&stk);
				op = pop(&stk);
				push(&stk, (op - op2));
				break;
			case '*':
				op2 = pop(&stk);
				op = pop(&stk);
				push(&stk, (op * op2));
				break;
			case '/':
				op2 = pop(&stk);
				op = pop(&stk);
				push(&stk, (op / op2));
				break;
			case 'm':
				op2 = pop(&stk);
				op = pop(&stk);
				push(&stk, (op % op2));
				break; /* %m: mod */
			case '&':
				op2 = pop(&stk);
				op = pop(&stk);
				push(&stk, (op & op2));
				break;
			case '|':
				op2 = pop(&stk);
				op = pop(&stk);
				push(&stk, (op | op2));
				break;
			case '^':
				op2 = pop(&stk);
				op = pop(&stk);
				push(&stk, (op ^ op2));
				break;
			case '=':
				op2 = pop(&stk);
				op = pop(&stk);
				push(&stk, (op == op2));
				break;
			case '>':
				op2 = pop(&stk);
				op = pop(&stk);
				push(&stk, (op > op2));
				break;
			case '<':
				op2 = pop(&stk);
				op = pop(&stk);
				push(&stk, (op < op2));
				break;
			case 'A':
				op2 = pop(&stk);
				op = pop(&stk);
				push(&stk, (op && op2));
				break; /* AND */
			case 'O':
				op2 = pop(&stk);
				op = pop(&stk);
				push(&stk, (op || op2));
				break; /* OR */

			/* Unary operators. */
			case '!':
				push(&stk, !pop(&stk));
				break;
			case '~':
				push(&stk, ~pop(&stk));
				break;

			/* Sorry, no unary minus, because minus is binary. */

			/*
			 * If-then-else.  Implemented by a low level hack of
			 * skipping forward until the match is found, counting
			 * nested if-then-elses.
			 */
			case '?':	/* IF - just a marker */
				break;

			case 't':	/* THEN - branch if false */
				if (!pop(&stk))
					cp = _branchto(cp, 'e');
				break;

			case 'e':	/* ELSE - branch to ENDIF */
				cp = _branchto(cp, ';');
				break;

			case ';':	/* ENDIF - just a marker */
				break;

			default:
#ifdef	DEBUG
				if (outf)
					fprintf(outf, "TPARM: bad % "
					    "sequence\n");
#endif	/* DEBUG */
				free_stack(&stk);
				return (NULL);
		}
	}
	(void) strcpy(outp, added);
	free_stack(&stk);
	return (result);
}

char	*
_branchto(register char *cp, char to)
{
	register	int	level = 0;
	register	char	c;

	while (c = *cp++) {
		if (c == '%') {
			if ((c = *cp++) == to || c == ';') {
				if (level == 0) {
					return (cp);
				}
			}
			if (c == '?')
				level++;
			if (c == ';')
				level--;
		}
	}
#ifdef	DEBUG
	if (outf)
		fprintf(outf, "TPARM: no matching ENDIF");
#endif	/* DEBUG */
	return (NULL);
}