freebsd/lib/libdpv/dprompt.c

/*-
 * Copyright (c) 2013-2014 Devin Teske <dteske@FreeBSD.org>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include <sys/types.h>

#define _BSD_SOURCE /* to get dprintf() prototype in stdio.h below */
#include <dialog.h>
#include <err.h>
#include <libutil.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string_m.h>
#include <unistd.h>

#include "dialog_util.h"
#include "dialogrc.h"
#include "dprompt.h"
#include "dpv.h"
#include "dpv_private.h"

#define FLABEL_MAX 1024

static int fheight = 0; /* initialized by dprompt_init() */
static char dprompt[PROMPT_MAX + 1] = "";
static char *dprompt_pos = (char *)(0); /* treated numerically */

/* Display characteristics */
#define FM_DONE 0x01
#define FM_FAIL 0x02
#define FM_PEND 0x04
static uint8_t dprompt_free_mask;
static char *done = NULL;
static char *fail = NULL;
static char *pend = NULL;
int display_limit = DISPLAY_LIMIT_DEFAULT;	/* Max entries to show */
int label_size    = LABEL_SIZE_DEFAULT;		/* Max width for labels */
int pbar_size     = PBAR_SIZE_DEFAULT;		/* Mini-progressbar size */
static int gauge_percent = 0;
static int done_size, done_lsize, done_rsize;
static int fail_size, fail_lsize, fail_rsize;
static int mesg_size, mesg_lsize, mesg_rsize;
static int pend_size, pend_lsize, pend_rsize;
static int pct_lsize, pct_rsize;
static void *gauge = NULL;
#define SPIN_SIZE 4
static char spin[SPIN_SIZE + 1] = "/-\\|";
static char msg[PROMPT_MAX + 1];
static char *spin_cp = spin;

/* Function prototypes */
static char	spin_char(void);
static int	dprompt_add_files(struct dpv_file_node *file_list,
		    struct dpv_file_node *curfile, int pct);

/*
 * Returns a pointer to the current spin character in the spin string and
 * advances the global position to the next character for the next call.
 */
static char
spin_char(void)
{
	char ch;

	if (spin_cp == '\0')
		spin_cp = spin;
	ch = *spin_cp;

	/* Advance the spinner to the next char */
	if (++spin_cp >= (spin + SPIN_SIZE))
		spin_cp = spin;

	return (ch);
}

/*
 * Initialize heights and widths based on various strings and environment
 * variables (such as ENV_USE_COLOR).
 */
void
dprompt_init(struct dpv_file_node *file_list)
{
	uint8_t nls = 0;
	int len;
	int max_cols;
	int max_rows;
	int nthfile;
	int numlines;
	struct dpv_file_node *curfile;

	/*
	 * Initialize dialog(3) `colors' support and draw backtitle
	 */
	if (use_libdialog && !debug) {
		init_dialog(stdin, stdout);
		dialog_vars.colors = 1;
		if (backtitle != NULL) {
			dialog_vars.backtitle = (char *)backtitle;
			dlg_put_backtitle();
		}
	}

	/* Calculate width of dialog(3) or [X]dialog(1) --gauge box */
	dwidth = label_size + pbar_size + 9;

	/*
	 * Calculate height of dialog(3) or [X]dialog(1) --gauge box
	 */
	dheight = 5;
	max_rows = dialog_maxrows();
	/* adjust max_rows for backtitle and/or dialog(3) statusLine */
	if (backtitle != NULL)
		max_rows -= use_shadow ? 3 : 2;
	if (use_libdialog && use_shadow)
		max_rows -= 2;
	/* add lines for `-p text' */
	numlines = dialog_prompt_numlines(pprompt, 0);
	if (debug)
		warnx("`-p text' is %i line%s long", numlines,
		    numlines == 1 ? "" : "s");
	dheight += numlines;
	/* adjust dheight for various implementations */
	if (use_dialog) {
		dheight -= dialog_prompt_nlstate(pprompt);
		nls = dialog_prompt_nlstate(pprompt);
	} else if (use_xdialog) {
		if (pprompt == NULL || *pprompt == '\0')
			dheight++;
	} else if (use_libdialog) {
		if (pprompt != NULL && *pprompt != '\0')
			dheight--;
	}
	/* limit the number of display items (necessary per dialog(1,3)) */
	if (display_limit == 0 || display_limit > DPV_DISPLAY_LIMIT)
		display_limit = DPV_DISPLAY_LIMIT;
	/* verify fheight will fit (stop if we hit 1) */
	for (; display_limit > 0; display_limit--) {
		nthfile = numlines = 0;
		fheight = (int)dpv_nfiles > display_limit ?
		    (unsigned int)display_limit : dpv_nfiles;
		for (curfile = file_list; curfile != NULL;
		    curfile = curfile->next) {
			nthfile++;
			numlines += dialog_prompt_numlines(curfile->name, nls);
			if ((nthfile % display_limit) == 0) {
				if (numlines > fheight)
					fheight = numlines;
				numlines = nthfile = 0;
			}
		}
		if (numlines > fheight)
			fheight = numlines;
		if ((dheight + fheight +
		    (int)dialog_prompt_numlines(aprompt, use_dialog) -
		    (use_dialog ? (int)dialog_prompt_nlstate(aprompt) : 0))
		    <= max_rows)
			break;	
	}
	/* don't show any items if we run the risk of hitting a blank set */
	if ((max_rows - (use_shadow ? 5 : 4)) >= fheight)
		dheight += fheight;
	else
		fheight = 0;
	/* add lines for `-a text' */
	numlines = dialog_prompt_numlines(aprompt, use_dialog);
	if (debug)
		warnx("`-a text' is %i line%s long", numlines,
		    numlines == 1 ? "" : "s");
	dheight += numlines;

	/* If using Xdialog(1), adjust accordingly (based on testing) */
	if (use_xdialog)
		dheight += dheight / 4;

	/* For wide mode, long prefix (`pprompt') or append (`aprompt')
	 * strings will bump width */
	if (wide) {
		len = (int)dialog_prompt_longestline(pprompt, 0); /* !nls */
		if ((len + 4) > dwidth)
			dwidth = len + 4;
		len = (int)dialog_prompt_longestline(aprompt, 1); /* nls */
		if ((len + 4) > dwidth)
			dwidth = len + 4;
	}

	/* Enforce width constraints to maximum values */
	max_cols = dialog_maxcols();
	if (max_cols > 0 && dwidth > max_cols)
		dwidth = max_cols;

	/* Optimize widths to sane values*/
	if (pbar_size > dwidth - 9) {
		pbar_size = dwidth - 9;
		label_size = 0;
		/* -9 = "|  - [" ... "] |" */
	}
	if (pbar_size < 0)
		label_size = dwidth - 8;
		/* -8 = "|  " ... " -  |" */
	else if (label_size > (dwidth - pbar_size - 9) || wide)
		label_size = no_labels ? 0 : dwidth - pbar_size - 9;
		/* -9 = "| " ... " - [" ... "] |" */

	/* Hide labels if requested */
	if (no_labels)
		label_size = 0;

	/* Touch up the height (now that we know dwidth) */
	dheight += dialog_prompt_wrappedlines(pprompt, dwidth - 4, 0);
	dheight += dialog_prompt_wrappedlines(aprompt, dwidth - 4, 1);

	if (debug)
		warnx("dheight = %i dwidth = %i fheight = %i",
		    dheight, dwidth, fheight);

	/* Calculate left/right portions of % */
	pct_lsize = (pbar_size - 4) / 2; /* -4 == printf("%-3s%%", pct) */
	pct_rsize = pct_lsize;
	/* If not evenly divisible by 2, increment the right-side */
	if ((pct_rsize + pct_rsize + 4) != pbar_size)
		pct_rsize++;

	/* Initialize "Done" text */
	if (done == NULL && (done = msg_done) == NULL) {
		if ((done = getenv(ENV_MSG_DONE)) != NULL)
			done_size = strlen(done);
		else {
			done_size = strlen(DPV_DONE_DEFAULT);
			if ((done = malloc(done_size + 1)) == NULL)
				errx(EXIT_FAILURE, "Out of memory?!");
			dprompt_free_mask |= FM_DONE;
			snprintf(done, done_size + 1, DPV_DONE_DEFAULT);
		}
	}
	if (pbar_size < done_size) {
		done_lsize = done_rsize = 0;
		*(done + pbar_size) = '\0';
		done_size = pbar_size;
	} else {
		/* Calculate left/right portions for mini-progressbar */
		done_lsize = (pbar_size - done_size) / 2;
		done_rsize = done_lsize;
		/* If not evenly divisible by 2, increment the right-side */
		if ((done_rsize + done_size + done_lsize) != pbar_size)
			done_rsize++;
	}

	/* Initialize "Fail" text */
	if (fail == NULL && (fail = msg_fail) == NULL) {
		if ((fail = getenv(ENV_MSG_FAIL)) != NULL)
			fail_size = strlen(fail);
		else {
			fail_size = strlen(DPV_FAIL_DEFAULT);
			if ((fail = malloc(fail_size + 1)) == NULL)
				errx(EXIT_FAILURE, "Out of memory?!");
			dprompt_free_mask |= FM_FAIL;
			snprintf(fail, fail_size + 1, DPV_FAIL_DEFAULT);
		}
	}
	if (pbar_size < fail_size) {
		fail_lsize = fail_rsize = 0;
		*(fail + pbar_size) = '\0';
		fail_size = pbar_size;
	} else {
		/* Calculate left/right portions for mini-progressbar */
		fail_lsize = (pbar_size - fail_size) / 2;
		fail_rsize = fail_lsize;
		/* If not evenly divisible by 2, increment the right-side */
		if ((fail_rsize + fail_size + fail_lsize) != pbar_size)
			fail_rsize++;
	}

	/* Initialize "Pending" text */
	if (pend == NULL && (pend = msg_pending) == NULL) {
		if ((pend = getenv(ENV_MSG_PENDING)) != NULL)
			pend_size = strlen(pend);
		else {
			pend_size = strlen(DPV_PENDING_DEFAULT);
			if ((pend = malloc(pend_size + 1)) == NULL)
				errx(EXIT_FAILURE, "Out of memory?!");
			dprompt_free_mask |= FM_PEND;
			snprintf(pend, pend_size + 1, DPV_PENDING_DEFAULT);
		}
	}
	if (pbar_size < pend_size) {
		pend_lsize = pend_rsize = 0;
		*(pend + pbar_size) = '\0';
		pend_size = pbar_size;
	} else {
		/* Calculate left/right portions for mini-progressbar */
		pend_lsize = (pbar_size - pend_size) / 2;
		pend_rsize = pend_lsize;
		/* If not evenly divisible by 2, increment the right-side */
		if ((pend_rsize + pend_lsize + pend_size) != pbar_size)
			pend_rsize++;
	}

	if (debug)
		warnx("label_size = %i pbar_size = %i", label_size, pbar_size);

	dprompt_clear();
}

/*
 * Clear the [X]dialog(1) `--gauge' prompt buffer.
 */
void
dprompt_clear(void)
{

	*dprompt = '\0';
	dprompt_pos = dprompt;
}

/*
 * Append to the [X]dialog(1) `--gauge' prompt buffer. Syntax is like printf(3)
 * and returns the number of bytes appended to the buffer.
 */
int
dprompt_add(const char *format, ...)
{
	int len;
	va_list ap;

	if (dprompt_pos >= (dprompt + PROMPT_MAX))
		return (0);

	va_start(ap, format);
	len = vsnprintf(dprompt_pos, (size_t)(PROMPT_MAX -
	    (dprompt_pos - dprompt)), format, ap);
	va_end(ap);
	if (len == -1)
		errx(EXIT_FAILURE, "%s: Oops, dprompt buffer overflow",
		    __func__);

	if ((dprompt_pos + len) < (dprompt + PROMPT_MAX))
		dprompt_pos += len;
	else
		dprompt_pos = dprompt + PROMPT_MAX;

	return (len);
}

/*
 * Append active files to the [X]dialog(1) `--gauge' prompt buffer. Syntax
 * requires a pointer to the head of the dpv_file_node linked-list. Returns the
 * number of files processed successfully.
 */
static int
dprompt_add_files(struct dpv_file_node *file_list,
    struct dpv_file_node *curfile, int pct)
{
	char c;
	char bold_code = 'b'; /* default: enabled */
	char color_code = '4'; /* default: blue */
	uint8_t after_curfile = curfile != NULL ? FALSE : TRUE;
	uint8_t nls = 0;
	char *cp;
	char *lastline;
	char *name;
	const char *bg_code;
	const char *estext;
	const char *format;
	enum dprompt_state dstate;
	int estext_lsize;
	int estext_rsize;
	int estext_size;
	int flabel_size;
	int hlen;
	int lsize;
	int nlines = 0;
	int nthfile = 0;
	int pwidth;
	int rsize;
	struct dpv_file_node *fp;
	char flabel[FLABEL_MAX + 1];
	char human[32];
	char pbar[pbar_size + 16]; /* +15 for optional color */
	char pbar_cap[sizeof(pbar)];
	char pbar_fill[sizeof(pbar)];


	/* Override color defaults with that of main progress bar */
	if (use_colors || use_shadow) { /* NB: shadow enables color */
		color_code = gauge_color[0];
		/* NB: str[1] aka bg is unused */
		bold_code = gauge_color[2];
	}

	/*
	 * Create mini-progressbar for current file (if applicable)
	 */
	*pbar = '\0';
	if (pbar_size >= 0 && pct >= 0 && curfile != NULL &&
	    (curfile->length >= 0 || dialog_test)) {
		snprintf(pbar, pbar_size + 1, "%*s%3u%%%*s", pct_lsize, "",
		    pct, pct_rsize, "");
		if (use_color) {
			/* Calculate the fill-width of progressbar */
			pwidth = pct * pbar_size / 100;
			/* Round up based on one-tenth of a percent */
			if ((pct * pbar_size % 100) > 50)
				pwidth++;

			/*
			 * Make two copies of pbar. Make one represent the fill
			 * and the other the remainder (cap). We'll insert the
			 * ANSI delimiter in between.
			 */
			*pbar_fill = '\0';
			*pbar_cap = '\0';
			strncat(pbar_fill, (const char *)(pbar), dwidth);
			*(pbar_fill + pwidth) = '\0';
			strncat(pbar_cap, (const char *)(pbar+pwidth), dwidth);

			/* Finalize the mini [color] progressbar */
			snprintf(pbar, sizeof(pbar),
			    "\\Z%c\\Zr\\Z%c%s%s%s\\Zn", bold_code, color_code,
			    pbar_fill, "\\ZR", pbar_cap);
		}
	}

	for (fp = file_list; fp != NULL; fp = fp->next) {
		flabel_size = label_size;
		name = fp->name;
		nthfile++;

		/*
		 * Support multiline filenames (where the filename is taken as
		 * the last line and the text leading up to the last line can
		 * be used as (for example) a heading/separator between files.
		 */
		if (use_dialog)
			nls = dialog_prompt_nlstate(pprompt);
		nlines += dialog_prompt_numlines(name, nls);
		lastline = dialog_prompt_lastline(name, 1);
		if (name != lastline) {
			c = *lastline;
			*lastline = '\0';
			dprompt_add("%s", name);
			*lastline = c;
			name = lastline;
		}

		/* Support color codes (for dialog(1,3)) in file names */
		if ((use_dialog || use_libdialog) && use_color) {
			cp = name;
			while (*cp != '\0') {
				if (*cp == '\\' && *(cp + 1) != '\0' &&
				    *(++cp) == 'Z' && *(cp + 1) != '\0') {
					cp++;
					flabel_size += 3;
				}
				cp++;
			}
			if (flabel_size > FLABEL_MAX)
				flabel_size = FLABEL_MAX;
		}

		/* If no mini-progressbar, increase label width */
		if (pbar_size < 0 && flabel_size <= FLABEL_MAX - 2 &&
		    no_labels == FALSE)
			flabel_size += 2;

		/* If name is too long, add an ellipsis */
		if (snprintf(flabel, flabel_size + 1, "%s", name) >
		    flabel_size) sprintf(flabel + flabel_size - 3, "...");

		/*
		 * Append the label (processing the current file differently)
		 */
		if (fp == curfile && pct < 100) {
			/*
			 * Add an ellipsis to current file name if it will fit.
			 * There may be an ellipsis already from truncating the
			 * label (in which case, we already have one).
			 */
			cp = flabel + strlen(flabel);
			if (cp < (flabel + flabel_size))
				snprintf(cp, flabel_size -
				    (cp - flabel) + 1, "...");

			/* Append label (with spinner and optional color) */
			dprompt_add("%s%-*s%s %c", use_color ? "\\Zb" : "",
			    flabel_size, flabel, use_color ? "\\Zn" : "",
			    spin_char());
		} else
			dprompt_add("%-*s%s %s", flabel_size,
			    flabel, use_color ? "\\Zn" : "", " ");

		/*
		 * Append pbar/status (processing the current file differently)
		 */
		dstate = DPROMPT_NONE;
		if (fp->msg != NULL)
			dstate = DPROMPT_CUSTOM_MSG;
		else if (pbar_size < 0)
			dstate = DPROMPT_NONE;
		else if (pbar_size < 4)
			dstate = DPROMPT_MINIMAL;
		else if (after_curfile)
			dstate = DPROMPT_PENDING;
		else if (fp == curfile) {
			if (*pbar == '\0') {
				if (fp->length < 0)
					dstate = DPROMPT_DETAILS;
				else if (fp->status == DPV_STATUS_RUNNING)
					dstate = DPROMPT_DETAILS;
				else
					dstate = DPROMPT_END_STATE;
			}
			else if (dialog_test) /* status/length ignored */
				dstate = pct < 100 ?
				    DPROMPT_PBAR : DPROMPT_END_STATE;
			else if (fp->status == DPV_STATUS_RUNNING)
				dstate = fp->length < 0 ?
				    DPROMPT_DETAILS : DPROMPT_PBAR;
			else /* not running */
				dstate = fp->length < 0 ?
				    DPROMPT_DETAILS : DPROMPT_END_STATE;
		} else { /* before curfile */
			if (dialog_test)
				dstate = DPROMPT_END_STATE;
			else
				dstate = fp->length < 0 ?
				    DPROMPT_DETAILS : DPROMPT_END_STATE;
		}
		format = use_color ?
		    " [\\Z%c%s%-*s%s%-*s\\Zn]\\n" :
		    " [%-*s%s%-*s]\\n";
		if (fp->status == DPV_STATUS_FAILED) {
			bg_code = "\\Zr\\Z1"; /* Red */
			estext_lsize = fail_lsize;
			estext_rsize = fail_rsize;
			estext_size = fail_size;
			estext = fail;
		} else { /* e.g., DPV_STATUS_DONE */
			bg_code = "\\Zr\\Z2"; /* Green */
			estext_lsize = done_lsize;
			estext_rsize = done_rsize;
			estext_size = done_size;
			estext = done;
		}
		switch (dstate) {
		case DPROMPT_PENDING: /* Future file(s) */
			dprompt_add(" [%-*s%s%-*s]\\n",
			    pend_lsize, "", pend, pend_rsize, "");
			break;
		case DPROMPT_PBAR: /* Current file */
			dprompt_add(" [%s]\\n", pbar);
			break;
		case DPROMPT_END_STATE: /* Past/Current file(s) */
			if (use_color)
				dprompt_add(format, bold_code, bg_code,
				    estext_lsize, "", estext,
				    estext_rsize, "");
			else
				dprompt_add(format,
				    estext_lsize, "", estext,
				    estext_rsize, "");
			break;
		case DPROMPT_DETAILS: /* Past/Current file(s) */
			humanize_number(human, pbar_size + 2, fp->read, "",
			    HN_AUTOSCALE, HN_NOSPACE | HN_DIVISOR_1000);

			/* Calculate center alignment */
			hlen = (int)strlen(human);
			lsize = (pbar_size - hlen) / 2;
			rsize = lsize;
			if ((lsize+hlen+rsize) != pbar_size)
				rsize++;

			if (use_color)
				dprompt_add(format, bold_code, bg_code,
				    lsize, "", human, rsize, "");
			else
				dprompt_add(format,
				    lsize, "", human, rsize, "");
			break;
		case DPROMPT_CUSTOM_MSG: /* File-specific message override */
			snprintf(msg, PROMPT_MAX + 1, "%s", fp->msg);
			if (pbar_size < (mesg_size = strlen(msg))) {
				mesg_lsize = mesg_rsize = 0;
				*(msg + pbar_size) = '\0';
				mesg_size = pbar_size;
			} else {
				mesg_lsize = (pbar_size - mesg_size) / 2;
				mesg_rsize = mesg_lsize;
				if ((mesg_rsize + mesg_size + mesg_lsize)
				    != pbar_size)
					mesg_rsize++;
			}
			if (use_color)
				dprompt_add(format, bold_code, bg_code,
				    mesg_lsize, "", msg, mesg_rsize, "");
			else
				dprompt_add(format, mesg_lsize, "", msg,
				    mesg_rsize, "");
			break;
		case DPROMPT_MINIMAL: /* Short progress bar, minimal room */
			if (use_color)
				dprompt_add(format, bold_code, bg_code,
				    pbar_size, "", "", 0, "");
			else
				dprompt_add(format, pbar_size, "", "", 0, "");
			break;
		case DPROMPT_NONE: /* pbar_size < 0 */
			/* FALLTHROUGH */
		default:
			dprompt_add(" \\n");
			/*
			 * NB: Leading space required for the case when
			 * spin_char() returns a single backslash [\] which
			 * without the space, changes the meaning of `\n'
			 */
		}

		/* Stop building if we've hit the internal limit */
		if (nthfile >= display_limit)
			break;

		/* If this is the current file, all others are pending */
		if (fp == curfile)
			after_curfile = TRUE;
	}

	/*
	 * Since we cannot change the height/width of the [X]dialog(1) widget
	 * after spawn, to make things look nice let's pad the height so that
	 * the `-a text' always appears in the same spot.
	 *
	 * NOTE: fheight is calculated in dprompt_init(). It represents the
	 * maximum height required to display the set of items (broken up into
	 * pieces of display_limit chunks) whose names contain the most
	 * newlines for any given set.
	 */
	while (nlines < fheight) {
		dprompt_add("\n");
		nlines++;
	}

	return (nthfile);
}

/*
 * Process the dpv_file_node linked-list of named files, re-generating the
 * [X]dialog(1) `--gauge' prompt text for the current state of transfers.
 */
void
dprompt_recreate(struct dpv_file_node *file_list,
    struct dpv_file_node *curfile, int pct)
{
	size_t len;

	/*
	 * Re-Build the prompt text
	 */
	dprompt_clear();
	if (display_limit > 0)
		dprompt_add_files(file_list, curfile, pct);

	/* Xdialog(1) requires newlines (a) escaped and (b) in triplicate */
	if (use_xdialog) {
		/* Replace `\n' with `\n\\n\n' in dprompt */
		len = strlen(dprompt);
		len += strcount(dprompt, "\\n") * 5; /* +5 chars per count */
		if (len > PROMPT_MAX)
			errx(EXIT_FAILURE, "%s: Oops, dprompt buffer overflow "
			    "(%zu > %i)", __func__, len, PROMPT_MAX);
		if (replaceall(dprompt, "\\n", "\n\\n\n") < 0)
			err(EXIT_FAILURE, "%s: replaceall()", __func__);
	}
	else if (use_libdialog)
		strexpandnl(dprompt);
}

/*
 * Print the [X]dialog(1) `--gauge' prompt text to a buffer.
 */
int
dprompt_sprint(char * restrict str, const char *prefix, const char *append)
{

	return (snprintf(str, PROMPT_MAX, "%s%s%s%s", use_color ? "\\Zn" : "",
	    prefix ? prefix : "", dprompt, append ? append : ""));
}

/*
 * Print the [X]dialog(1) `--gauge' prompt text to file descriptor fd (could
 * be STDOUT_FILENO or a pipe(2) file descriptor to actual [X]dialog(1)).
 */
void
dprompt_dprint(int fd, const char *prefix, const char *append, int overall)
{
	int percent = gauge_percent;

	if (overall >= 0 && overall <= 100)
		gauge_percent = percent = overall;
	dprintf(fd, "XXX\n%s%s%s%s\nXXX\n%i\n", use_color ? "\\Zn" : "",
	    prefix ? prefix : "", dprompt, append ? append : "", percent);
	fsync(fd);
}

/*
 * Print the dialog(3) `gauge' prompt text using libdialog.
 */
void
dprompt_libprint(const char *prefix, const char *append, int overall)
{
	int percent = gauge_percent;
	char buf[DPV_PPROMPT_MAX + DPV_APROMPT_MAX + DPV_DISPLAY_LIMIT * 1024];

	dprompt_sprint(buf, prefix, append);

	if (overall >= 0 && overall <= 100)
		gauge_percent = percent = overall;
	gauge = dlg_reallocate_gauge(gauge, title == NULL ? "" : title,
	    buf, dheight, dwidth, percent);
	dlg_update_gauge(gauge, percent);
}

/*
 * Free allocated items initialized by dprompt_init()
 */
void
dprompt_free(void)
{
	if ((dprompt_free_mask & FM_DONE) != 0) {
		dprompt_free_mask ^= FM_DONE;
		free(done);
		done = NULL;
	}
	if ((dprompt_free_mask & FM_FAIL) != 0) {
		dprompt_free_mask ^= FM_FAIL;
		free(fail);
		fail = NULL;
	}
	if ((dprompt_free_mask & FM_PEND) != 0) {
		dprompt_free_mask ^= FM_PEND;
		free(pend);
		pend = NULL;
	}
}